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