1
2
3
4
5
6
7 package org.apache.hadoop.hbase.thrift.generated;
8
9 import org.apache.commons.lang.builder.HashCodeBuilder;
10 import org.apache.thrift.scheme.IScheme;
11 import org.apache.thrift.scheme.SchemeFactory;
12 import org.apache.thrift.scheme.StandardScheme;
13
14 import org.apache.thrift.scheme.TupleScheme;
15 import org.apache.thrift.protocol.TTupleProtocol;
16 import org.apache.thrift.protocol.TProtocolException;
17 import org.apache.thrift.EncodingUtils;
18 import org.apache.thrift.TException;
19 import java.util.List;
20 import java.util.ArrayList;
21 import java.util.Map;
22 import java.util.HashMap;
23 import java.util.EnumMap;
24 import java.util.Set;
25 import java.util.HashSet;
26 import java.util.EnumSet;
27 import java.util.Collections;
28 import java.util.BitSet;
29 import java.nio.ByteBuffer;
30 import java.util.Arrays;
31 import org.slf4j.Logger;
32 import org.slf4j.LoggerFactory;
33
34
35
36
37 public class TAppend implements org.apache.thrift.TBase<TAppend, TAppend._Fields>, java.io.Serializable, Cloneable {
38 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TAppend");
39
40 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
41 private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2);
42 private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3);
43 private static final org.apache.thrift.protocol.TField VALUES_FIELD_DESC = new org.apache.thrift.protocol.TField("values", org.apache.thrift.protocol.TType.LIST, (short)4);
44
45 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
46 static {
47 schemes.put(StandardScheme.class, new TAppendStandardSchemeFactory());
48 schemes.put(TupleScheme.class, new TAppendTupleSchemeFactory());
49 }
50
51 public ByteBuffer table;
52 public ByteBuffer row;
53 public List<ByteBuffer> columns;
54 public List<ByteBuffer> values;
55
56
57 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
58 TABLE((short)1, "table"),
59 ROW((short)2, "row"),
60 COLUMNS((short)3, "columns"),
61 VALUES((short)4, "values");
62
63 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
64
65 static {
66 for (_Fields field : EnumSet.allOf(_Fields.class)) {
67 byName.put(field.getFieldName(), field);
68 }
69 }
70
71
72
73
74 public static _Fields findByThriftId(int fieldId) {
75 switch(fieldId) {
76 case 1:
77 return TABLE;
78 case 2:
79 return ROW;
80 case 3:
81 return COLUMNS;
82 case 4:
83 return VALUES;
84 default:
85 return null;
86 }
87 }
88
89
90
91
92
93 public static _Fields findByThriftIdOrThrow(int fieldId) {
94 _Fields fields = findByThriftId(fieldId);
95 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
96 return fields;
97 }
98
99
100
101
102 public static _Fields findByName(String name) {
103 return byName.get(name);
104 }
105
106 private final short _thriftId;
107 private final String _fieldName;
108
109 _Fields(short thriftId, String fieldName) {
110 _thriftId = thriftId;
111 _fieldName = fieldName;
112 }
113
114 public short getThriftFieldId() {
115 return _thriftId;
116 }
117
118 public String getFieldName() {
119 return _fieldName;
120 }
121 }
122
123
124 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
125 static {
126 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
127 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.DEFAULT,
128 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
129 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT,
130 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
131 tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT,
132 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
133 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
134 tmpMap.put(_Fields.VALUES, new org.apache.thrift.meta_data.FieldMetaData("values", org.apache.thrift.TFieldRequirementType.DEFAULT,
135 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
136 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))));
137 metaDataMap = Collections.unmodifiableMap(tmpMap);
138 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TAppend.class, metaDataMap);
139 }
140
141 public TAppend() {
142 }
143
144 public TAppend(
145 ByteBuffer table,
146 ByteBuffer row,
147 List<ByteBuffer> columns,
148 List<ByteBuffer> values)
149 {
150 this();
151 this.table = table;
152 this.row = row;
153 this.columns = columns;
154 this.values = values;
155 }
156
157
158
159
160 public TAppend(TAppend other) {
161 if (other.isSetTable()) {
162 this.table = other.table;
163 }
164 if (other.isSetRow()) {
165 this.row = other.row;
166 }
167 if (other.isSetColumns()) {
168 List<ByteBuffer> __this__columns = new ArrayList<ByteBuffer>();
169 for (ByteBuffer other_element : other.columns) {
170 __this__columns.add(other_element);
171 }
172 this.columns = __this__columns;
173 }
174 if (other.isSetValues()) {
175 List<ByteBuffer> __this__values = new ArrayList<ByteBuffer>();
176 for (ByteBuffer other_element : other.values) {
177 __this__values.add(other_element);
178 }
179 this.values = __this__values;
180 }
181 }
182
183 public TAppend deepCopy() {
184 return new TAppend(this);
185 }
186
187 @Override
188 public void clear() {
189 this.table = null;
190 this.row = null;
191 this.columns = null;
192 this.values = null;
193 }
194
195 public byte[] getTable() {
196 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
197 return table == null ? null : table.array();
198 }
199
200 public ByteBuffer bufferForTable() {
201 return table;
202 }
203
204 public TAppend setTable(byte[] table) {
205 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
206 return this;
207 }
208
209 public TAppend setTable(ByteBuffer table) {
210 this.table = table;
211 return this;
212 }
213
214 public void unsetTable() {
215 this.table = null;
216 }
217
218
219 public boolean isSetTable() {
220 return this.table != null;
221 }
222
223 public void setTableIsSet(boolean value) {
224 if (!value) {
225 this.table = null;
226 }
227 }
228
229 public byte[] getRow() {
230 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
231 return row == null ? null : row.array();
232 }
233
234 public ByteBuffer bufferForRow() {
235 return row;
236 }
237
238 public TAppend setRow(byte[] row) {
239 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
240 return this;
241 }
242
243 public TAppend setRow(ByteBuffer row) {
244 this.row = row;
245 return this;
246 }
247
248 public void unsetRow() {
249 this.row = null;
250 }
251
252
253 public boolean isSetRow() {
254 return this.row != null;
255 }
256
257 public void setRowIsSet(boolean value) {
258 if (!value) {
259 this.row = null;
260 }
261 }
262
263 public int getColumnsSize() {
264 return (this.columns == null) ? 0 : this.columns.size();
265 }
266
267 public java.util.Iterator<ByteBuffer> getColumnsIterator() {
268 return (this.columns == null) ? null : this.columns.iterator();
269 }
270
271 public void addToColumns(ByteBuffer elem) {
272 if (this.columns == null) {
273 this.columns = new ArrayList<ByteBuffer>();
274 }
275 this.columns.add(elem);
276 }
277
278 public List<ByteBuffer> getColumns() {
279 return this.columns;
280 }
281
282 public TAppend setColumns(List<ByteBuffer> columns) {
283 this.columns = columns;
284 return this;
285 }
286
287 public void unsetColumns() {
288 this.columns = null;
289 }
290
291
292 public boolean isSetColumns() {
293 return this.columns != null;
294 }
295
296 public void setColumnsIsSet(boolean value) {
297 if (!value) {
298 this.columns = null;
299 }
300 }
301
302 public int getValuesSize() {
303 return (this.values == null) ? 0 : this.values.size();
304 }
305
306 public java.util.Iterator<ByteBuffer> getValuesIterator() {
307 return (this.values == null) ? null : this.values.iterator();
308 }
309
310 public void addToValues(ByteBuffer elem) {
311 if (this.values == null) {
312 this.values = new ArrayList<ByteBuffer>();
313 }
314 this.values.add(elem);
315 }
316
317 public List<ByteBuffer> getValues() {
318 return this.values;
319 }
320
321 public TAppend setValues(List<ByteBuffer> values) {
322 this.values = values;
323 return this;
324 }
325
326 public void unsetValues() {
327 this.values = null;
328 }
329
330
331 public boolean isSetValues() {
332 return this.values != null;
333 }
334
335 public void setValuesIsSet(boolean value) {
336 if (!value) {
337 this.values = null;
338 }
339 }
340
341 public void setFieldValue(_Fields field, Object value) {
342 switch (field) {
343 case TABLE:
344 if (value == null) {
345 unsetTable();
346 } else {
347 setTable((ByteBuffer)value);
348 }
349 break;
350
351 case ROW:
352 if (value == null) {
353 unsetRow();
354 } else {
355 setRow((ByteBuffer)value);
356 }
357 break;
358
359 case COLUMNS:
360 if (value == null) {
361 unsetColumns();
362 } else {
363 setColumns((List<ByteBuffer>)value);
364 }
365 break;
366
367 case VALUES:
368 if (value == null) {
369 unsetValues();
370 } else {
371 setValues((List<ByteBuffer>)value);
372 }
373 break;
374
375 }
376 }
377
378 public Object getFieldValue(_Fields field) {
379 switch (field) {
380 case TABLE:
381 return getTable();
382
383 case ROW:
384 return getRow();
385
386 case COLUMNS:
387 return getColumns();
388
389 case VALUES:
390 return getValues();
391
392 }
393 throw new IllegalStateException();
394 }
395
396
397 public boolean isSet(_Fields field) {
398 if (field == null) {
399 throw new IllegalArgumentException();
400 }
401
402 switch (field) {
403 case TABLE:
404 return isSetTable();
405 case ROW:
406 return isSetRow();
407 case COLUMNS:
408 return isSetColumns();
409 case VALUES:
410 return isSetValues();
411 }
412 throw new IllegalStateException();
413 }
414
415 @Override
416 public boolean equals(Object that) {
417 if (that == null)
418 return false;
419 if (that instanceof TAppend)
420 return this.equals((TAppend)that);
421 return false;
422 }
423
424 public boolean equals(TAppend that) {
425 if (that == null)
426 return false;
427
428 boolean this_present_table = true && this.isSetTable();
429 boolean that_present_table = true && that.isSetTable();
430 if (this_present_table || that_present_table) {
431 if (!(this_present_table && that_present_table))
432 return false;
433 if (!this.table.equals(that.table))
434 return false;
435 }
436
437 boolean this_present_row = true && this.isSetRow();
438 boolean that_present_row = true && that.isSetRow();
439 if (this_present_row || that_present_row) {
440 if (!(this_present_row && that_present_row))
441 return false;
442 if (!this.row.equals(that.row))
443 return false;
444 }
445
446 boolean this_present_columns = true && this.isSetColumns();
447 boolean that_present_columns = true && that.isSetColumns();
448 if (this_present_columns || that_present_columns) {
449 if (!(this_present_columns && that_present_columns))
450 return false;
451 if (!this.columns.equals(that.columns))
452 return false;
453 }
454
455 boolean this_present_values = true && this.isSetValues();
456 boolean that_present_values = true && that.isSetValues();
457 if (this_present_values || that_present_values) {
458 if (!(this_present_values && that_present_values))
459 return false;
460 if (!this.values.equals(that.values))
461 return false;
462 }
463
464 return true;
465 }
466
467 @Override
468 public int hashCode() {
469 HashCodeBuilder builder = new HashCodeBuilder();
470
471 boolean present_table = true && (isSetTable());
472 builder.append(present_table);
473 if (present_table)
474 builder.append(table);
475
476 boolean present_row = true && (isSetRow());
477 builder.append(present_row);
478 if (present_row)
479 builder.append(row);
480
481 boolean present_columns = true && (isSetColumns());
482 builder.append(present_columns);
483 if (present_columns)
484 builder.append(columns);
485
486 boolean present_values = true && (isSetValues());
487 builder.append(present_values);
488 if (present_values)
489 builder.append(values);
490
491 return builder.toHashCode();
492 }
493
494 public int compareTo(TAppend other) {
495 if (!getClass().equals(other.getClass())) {
496 return getClass().getName().compareTo(other.getClass().getName());
497 }
498
499 int lastComparison = 0;
500 TAppend typedOther = (TAppend)other;
501
502 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
503 if (lastComparison != 0) {
504 return lastComparison;
505 }
506 if (isSetTable()) {
507 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
508 if (lastComparison != 0) {
509 return lastComparison;
510 }
511 }
512 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
513 if (lastComparison != 0) {
514 return lastComparison;
515 }
516 if (isSetRow()) {
517 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
518 if (lastComparison != 0) {
519 return lastComparison;
520 }
521 }
522 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns());
523 if (lastComparison != 0) {
524 return lastComparison;
525 }
526 if (isSetColumns()) {
527 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns);
528 if (lastComparison != 0) {
529 return lastComparison;
530 }
531 }
532 lastComparison = Boolean.valueOf(isSetValues()).compareTo(typedOther.isSetValues());
533 if (lastComparison != 0) {
534 return lastComparison;
535 }
536 if (isSetValues()) {
537 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.values, typedOther.values);
538 if (lastComparison != 0) {
539 return lastComparison;
540 }
541 }
542 return 0;
543 }
544
545 public _Fields fieldForId(int fieldId) {
546 return _Fields.findByThriftId(fieldId);
547 }
548
549 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
550 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
551 }
552
553 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
554 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
555 }
556
557 @Override
558 public String toString() {
559 StringBuilder sb = new StringBuilder("TAppend(");
560 boolean first = true;
561
562 sb.append("table:");
563 if (this.table == null) {
564 sb.append("null");
565 } else {
566 sb.append(this.table);
567 }
568 first = false;
569 if (!first) sb.append(", ");
570 sb.append("row:");
571 if (this.row == null) {
572 sb.append("null");
573 } else {
574 sb.append(this.row);
575 }
576 first = false;
577 if (!first) sb.append(", ");
578 sb.append("columns:");
579 if (this.columns == null) {
580 sb.append("null");
581 } else {
582 sb.append(this.columns);
583 }
584 first = false;
585 if (!first) sb.append(", ");
586 sb.append("values:");
587 if (this.values == null) {
588 sb.append("null");
589 } else {
590 sb.append(this.values);
591 }
592 first = false;
593 sb.append(")");
594 return sb.toString();
595 }
596
597 public void validate() throws org.apache.thrift.TException {
598
599
600 }
601
602 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
603 try {
604 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
605 } catch (org.apache.thrift.TException te) {
606 throw new java.io.IOException(te);
607 }
608 }
609
610 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
611 try {
612 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
613 } catch (org.apache.thrift.TException te) {
614 throw new java.io.IOException(te);
615 }
616 }
617
618 private static class TAppendStandardSchemeFactory implements SchemeFactory {
619 public TAppendStandardScheme getScheme() {
620 return new TAppendStandardScheme();
621 }
622 }
623
624 private static class TAppendStandardScheme extends StandardScheme<TAppend> {
625
626 public void read(org.apache.thrift.protocol.TProtocol iprot, TAppend struct) throws org.apache.thrift.TException {
627 org.apache.thrift.protocol.TField schemeField;
628 iprot.readStructBegin();
629 while (true)
630 {
631 schemeField = iprot.readFieldBegin();
632 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
633 break;
634 }
635 switch (schemeField.id) {
636 case 1:
637 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
638 struct.table = iprot.readBinary();
639 struct.setTableIsSet(true);
640 } else {
641 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
642 }
643 break;
644 case 2:
645 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
646 struct.row = iprot.readBinary();
647 struct.setRowIsSet(true);
648 } else {
649 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
650 }
651 break;
652 case 3:
653 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
654 {
655 org.apache.thrift.protocol.TList _list34 = iprot.readListBegin();
656 struct.columns = new ArrayList<ByteBuffer>(_list34.size);
657 for (int _i35 = 0; _i35 < _list34.size; ++_i35)
658 {
659 ByteBuffer _elem36;
660 _elem36 = iprot.readBinary();
661 struct.columns.add(_elem36);
662 }
663 iprot.readListEnd();
664 }
665 struct.setColumnsIsSet(true);
666 } else {
667 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
668 }
669 break;
670 case 4:
671 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
672 {
673 org.apache.thrift.protocol.TList _list37 = iprot.readListBegin();
674 struct.values = new ArrayList<ByteBuffer>(_list37.size);
675 for (int _i38 = 0; _i38 < _list37.size; ++_i38)
676 {
677 ByteBuffer _elem39;
678 _elem39 = iprot.readBinary();
679 struct.values.add(_elem39);
680 }
681 iprot.readListEnd();
682 }
683 struct.setValuesIsSet(true);
684 } else {
685 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
686 }
687 break;
688 default:
689 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
690 }
691 iprot.readFieldEnd();
692 }
693 iprot.readStructEnd();
694
695
696 struct.validate();
697 }
698
699 public void write(org.apache.thrift.protocol.TProtocol oprot, TAppend struct) throws org.apache.thrift.TException {
700 struct.validate();
701
702 oprot.writeStructBegin(STRUCT_DESC);
703 if (struct.table != null) {
704 oprot.writeFieldBegin(TABLE_FIELD_DESC);
705 oprot.writeBinary(struct.table);
706 oprot.writeFieldEnd();
707 }
708 if (struct.row != null) {
709 oprot.writeFieldBegin(ROW_FIELD_DESC);
710 oprot.writeBinary(struct.row);
711 oprot.writeFieldEnd();
712 }
713 if (struct.columns != null) {
714 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
715 {
716 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
717 for (ByteBuffer _iter40 : struct.columns)
718 {
719 oprot.writeBinary(_iter40);
720 }
721 oprot.writeListEnd();
722 }
723 oprot.writeFieldEnd();
724 }
725 if (struct.values != null) {
726 oprot.writeFieldBegin(VALUES_FIELD_DESC);
727 {
728 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.values.size()));
729 for (ByteBuffer _iter41 : struct.values)
730 {
731 oprot.writeBinary(_iter41);
732 }
733 oprot.writeListEnd();
734 }
735 oprot.writeFieldEnd();
736 }
737 oprot.writeFieldStop();
738 oprot.writeStructEnd();
739 }
740
741 }
742
743 private static class TAppendTupleSchemeFactory implements SchemeFactory {
744 public TAppendTupleScheme getScheme() {
745 return new TAppendTupleScheme();
746 }
747 }
748
749 private static class TAppendTupleScheme extends TupleScheme<TAppend> {
750
751 @Override
752 public void write(org.apache.thrift.protocol.TProtocol prot, TAppend struct) throws org.apache.thrift.TException {
753 TTupleProtocol oprot = (TTupleProtocol) prot;
754 BitSet optionals = new BitSet();
755 if (struct.isSetTable()) {
756 optionals.set(0);
757 }
758 if (struct.isSetRow()) {
759 optionals.set(1);
760 }
761 if (struct.isSetColumns()) {
762 optionals.set(2);
763 }
764 if (struct.isSetValues()) {
765 optionals.set(3);
766 }
767 oprot.writeBitSet(optionals, 4);
768 if (struct.isSetTable()) {
769 oprot.writeBinary(struct.table);
770 }
771 if (struct.isSetRow()) {
772 oprot.writeBinary(struct.row);
773 }
774 if (struct.isSetColumns()) {
775 {
776 oprot.writeI32(struct.columns.size());
777 for (ByteBuffer _iter42 : struct.columns)
778 {
779 oprot.writeBinary(_iter42);
780 }
781 }
782 }
783 if (struct.isSetValues()) {
784 {
785 oprot.writeI32(struct.values.size());
786 for (ByteBuffer _iter43 : struct.values)
787 {
788 oprot.writeBinary(_iter43);
789 }
790 }
791 }
792 }
793
794 @Override
795 public void read(org.apache.thrift.protocol.TProtocol prot, TAppend struct) throws org.apache.thrift.TException {
796 TTupleProtocol iprot = (TTupleProtocol) prot;
797 BitSet incoming = iprot.readBitSet(4);
798 if (incoming.get(0)) {
799 struct.table = iprot.readBinary();
800 struct.setTableIsSet(true);
801 }
802 if (incoming.get(1)) {
803 struct.row = iprot.readBinary();
804 struct.setRowIsSet(true);
805 }
806 if (incoming.get(2)) {
807 {
808 org.apache.thrift.protocol.TList _list44 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
809 struct.columns = new ArrayList<ByteBuffer>(_list44.size);
810 for (int _i45 = 0; _i45 < _list44.size; ++_i45)
811 {
812 ByteBuffer _elem46;
813 _elem46 = iprot.readBinary();
814 struct.columns.add(_elem46);
815 }
816 }
817 struct.setColumnsIsSet(true);
818 }
819 if (incoming.get(3)) {
820 {
821 org.apache.thrift.protocol.TList _list47 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
822 struct.values = new ArrayList<ByteBuffer>(_list47.size);
823 for (int _i48 = 0; _i48 < _list47.size; ++_i48)
824 {
825 ByteBuffer _elem49;
826 _elem49 = iprot.readBinary();
827 struct.values.add(_elem49);
828 }
829 }
830 struct.setValuesIsSet(true);
831 }
832 }
833 }
834
835 }
836