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 TRowResult implements org.apache.thrift.TBase<TRowResult, TRowResult._Fields>, java.io.Serializable, Cloneable {
38 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TRowResult");
39
40 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)1);
41 private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.MAP, (short)2);
42 private static final org.apache.thrift.protocol.TField SORTED_COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("sortedColumns", org.apache.thrift.protocol.TType.LIST, (short)3);
43
44 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
45 static {
46 schemes.put(StandardScheme.class, new TRowResultStandardSchemeFactory());
47 schemes.put(TupleScheme.class, new TRowResultTupleSchemeFactory());
48 }
49
50 public ByteBuffer row;
51 public Map<ByteBuffer,TCell> columns;
52 public List<TColumn> sortedColumns;
53
54
55 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
56 ROW((short)1, "row"),
57 COLUMNS((short)2, "columns"),
58 SORTED_COLUMNS((short)3, "sortedColumns");
59
60 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
61
62 static {
63 for (_Fields field : EnumSet.allOf(_Fields.class)) {
64 byName.put(field.getFieldName(), field);
65 }
66 }
67
68
69
70
71 public static _Fields findByThriftId(int fieldId) {
72 switch(fieldId) {
73 case 1:
74 return ROW;
75 case 2:
76 return COLUMNS;
77 case 3:
78 return SORTED_COLUMNS;
79 default:
80 return null;
81 }
82 }
83
84
85
86
87
88 public static _Fields findByThriftIdOrThrow(int fieldId) {
89 _Fields fields = findByThriftId(fieldId);
90 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
91 return fields;
92 }
93
94
95
96
97 public static _Fields findByName(String name) {
98 return byName.get(name);
99 }
100
101 private final short _thriftId;
102 private final String _fieldName;
103
104 _Fields(short thriftId, String fieldName) {
105 _thriftId = thriftId;
106 _fieldName = fieldName;
107 }
108
109 public short getThriftFieldId() {
110 return _thriftId;
111 }
112
113 public String getFieldName() {
114 return _fieldName;
115 }
116 }
117
118
119 private _Fields optionals[] = {_Fields.COLUMNS,_Fields.SORTED_COLUMNS};
120 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
121 static {
122 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
123 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT,
124 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")));
125 tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.OPTIONAL,
126 new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
127 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"),
128 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class))));
129 tmpMap.put(_Fields.SORTED_COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("sortedColumns", org.apache.thrift.TFieldRequirementType.OPTIONAL,
130 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
131 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TColumn.class))));
132 metaDataMap = Collections.unmodifiableMap(tmpMap);
133 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TRowResult.class, metaDataMap);
134 }
135
136 public TRowResult() {
137 }
138
139 public TRowResult(
140 ByteBuffer row)
141 {
142 this();
143 this.row = row;
144 }
145
146
147
148
149 public TRowResult(TRowResult other) {
150 if (other.isSetRow()) {
151 this.row = other.row;
152 }
153 if (other.isSetColumns()) {
154 Map<ByteBuffer,TCell> __this__columns = new HashMap<ByteBuffer,TCell>();
155 for (Map.Entry<ByteBuffer, TCell> other_element : other.columns.entrySet()) {
156
157 ByteBuffer other_element_key = other_element.getKey();
158 TCell other_element_value = other_element.getValue();
159
160 ByteBuffer __this__columns_copy_key = other_element_key;
161
162 TCell __this__columns_copy_value = new TCell(other_element_value);
163
164 __this__columns.put(__this__columns_copy_key, __this__columns_copy_value);
165 }
166 this.columns = __this__columns;
167 }
168 if (other.isSetSortedColumns()) {
169 List<TColumn> __this__sortedColumns = new ArrayList<TColumn>();
170 for (TColumn other_element : other.sortedColumns) {
171 __this__sortedColumns.add(new TColumn(other_element));
172 }
173 this.sortedColumns = __this__sortedColumns;
174 }
175 }
176
177 public TRowResult deepCopy() {
178 return new TRowResult(this);
179 }
180
181 @Override
182 public void clear() {
183 this.row = null;
184 this.columns = null;
185 this.sortedColumns = null;
186 }
187
188 public byte[] getRow() {
189 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
190 return row == null ? null : row.array();
191 }
192
193 public ByteBuffer bufferForRow() {
194 return row;
195 }
196
197 public TRowResult setRow(byte[] row) {
198 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
199 return this;
200 }
201
202 public TRowResult setRow(ByteBuffer row) {
203 this.row = row;
204 return this;
205 }
206
207 public void unsetRow() {
208 this.row = null;
209 }
210
211
212 public boolean isSetRow() {
213 return this.row != null;
214 }
215
216 public void setRowIsSet(boolean value) {
217 if (!value) {
218 this.row = null;
219 }
220 }
221
222 public int getColumnsSize() {
223 return (this.columns == null) ? 0 : this.columns.size();
224 }
225
226 public void putToColumns(ByteBuffer key, TCell val) {
227 if (this.columns == null) {
228 this.columns = new HashMap<ByteBuffer,TCell>();
229 }
230 this.columns.put(key, val);
231 }
232
233 public Map<ByteBuffer,TCell> getColumns() {
234 return this.columns;
235 }
236
237 public TRowResult setColumns(Map<ByteBuffer,TCell> columns) {
238 this.columns = columns;
239 return this;
240 }
241
242 public void unsetColumns() {
243 this.columns = null;
244 }
245
246
247 public boolean isSetColumns() {
248 return this.columns != null;
249 }
250
251 public void setColumnsIsSet(boolean value) {
252 if (!value) {
253 this.columns = null;
254 }
255 }
256
257 public int getSortedColumnsSize() {
258 return (this.sortedColumns == null) ? 0 : this.sortedColumns.size();
259 }
260
261 public java.util.Iterator<TColumn> getSortedColumnsIterator() {
262 return (this.sortedColumns == null) ? null : this.sortedColumns.iterator();
263 }
264
265 public void addToSortedColumns(TColumn elem) {
266 if (this.sortedColumns == null) {
267 this.sortedColumns = new ArrayList<TColumn>();
268 }
269 this.sortedColumns.add(elem);
270 }
271
272 public List<TColumn> getSortedColumns() {
273 return this.sortedColumns;
274 }
275
276 public TRowResult setSortedColumns(List<TColumn> sortedColumns) {
277 this.sortedColumns = sortedColumns;
278 return this;
279 }
280
281 public void unsetSortedColumns() {
282 this.sortedColumns = null;
283 }
284
285
286 public boolean isSetSortedColumns() {
287 return this.sortedColumns != null;
288 }
289
290 public void setSortedColumnsIsSet(boolean value) {
291 if (!value) {
292 this.sortedColumns = null;
293 }
294 }
295
296 public void setFieldValue(_Fields field, Object value) {
297 switch (field) {
298 case ROW:
299 if (value == null) {
300 unsetRow();
301 } else {
302 setRow((ByteBuffer)value);
303 }
304 break;
305
306 case COLUMNS:
307 if (value == null) {
308 unsetColumns();
309 } else {
310 setColumns((Map<ByteBuffer,TCell>)value);
311 }
312 break;
313
314 case SORTED_COLUMNS:
315 if (value == null) {
316 unsetSortedColumns();
317 } else {
318 setSortedColumns((List<TColumn>)value);
319 }
320 break;
321
322 }
323 }
324
325 public Object getFieldValue(_Fields field) {
326 switch (field) {
327 case ROW:
328 return getRow();
329
330 case COLUMNS:
331 return getColumns();
332
333 case SORTED_COLUMNS:
334 return getSortedColumns();
335
336 }
337 throw new IllegalStateException();
338 }
339
340
341 public boolean isSet(_Fields field) {
342 if (field == null) {
343 throw new IllegalArgumentException();
344 }
345
346 switch (field) {
347 case ROW:
348 return isSetRow();
349 case COLUMNS:
350 return isSetColumns();
351 case SORTED_COLUMNS:
352 return isSetSortedColumns();
353 }
354 throw new IllegalStateException();
355 }
356
357 @Override
358 public boolean equals(Object that) {
359 if (that == null)
360 return false;
361 if (that instanceof TRowResult)
362 return this.equals((TRowResult)that);
363 return false;
364 }
365
366 public boolean equals(TRowResult that) {
367 if (that == null)
368 return false;
369
370 boolean this_present_row = true && this.isSetRow();
371 boolean that_present_row = true && that.isSetRow();
372 if (this_present_row || that_present_row) {
373 if (!(this_present_row && that_present_row))
374 return false;
375 if (!this.row.equals(that.row))
376 return false;
377 }
378
379 boolean this_present_columns = true && this.isSetColumns();
380 boolean that_present_columns = true && that.isSetColumns();
381 if (this_present_columns || that_present_columns) {
382 if (!(this_present_columns && that_present_columns))
383 return false;
384 if (!this.columns.equals(that.columns))
385 return false;
386 }
387
388 boolean this_present_sortedColumns = true && this.isSetSortedColumns();
389 boolean that_present_sortedColumns = true && that.isSetSortedColumns();
390 if (this_present_sortedColumns || that_present_sortedColumns) {
391 if (!(this_present_sortedColumns && that_present_sortedColumns))
392 return false;
393 if (!this.sortedColumns.equals(that.sortedColumns))
394 return false;
395 }
396
397 return true;
398 }
399
400 @Override
401 public int hashCode() {
402 HashCodeBuilder builder = new HashCodeBuilder();
403
404 boolean present_row = true && (isSetRow());
405 builder.append(present_row);
406 if (present_row)
407 builder.append(row);
408
409 boolean present_columns = true && (isSetColumns());
410 builder.append(present_columns);
411 if (present_columns)
412 builder.append(columns);
413
414 boolean present_sortedColumns = true && (isSetSortedColumns());
415 builder.append(present_sortedColumns);
416 if (present_sortedColumns)
417 builder.append(sortedColumns);
418
419 return builder.toHashCode();
420 }
421
422 public int compareTo(TRowResult other) {
423 if (!getClass().equals(other.getClass())) {
424 return getClass().getName().compareTo(other.getClass().getName());
425 }
426
427 int lastComparison = 0;
428 TRowResult typedOther = (TRowResult)other;
429
430 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
431 if (lastComparison != 0) {
432 return lastComparison;
433 }
434 if (isSetRow()) {
435 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
436 if (lastComparison != 0) {
437 return lastComparison;
438 }
439 }
440 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns());
441 if (lastComparison != 0) {
442 return lastComparison;
443 }
444 if (isSetColumns()) {
445 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns);
446 if (lastComparison != 0) {
447 return lastComparison;
448 }
449 }
450 lastComparison = Boolean.valueOf(isSetSortedColumns()).compareTo(typedOther.isSetSortedColumns());
451 if (lastComparison != 0) {
452 return lastComparison;
453 }
454 if (isSetSortedColumns()) {
455 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sortedColumns, typedOther.sortedColumns);
456 if (lastComparison != 0) {
457 return lastComparison;
458 }
459 }
460 return 0;
461 }
462
463 public _Fields fieldForId(int fieldId) {
464 return _Fields.findByThriftId(fieldId);
465 }
466
467 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
468 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
469 }
470
471 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
472 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
473 }
474
475 @Override
476 public String toString() {
477 StringBuilder sb = new StringBuilder("TRowResult(");
478 boolean first = true;
479
480 sb.append("row:");
481 if (this.row == null) {
482 sb.append("null");
483 } else {
484 sb.append(this.row);
485 }
486 first = false;
487 if (isSetColumns()) {
488 if (!first) sb.append(", ");
489 sb.append("columns:");
490 if (this.columns == null) {
491 sb.append("null");
492 } else {
493 sb.append(this.columns);
494 }
495 first = false;
496 }
497 if (isSetSortedColumns()) {
498 if (!first) sb.append(", ");
499 sb.append("sortedColumns:");
500 if (this.sortedColumns == null) {
501 sb.append("null");
502 } else {
503 sb.append(this.sortedColumns);
504 }
505 first = false;
506 }
507 sb.append(")");
508 return sb.toString();
509 }
510
511 public void validate() throws org.apache.thrift.TException {
512
513
514 }
515
516 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
517 try {
518 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
519 } catch (org.apache.thrift.TException te) {
520 throw new java.io.IOException(te);
521 }
522 }
523
524 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
525 try {
526 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
527 } catch (org.apache.thrift.TException te) {
528 throw new java.io.IOException(te);
529 }
530 }
531
532 private static class TRowResultStandardSchemeFactory implements SchemeFactory {
533 public TRowResultStandardScheme getScheme() {
534 return new TRowResultStandardScheme();
535 }
536 }
537
538 private static class TRowResultStandardScheme extends StandardScheme<TRowResult> {
539
540 public void read(org.apache.thrift.protocol.TProtocol iprot, TRowResult struct) throws org.apache.thrift.TException {
541 org.apache.thrift.protocol.TField schemeField;
542 iprot.readStructBegin();
543 while (true)
544 {
545 schemeField = iprot.readFieldBegin();
546 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
547 break;
548 }
549 switch (schemeField.id) {
550 case 1:
551 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
552 struct.row = iprot.readBinary();
553 struct.setRowIsSet(true);
554 } else {
555 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
556 }
557 break;
558 case 2:
559 if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
560 {
561 org.apache.thrift.protocol.TMap _map8 = iprot.readMapBegin();
562 struct.columns = new HashMap<ByteBuffer,TCell>(2*_map8.size);
563 for (int _i9 = 0; _i9 < _map8.size; ++_i9)
564 {
565 ByteBuffer _key10;
566 TCell _val11;
567 _key10 = iprot.readBinary();
568 _val11 = new TCell();
569 _val11.read(iprot);
570 struct.columns.put(_key10, _val11);
571 }
572 iprot.readMapEnd();
573 }
574 struct.setColumnsIsSet(true);
575 } else {
576 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
577 }
578 break;
579 case 3:
580 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
581 {
582 org.apache.thrift.protocol.TList _list12 = iprot.readListBegin();
583 struct.sortedColumns = new ArrayList<TColumn>(_list12.size);
584 for (int _i13 = 0; _i13 < _list12.size; ++_i13)
585 {
586 TColumn _elem14;
587 _elem14 = new TColumn();
588 _elem14.read(iprot);
589 struct.sortedColumns.add(_elem14);
590 }
591 iprot.readListEnd();
592 }
593 struct.setSortedColumnsIsSet(true);
594 } else {
595 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
596 }
597 break;
598 default:
599 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
600 }
601 iprot.readFieldEnd();
602 }
603 iprot.readStructEnd();
604
605
606 struct.validate();
607 }
608
609 public void write(org.apache.thrift.protocol.TProtocol oprot, TRowResult struct) throws org.apache.thrift.TException {
610 struct.validate();
611
612 oprot.writeStructBegin(STRUCT_DESC);
613 if (struct.row != null) {
614 oprot.writeFieldBegin(ROW_FIELD_DESC);
615 oprot.writeBinary(struct.row);
616 oprot.writeFieldEnd();
617 }
618 if (struct.columns != null) {
619 if (struct.isSetColumns()) {
620 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
621 {
622 oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
623 for (Map.Entry<ByteBuffer, TCell> _iter15 : struct.columns.entrySet())
624 {
625 oprot.writeBinary(_iter15.getKey());
626 _iter15.getValue().write(oprot);
627 }
628 oprot.writeMapEnd();
629 }
630 oprot.writeFieldEnd();
631 }
632 }
633 if (struct.sortedColumns != null) {
634 if (struct.isSetSortedColumns()) {
635 oprot.writeFieldBegin(SORTED_COLUMNS_FIELD_DESC);
636 {
637 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.sortedColumns.size()));
638 for (TColumn _iter16 : struct.sortedColumns)
639 {
640 _iter16.write(oprot);
641 }
642 oprot.writeListEnd();
643 }
644 oprot.writeFieldEnd();
645 }
646 }
647 oprot.writeFieldStop();
648 oprot.writeStructEnd();
649 }
650
651 }
652
653 private static class TRowResultTupleSchemeFactory implements SchemeFactory {
654 public TRowResultTupleScheme getScheme() {
655 return new TRowResultTupleScheme();
656 }
657 }
658
659 private static class TRowResultTupleScheme extends TupleScheme<TRowResult> {
660
661 @Override
662 public void write(org.apache.thrift.protocol.TProtocol prot, TRowResult struct) throws org.apache.thrift.TException {
663 TTupleProtocol oprot = (TTupleProtocol) prot;
664 BitSet optionals = new BitSet();
665 if (struct.isSetRow()) {
666 optionals.set(0);
667 }
668 if (struct.isSetColumns()) {
669 optionals.set(1);
670 }
671 if (struct.isSetSortedColumns()) {
672 optionals.set(2);
673 }
674 oprot.writeBitSet(optionals, 3);
675 if (struct.isSetRow()) {
676 oprot.writeBinary(struct.row);
677 }
678 if (struct.isSetColumns()) {
679 {
680 oprot.writeI32(struct.columns.size());
681 for (Map.Entry<ByteBuffer, TCell> _iter17 : struct.columns.entrySet())
682 {
683 oprot.writeBinary(_iter17.getKey());
684 _iter17.getValue().write(oprot);
685 }
686 }
687 }
688 if (struct.isSetSortedColumns()) {
689 {
690 oprot.writeI32(struct.sortedColumns.size());
691 for (TColumn _iter18 : struct.sortedColumns)
692 {
693 _iter18.write(oprot);
694 }
695 }
696 }
697 }
698
699 @Override
700 public void read(org.apache.thrift.protocol.TProtocol prot, TRowResult struct) throws org.apache.thrift.TException {
701 TTupleProtocol iprot = (TTupleProtocol) prot;
702 BitSet incoming = iprot.readBitSet(3);
703 if (incoming.get(0)) {
704 struct.row = iprot.readBinary();
705 struct.setRowIsSet(true);
706 }
707 if (incoming.get(1)) {
708 {
709 org.apache.thrift.protocol.TMap _map19 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
710 struct.columns = new HashMap<ByteBuffer,TCell>(2*_map19.size);
711 for (int _i20 = 0; _i20 < _map19.size; ++_i20)
712 {
713 ByteBuffer _key21;
714 TCell _val22;
715 _key21 = iprot.readBinary();
716 _val22 = new TCell();
717 _val22.read(iprot);
718 struct.columns.put(_key21, _val22);
719 }
720 }
721 struct.setColumnsIsSet(true);
722 }
723 if (incoming.get(2)) {
724 {
725 org.apache.thrift.protocol.TList _list23 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
726 struct.sortedColumns = new ArrayList<TColumn>(_list23.size);
727 for (int _i24 = 0; _i24 < _list23.size; ++_i24)
728 {
729 TColumn _elem25;
730 _elem25 = new TColumn();
731 _elem25.read(iprot);
732 struct.sortedColumns.add(_elem25);
733 }
734 }
735 struct.setSortedColumnsIsSet(true);
736 }
737 }
738 }
739
740 }
741