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