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