1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.hadoop.hbase.thrift.generated;
19
20 import org.apache.commons.lang.builder.HashCodeBuilder;
21 import java.util.List;
22 import java.util.ArrayList;
23 import java.util.Map;
24 import java.util.HashMap;
25 import java.util.EnumMap;
26 import java.util.Set;
27 import java.util.HashSet;
28 import java.util.EnumSet;
29 import java.util.Collections;
30 import java.util.BitSet;
31 import java.util.Arrays;
32 import org.slf4j.Logger;
33 import org.slf4j.LoggerFactory;
34
35 import org.apache.thrift.*;
36 import org.apache.thrift.meta_data.*;
37 import org.apache.thrift.protocol.*;
38
39 public class Hbase {
40
41 public interface Iface {
42
43
44
45
46
47
48 public void enableTable(byte[] tableName) throws IOError, TException;
49
50
51
52
53
54
55
56 public void disableTable(byte[] tableName) throws IOError, TException;
57
58
59
60
61
62
63 public boolean isTableEnabled(byte[] tableName) throws IOError, TException;
64
65 public void compact(byte[] tableNameOrRegionName) throws IOError, TException;
66
67 public void majorCompact(byte[] tableNameOrRegionName) throws IOError, TException;
68
69
70
71
72
73 public List<byte[]> getTableNames() throws IOError, TException;
74
75
76
77
78
79
80
81 public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException;
82
83
84
85
86
87
88
89 public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException;
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104 public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException;
105
106
107
108
109
110
111
112
113
114 public void deleteTable(byte[] tableName) throws IOError, TException;
115
116
117
118
119
120
121
122
123
124
125
126
127
128 public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144 public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException;
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163 public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException;
164
165
166
167
168
169
170
171
172
173
174
175 public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException;
176
177
178
179
180
181
182
183
184
185
186
187
188
189 public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException;
190
191
192
193
194
195
196
197
198
199
200
201
202
203 public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219 public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException;
220
221
222
223
224
225
226
227
228
229
230
231
232
233 public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException;
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249 public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException;
250
251
252
253
254
255
256
257
258
259
260
261 public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException;
262
263
264
265
266
267
268
269
270
271
272
273
274
275 public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException;
276
277
278
279
280
281
282
283
284
285
286
287
288 public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException;
289
290
291
292
293
294
295
296
297
298
299 public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
300
301
302
303
304
305
306
307
308
309
310
311
312
313 public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException;
314
315
316
317
318
319
320
321
322 public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException;
323
324
325
326
327
328
329
330
331
332
333
334 public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351 public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException;
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372 public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException;
373
374
375
376
377
378
379
380
381
382
383
384
385
386 public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException;
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406 public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException;
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430 public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException;
431
432
433
434
435
436
437
438
439
440
441
442
443
444 public List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, TException;
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460 public List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException;
461
462
463
464
465
466
467
468
469 public void scannerClose(int id) throws IOError, IllegalArgument, TException;
470
471 }
472
473 public static class Client implements Iface {
474 public Client(TProtocol prot)
475 {
476 this(prot, prot);
477 }
478
479 public Client(TProtocol iprot, TProtocol oprot)
480 {
481 iprot_ = iprot;
482 oprot_ = oprot;
483 }
484
485 protected TProtocol iprot_;
486 protected TProtocol oprot_;
487
488 protected int seqid_;
489
490 public TProtocol getInputProtocol()
491 {
492 return this.iprot_;
493 }
494
495 public TProtocol getOutputProtocol()
496 {
497 return this.oprot_;
498 }
499
500 public void enableTable(byte[] tableName) throws IOError, TException
501 {
502 send_enableTable(tableName);
503 recv_enableTable();
504 }
505
506 public void send_enableTable(byte[] tableName) throws TException
507 {
508 oprot_.writeMessageBegin(new TMessage("enableTable", TMessageType.CALL, seqid_));
509 enableTable_args args = new enableTable_args();
510 args.tableName = tableName;
511 args.write(oprot_);
512 oprot_.writeMessageEnd();
513 oprot_.getTransport().flush();
514 }
515
516 public void recv_enableTable() throws IOError, TException
517 {
518 TMessage msg = iprot_.readMessageBegin();
519 if (msg.type == TMessageType.EXCEPTION) {
520 TApplicationException x = TApplicationException.read(iprot_);
521 iprot_.readMessageEnd();
522 throw x;
523 }
524 enableTable_result result = new enableTable_result();
525 result.read(iprot_);
526 iprot_.readMessageEnd();
527 if (result.io != null) {
528 throw result.io;
529 }
530 return;
531 }
532
533 public void disableTable(byte[] tableName) throws IOError, TException
534 {
535 send_disableTable(tableName);
536 recv_disableTable();
537 }
538
539 public void send_disableTable(byte[] tableName) throws TException
540 {
541 oprot_.writeMessageBegin(new TMessage("disableTable", TMessageType.CALL, seqid_));
542 disableTable_args args = new disableTable_args();
543 args.tableName = tableName;
544 args.write(oprot_);
545 oprot_.writeMessageEnd();
546 oprot_.getTransport().flush();
547 }
548
549 public void recv_disableTable() throws IOError, TException
550 {
551 TMessage msg = iprot_.readMessageBegin();
552 if (msg.type == TMessageType.EXCEPTION) {
553 TApplicationException x = TApplicationException.read(iprot_);
554 iprot_.readMessageEnd();
555 throw x;
556 }
557 disableTable_result result = new disableTable_result();
558 result.read(iprot_);
559 iprot_.readMessageEnd();
560 if (result.io != null) {
561 throw result.io;
562 }
563 return;
564 }
565
566 public boolean isTableEnabled(byte[] tableName) throws IOError, TException
567 {
568 send_isTableEnabled(tableName);
569 return recv_isTableEnabled();
570 }
571
572 public void send_isTableEnabled(byte[] tableName) throws TException
573 {
574 oprot_.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.CALL, seqid_));
575 isTableEnabled_args args = new isTableEnabled_args();
576 args.tableName = tableName;
577 args.write(oprot_);
578 oprot_.writeMessageEnd();
579 oprot_.getTransport().flush();
580 }
581
582 public boolean recv_isTableEnabled() throws IOError, TException
583 {
584 TMessage msg = iprot_.readMessageBegin();
585 if (msg.type == TMessageType.EXCEPTION) {
586 TApplicationException x = TApplicationException.read(iprot_);
587 iprot_.readMessageEnd();
588 throw x;
589 }
590 isTableEnabled_result result = new isTableEnabled_result();
591 result.read(iprot_);
592 iprot_.readMessageEnd();
593 if (result.isSetSuccess()) {
594 return result.success;
595 }
596 if (result.io != null) {
597 throw result.io;
598 }
599 throw new TApplicationException(TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result");
600 }
601
602 public void compact(byte[] tableNameOrRegionName) throws IOError, TException
603 {
604 send_compact(tableNameOrRegionName);
605 recv_compact();
606 }
607
608 public void send_compact(byte[] tableNameOrRegionName) throws TException
609 {
610 oprot_.writeMessageBegin(new TMessage("compact", TMessageType.CALL, seqid_));
611 compact_args args = new compact_args();
612 args.tableNameOrRegionName = tableNameOrRegionName;
613 args.write(oprot_);
614 oprot_.writeMessageEnd();
615 oprot_.getTransport().flush();
616 }
617
618 public void recv_compact() throws IOError, TException
619 {
620 TMessage msg = iprot_.readMessageBegin();
621 if (msg.type == TMessageType.EXCEPTION) {
622 TApplicationException x = TApplicationException.read(iprot_);
623 iprot_.readMessageEnd();
624 throw x;
625 }
626 compact_result result = new compact_result();
627 result.read(iprot_);
628 iprot_.readMessageEnd();
629 if (result.io != null) {
630 throw result.io;
631 }
632 return;
633 }
634
635 public void majorCompact(byte[] tableNameOrRegionName) throws IOError, TException
636 {
637 send_majorCompact(tableNameOrRegionName);
638 recv_majorCompact();
639 }
640
641 public void send_majorCompact(byte[] tableNameOrRegionName) throws TException
642 {
643 oprot_.writeMessageBegin(new TMessage("majorCompact", TMessageType.CALL, seqid_));
644 majorCompact_args args = new majorCompact_args();
645 args.tableNameOrRegionName = tableNameOrRegionName;
646 args.write(oprot_);
647 oprot_.writeMessageEnd();
648 oprot_.getTransport().flush();
649 }
650
651 public void recv_majorCompact() throws IOError, TException
652 {
653 TMessage msg = iprot_.readMessageBegin();
654 if (msg.type == TMessageType.EXCEPTION) {
655 TApplicationException x = TApplicationException.read(iprot_);
656 iprot_.readMessageEnd();
657 throw x;
658 }
659 majorCompact_result result = new majorCompact_result();
660 result.read(iprot_);
661 iprot_.readMessageEnd();
662 if (result.io != null) {
663 throw result.io;
664 }
665 return;
666 }
667
668 public List<byte[]> getTableNames() throws IOError, TException
669 {
670 send_getTableNames();
671 return recv_getTableNames();
672 }
673
674 public void send_getTableNames() throws TException
675 {
676 oprot_.writeMessageBegin(new TMessage("getTableNames", TMessageType.CALL, seqid_));
677 getTableNames_args args = new getTableNames_args();
678 args.write(oprot_);
679 oprot_.writeMessageEnd();
680 oprot_.getTransport().flush();
681 }
682
683 public List<byte[]> recv_getTableNames() throws IOError, TException
684 {
685 TMessage msg = iprot_.readMessageBegin();
686 if (msg.type == TMessageType.EXCEPTION) {
687 TApplicationException x = TApplicationException.read(iprot_);
688 iprot_.readMessageEnd();
689 throw x;
690 }
691 getTableNames_result result = new getTableNames_result();
692 result.read(iprot_);
693 iprot_.readMessageEnd();
694 if (result.isSetSuccess()) {
695 return result.success;
696 }
697 if (result.io != null) {
698 throw result.io;
699 }
700 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result");
701 }
702
703 public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException
704 {
705 send_getColumnDescriptors(tableName);
706 return recv_getColumnDescriptors();
707 }
708
709 public void send_getColumnDescriptors(byte[] tableName) throws TException
710 {
711 oprot_.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.CALL, seqid_));
712 getColumnDescriptors_args args = new getColumnDescriptors_args();
713 args.tableName = tableName;
714 args.write(oprot_);
715 oprot_.writeMessageEnd();
716 oprot_.getTransport().flush();
717 }
718
719 public Map<byte[],ColumnDescriptor> recv_getColumnDescriptors() throws IOError, TException
720 {
721 TMessage msg = iprot_.readMessageBegin();
722 if (msg.type == TMessageType.EXCEPTION) {
723 TApplicationException x = TApplicationException.read(iprot_);
724 iprot_.readMessageEnd();
725 throw x;
726 }
727 getColumnDescriptors_result result = new getColumnDescriptors_result();
728 result.read(iprot_);
729 iprot_.readMessageEnd();
730 if (result.isSetSuccess()) {
731 return result.success;
732 }
733 if (result.io != null) {
734 throw result.io;
735 }
736 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result");
737 }
738
739 public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException
740 {
741 send_getTableRegions(tableName);
742 return recv_getTableRegions();
743 }
744
745 public void send_getTableRegions(byte[] tableName) throws TException
746 {
747 oprot_.writeMessageBegin(new TMessage("getTableRegions", TMessageType.CALL, seqid_));
748 getTableRegions_args args = new getTableRegions_args();
749 args.tableName = tableName;
750 args.write(oprot_);
751 oprot_.writeMessageEnd();
752 oprot_.getTransport().flush();
753 }
754
755 public List<TRegionInfo> recv_getTableRegions() throws IOError, TException
756 {
757 TMessage msg = iprot_.readMessageBegin();
758 if (msg.type == TMessageType.EXCEPTION) {
759 TApplicationException x = TApplicationException.read(iprot_);
760 iprot_.readMessageEnd();
761 throw x;
762 }
763 getTableRegions_result result = new getTableRegions_result();
764 result.read(iprot_);
765 iprot_.readMessageEnd();
766 if (result.isSetSuccess()) {
767 return result.success;
768 }
769 if (result.io != null) {
770 throw result.io;
771 }
772 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result");
773 }
774
775 public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException
776 {
777 send_createTable(tableName, columnFamilies);
778 recv_createTable();
779 }
780
781 public void send_createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws TException
782 {
783 oprot_.writeMessageBegin(new TMessage("createTable", TMessageType.CALL, seqid_));
784 createTable_args args = new createTable_args();
785 args.tableName = tableName;
786 args.columnFamilies = columnFamilies;
787 args.write(oprot_);
788 oprot_.writeMessageEnd();
789 oprot_.getTransport().flush();
790 }
791
792 public void recv_createTable() throws IOError, IllegalArgument, AlreadyExists, TException
793 {
794 TMessage msg = iprot_.readMessageBegin();
795 if (msg.type == TMessageType.EXCEPTION) {
796 TApplicationException x = TApplicationException.read(iprot_);
797 iprot_.readMessageEnd();
798 throw x;
799 }
800 createTable_result result = new createTable_result();
801 result.read(iprot_);
802 iprot_.readMessageEnd();
803 if (result.io != null) {
804 throw result.io;
805 }
806 if (result.ia != null) {
807 throw result.ia;
808 }
809 if (result.exist != null) {
810 throw result.exist;
811 }
812 return;
813 }
814
815 public void deleteTable(byte[] tableName) throws IOError, TException
816 {
817 send_deleteTable(tableName);
818 recv_deleteTable();
819 }
820
821 public void send_deleteTable(byte[] tableName) throws TException
822 {
823 oprot_.writeMessageBegin(new TMessage("deleteTable", TMessageType.CALL, seqid_));
824 deleteTable_args args = new deleteTable_args();
825 args.tableName = tableName;
826 args.write(oprot_);
827 oprot_.writeMessageEnd();
828 oprot_.getTransport().flush();
829 }
830
831 public void recv_deleteTable() throws IOError, TException
832 {
833 TMessage msg = iprot_.readMessageBegin();
834 if (msg.type == TMessageType.EXCEPTION) {
835 TApplicationException x = TApplicationException.read(iprot_);
836 iprot_.readMessageEnd();
837 throw x;
838 }
839 deleteTable_result result = new deleteTable_result();
840 result.read(iprot_);
841 iprot_.readMessageEnd();
842 if (result.io != null) {
843 throw result.io;
844 }
845 return;
846 }
847
848 public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
849 {
850 send_get(tableName, row, column);
851 return recv_get();
852 }
853
854 public void send_get(byte[] tableName, byte[] row, byte[] column) throws TException
855 {
856 oprot_.writeMessageBegin(new TMessage("get", TMessageType.CALL, seqid_));
857 get_args args = new get_args();
858 args.tableName = tableName;
859 args.row = row;
860 args.column = column;
861 args.write(oprot_);
862 oprot_.writeMessageEnd();
863 oprot_.getTransport().flush();
864 }
865
866 public List<TCell> recv_get() throws IOError, TException
867 {
868 TMessage msg = iprot_.readMessageBegin();
869 if (msg.type == TMessageType.EXCEPTION) {
870 TApplicationException x = TApplicationException.read(iprot_);
871 iprot_.readMessageEnd();
872 throw x;
873 }
874 get_result result = new get_result();
875 result.read(iprot_);
876 iprot_.readMessageEnd();
877 if (result.isSetSuccess()) {
878 return result.success;
879 }
880 if (result.io != null) {
881 throw result.io;
882 }
883 throw new TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result");
884 }
885
886 public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException
887 {
888 send_getVer(tableName, row, column, numVersions);
889 return recv_getVer();
890 }
891
892 public void send_getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws TException
893 {
894 oprot_.writeMessageBegin(new TMessage("getVer", TMessageType.CALL, seqid_));
895 getVer_args args = new getVer_args();
896 args.tableName = tableName;
897 args.row = row;
898 args.column = column;
899 args.numVersions = numVersions;
900 args.write(oprot_);
901 oprot_.writeMessageEnd();
902 oprot_.getTransport().flush();
903 }
904
905 public List<TCell> recv_getVer() throws IOError, TException
906 {
907 TMessage msg = iprot_.readMessageBegin();
908 if (msg.type == TMessageType.EXCEPTION) {
909 TApplicationException x = TApplicationException.read(iprot_);
910 iprot_.readMessageEnd();
911 throw x;
912 }
913 getVer_result result = new getVer_result();
914 result.read(iprot_);
915 iprot_.readMessageEnd();
916 if (result.isSetSuccess()) {
917 return result.success;
918 }
919 if (result.io != null) {
920 throw result.io;
921 }
922 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVer failed: unknown result");
923 }
924
925 public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException
926 {
927 send_getVerTs(tableName, row, column, timestamp, numVersions);
928 return recv_getVerTs();
929 }
930
931 public void send_getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws TException
932 {
933 oprot_.writeMessageBegin(new TMessage("getVerTs", TMessageType.CALL, seqid_));
934 getVerTs_args args = new getVerTs_args();
935 args.tableName = tableName;
936 args.row = row;
937 args.column = column;
938 args.timestamp = timestamp;
939 args.numVersions = numVersions;
940 args.write(oprot_);
941 oprot_.writeMessageEnd();
942 oprot_.getTransport().flush();
943 }
944
945 public List<TCell> recv_getVerTs() throws IOError, TException
946 {
947 TMessage msg = iprot_.readMessageBegin();
948 if (msg.type == TMessageType.EXCEPTION) {
949 TApplicationException x = TApplicationException.read(iprot_);
950 iprot_.readMessageEnd();
951 throw x;
952 }
953 getVerTs_result result = new getVerTs_result();
954 result.read(iprot_);
955 iprot_.readMessageEnd();
956 if (result.isSetSuccess()) {
957 return result.success;
958 }
959 if (result.io != null) {
960 throw result.io;
961 }
962 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result");
963 }
964
965 public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException
966 {
967 send_getRow(tableName, row);
968 return recv_getRow();
969 }
970
971 public void send_getRow(byte[] tableName, byte[] row) throws TException
972 {
973 oprot_.writeMessageBegin(new TMessage("getRow", TMessageType.CALL, seqid_));
974 getRow_args args = new getRow_args();
975 args.tableName = tableName;
976 args.row = row;
977 args.write(oprot_);
978 oprot_.writeMessageEnd();
979 oprot_.getTransport().flush();
980 }
981
982 public List<TRowResult> recv_getRow() throws IOError, TException
983 {
984 TMessage msg = iprot_.readMessageBegin();
985 if (msg.type == TMessageType.EXCEPTION) {
986 TApplicationException x = TApplicationException.read(iprot_);
987 iprot_.readMessageEnd();
988 throw x;
989 }
990 getRow_result result = new getRow_result();
991 result.read(iprot_);
992 iprot_.readMessageEnd();
993 if (result.isSetSuccess()) {
994 return result.success;
995 }
996 if (result.io != null) {
997 throw result.io;
998 }
999 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRow failed: unknown result");
1000 }
1001
1002 public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException
1003 {
1004 send_getRowWithColumns(tableName, row, columns);
1005 return recv_getRowWithColumns();
1006 }
1007
1008 public void send_getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws TException
1009 {
1010 oprot_.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.CALL, seqid_));
1011 getRowWithColumns_args args = new getRowWithColumns_args();
1012 args.tableName = tableName;
1013 args.row = row;
1014 args.columns = columns;
1015 args.write(oprot_);
1016 oprot_.writeMessageEnd();
1017 oprot_.getTransport().flush();
1018 }
1019
1020 public List<TRowResult> recv_getRowWithColumns() throws IOError, TException
1021 {
1022 TMessage msg = iprot_.readMessageBegin();
1023 if (msg.type == TMessageType.EXCEPTION) {
1024 TApplicationException x = TApplicationException.read(iprot_);
1025 iprot_.readMessageEnd();
1026 throw x;
1027 }
1028 getRowWithColumns_result result = new getRowWithColumns_result();
1029 result.read(iprot_);
1030 iprot_.readMessageEnd();
1031 if (result.isSetSuccess()) {
1032 return result.success;
1033 }
1034 if (result.io != null) {
1035 throw result.io;
1036 }
1037 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result");
1038 }
1039
1040 public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
1041 {
1042 send_getRowTs(tableName, row, timestamp);
1043 return recv_getRowTs();
1044 }
1045
1046 public void send_getRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
1047 {
1048 oprot_.writeMessageBegin(new TMessage("getRowTs", TMessageType.CALL, seqid_));
1049 getRowTs_args args = new getRowTs_args();
1050 args.tableName = tableName;
1051 args.row = row;
1052 args.timestamp = timestamp;
1053 args.write(oprot_);
1054 oprot_.writeMessageEnd();
1055 oprot_.getTransport().flush();
1056 }
1057
1058 public List<TRowResult> recv_getRowTs() throws IOError, TException
1059 {
1060 TMessage msg = iprot_.readMessageBegin();
1061 if (msg.type == TMessageType.EXCEPTION) {
1062 TApplicationException x = TApplicationException.read(iprot_);
1063 iprot_.readMessageEnd();
1064 throw x;
1065 }
1066 getRowTs_result result = new getRowTs_result();
1067 result.read(iprot_);
1068 iprot_.readMessageEnd();
1069 if (result.isSetSuccess()) {
1070 return result.success;
1071 }
1072 if (result.io != null) {
1073 throw result.io;
1074 }
1075 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result");
1076 }
1077
1078 public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException
1079 {
1080 send_getRowWithColumnsTs(tableName, row, columns, timestamp);
1081 return recv_getRowWithColumnsTs();
1082 }
1083
1084 public void send_getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws TException
1085 {
1086 oprot_.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.CALL, seqid_));
1087 getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
1088 args.tableName = tableName;
1089 args.row = row;
1090 args.columns = columns;
1091 args.timestamp = timestamp;
1092 args.write(oprot_);
1093 oprot_.writeMessageEnd();
1094 oprot_.getTransport().flush();
1095 }
1096
1097 public List<TRowResult> recv_getRowWithColumnsTs() throws IOError, TException
1098 {
1099 TMessage msg = iprot_.readMessageBegin();
1100 if (msg.type == TMessageType.EXCEPTION) {
1101 TApplicationException x = TApplicationException.read(iprot_);
1102 iprot_.readMessageEnd();
1103 throw x;
1104 }
1105 getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
1106 result.read(iprot_);
1107 iprot_.readMessageEnd();
1108 if (result.isSetSuccess()) {
1109 return result.success;
1110 }
1111 if (result.io != null) {
1112 throw result.io;
1113 }
1114 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
1115 }
1116
1117 public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException
1118 {
1119 send_mutateRow(tableName, row, mutations);
1120 recv_mutateRow();
1121 }
1122
1123 public void send_mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws TException
1124 {
1125 oprot_.writeMessageBegin(new TMessage("mutateRow", TMessageType.CALL, seqid_));
1126 mutateRow_args args = new mutateRow_args();
1127 args.tableName = tableName;
1128 args.row = row;
1129 args.mutations = mutations;
1130 args.write(oprot_);
1131 oprot_.writeMessageEnd();
1132 oprot_.getTransport().flush();
1133 }
1134
1135 public void recv_mutateRow() throws IOError, IllegalArgument, TException
1136 {
1137 TMessage msg = iprot_.readMessageBegin();
1138 if (msg.type == TMessageType.EXCEPTION) {
1139 TApplicationException x = TApplicationException.read(iprot_);
1140 iprot_.readMessageEnd();
1141 throw x;
1142 }
1143 mutateRow_result result = new mutateRow_result();
1144 result.read(iprot_);
1145 iprot_.readMessageEnd();
1146 if (result.io != null) {
1147 throw result.io;
1148 }
1149 if (result.ia != null) {
1150 throw result.ia;
1151 }
1152 return;
1153 }
1154
1155 public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException
1156 {
1157 send_mutateRowTs(tableName, row, mutations, timestamp);
1158 recv_mutateRowTs();
1159 }
1160
1161 public void send_mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws TException
1162 {
1163 oprot_.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.CALL, seqid_));
1164 mutateRowTs_args args = new mutateRowTs_args();
1165 args.tableName = tableName;
1166 args.row = row;
1167 args.mutations = mutations;
1168 args.timestamp = timestamp;
1169 args.write(oprot_);
1170 oprot_.writeMessageEnd();
1171 oprot_.getTransport().flush();
1172 }
1173
1174 public void recv_mutateRowTs() throws IOError, IllegalArgument, TException
1175 {
1176 TMessage msg = iprot_.readMessageBegin();
1177 if (msg.type == TMessageType.EXCEPTION) {
1178 TApplicationException x = TApplicationException.read(iprot_);
1179 iprot_.readMessageEnd();
1180 throw x;
1181 }
1182 mutateRowTs_result result = new mutateRowTs_result();
1183 result.read(iprot_);
1184 iprot_.readMessageEnd();
1185 if (result.io != null) {
1186 throw result.io;
1187 }
1188 if (result.ia != null) {
1189 throw result.ia;
1190 }
1191 return;
1192 }
1193
1194 public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException
1195 {
1196 send_mutateRows(tableName, rowBatches);
1197 recv_mutateRows();
1198 }
1199
1200 public void send_mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws TException
1201 {
1202 oprot_.writeMessageBegin(new TMessage("mutateRows", TMessageType.CALL, seqid_));
1203 mutateRows_args args = new mutateRows_args();
1204 args.tableName = tableName;
1205 args.rowBatches = rowBatches;
1206 args.write(oprot_);
1207 oprot_.writeMessageEnd();
1208 oprot_.getTransport().flush();
1209 }
1210
1211 public void recv_mutateRows() throws IOError, IllegalArgument, TException
1212 {
1213 TMessage msg = iprot_.readMessageBegin();
1214 if (msg.type == TMessageType.EXCEPTION) {
1215 TApplicationException x = TApplicationException.read(iprot_);
1216 iprot_.readMessageEnd();
1217 throw x;
1218 }
1219 mutateRows_result result = new mutateRows_result();
1220 result.read(iprot_);
1221 iprot_.readMessageEnd();
1222 if (result.io != null) {
1223 throw result.io;
1224 }
1225 if (result.ia != null) {
1226 throw result.ia;
1227 }
1228 return;
1229 }
1230
1231 public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException
1232 {
1233 send_mutateRowsTs(tableName, rowBatches, timestamp);
1234 recv_mutateRowsTs();
1235 }
1236
1237 public void send_mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws TException
1238 {
1239 oprot_.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.CALL, seqid_));
1240 mutateRowsTs_args args = new mutateRowsTs_args();
1241 args.tableName = tableName;
1242 args.rowBatches = rowBatches;
1243 args.timestamp = timestamp;
1244 args.write(oprot_);
1245 oprot_.writeMessageEnd();
1246 oprot_.getTransport().flush();
1247 }
1248
1249 public void recv_mutateRowsTs() throws IOError, IllegalArgument, TException
1250 {
1251 TMessage msg = iprot_.readMessageBegin();
1252 if (msg.type == TMessageType.EXCEPTION) {
1253 TApplicationException x = TApplicationException.read(iprot_);
1254 iprot_.readMessageEnd();
1255 throw x;
1256 }
1257 mutateRowsTs_result result = new mutateRowsTs_result();
1258 result.read(iprot_);
1259 iprot_.readMessageEnd();
1260 if (result.io != null) {
1261 throw result.io;
1262 }
1263 if (result.ia != null) {
1264 throw result.ia;
1265 }
1266 return;
1267 }
1268
1269 public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException
1270 {
1271 send_atomicIncrement(tableName, row, column, value);
1272 return recv_atomicIncrement();
1273 }
1274
1275 public void send_atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws TException
1276 {
1277 oprot_.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.CALL, seqid_));
1278 atomicIncrement_args args = new atomicIncrement_args();
1279 args.tableName = tableName;
1280 args.row = row;
1281 args.column = column;
1282 args.value = value;
1283 args.write(oprot_);
1284 oprot_.writeMessageEnd();
1285 oprot_.getTransport().flush();
1286 }
1287
1288 public long recv_atomicIncrement() throws IOError, IllegalArgument, TException
1289 {
1290 TMessage msg = iprot_.readMessageBegin();
1291 if (msg.type == TMessageType.EXCEPTION) {
1292 TApplicationException x = TApplicationException.read(iprot_);
1293 iprot_.readMessageEnd();
1294 throw x;
1295 }
1296 atomicIncrement_result result = new atomicIncrement_result();
1297 result.read(iprot_);
1298 iprot_.readMessageEnd();
1299 if (result.isSetSuccess()) {
1300 return result.success;
1301 }
1302 if (result.io != null) {
1303 throw result.io;
1304 }
1305 if (result.ia != null) {
1306 throw result.ia;
1307 }
1308 throw new TApplicationException(TApplicationException.MISSING_RESULT, "atomicIncrement failed: unknown result");
1309 }
1310
1311 public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
1312 {
1313 send_deleteAll(tableName, row, column);
1314 recv_deleteAll();
1315 }
1316
1317 public void send_deleteAll(byte[] tableName, byte[] row, byte[] column) throws TException
1318 {
1319 oprot_.writeMessageBegin(new TMessage("deleteAll", TMessageType.CALL, seqid_));
1320 deleteAll_args args = new deleteAll_args();
1321 args.tableName = tableName;
1322 args.row = row;
1323 args.column = column;
1324 args.write(oprot_);
1325 oprot_.writeMessageEnd();
1326 oprot_.getTransport().flush();
1327 }
1328
1329 public void recv_deleteAll() throws IOError, TException
1330 {
1331 TMessage msg = iprot_.readMessageBegin();
1332 if (msg.type == TMessageType.EXCEPTION) {
1333 TApplicationException x = TApplicationException.read(iprot_);
1334 iprot_.readMessageEnd();
1335 throw x;
1336 }
1337 deleteAll_result result = new deleteAll_result();
1338 result.read(iprot_);
1339 iprot_.readMessageEnd();
1340 if (result.io != null) {
1341 throw result.io;
1342 }
1343 return;
1344 }
1345
1346 public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException
1347 {
1348 send_deleteAllTs(tableName, row, column, timestamp);
1349 recv_deleteAllTs();
1350 }
1351
1352 public void send_deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws TException
1353 {
1354 oprot_.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.CALL, seqid_));
1355 deleteAllTs_args args = new deleteAllTs_args();
1356 args.tableName = tableName;
1357 args.row = row;
1358 args.column = column;
1359 args.timestamp = timestamp;
1360 args.write(oprot_);
1361 oprot_.writeMessageEnd();
1362 oprot_.getTransport().flush();
1363 }
1364
1365 public void recv_deleteAllTs() throws IOError, TException
1366 {
1367 TMessage msg = iprot_.readMessageBegin();
1368 if (msg.type == TMessageType.EXCEPTION) {
1369 TApplicationException x = TApplicationException.read(iprot_);
1370 iprot_.readMessageEnd();
1371 throw x;
1372 }
1373 deleteAllTs_result result = new deleteAllTs_result();
1374 result.read(iprot_);
1375 iprot_.readMessageEnd();
1376 if (result.io != null) {
1377 throw result.io;
1378 }
1379 return;
1380 }
1381
1382 public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException
1383 {
1384 send_deleteAllRow(tableName, row);
1385 recv_deleteAllRow();
1386 }
1387
1388 public void send_deleteAllRow(byte[] tableName, byte[] row) throws TException
1389 {
1390 oprot_.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.CALL, seqid_));
1391 deleteAllRow_args args = new deleteAllRow_args();
1392 args.tableName = tableName;
1393 args.row = row;
1394 args.write(oprot_);
1395 oprot_.writeMessageEnd();
1396 oprot_.getTransport().flush();
1397 }
1398
1399 public void recv_deleteAllRow() throws IOError, TException
1400 {
1401 TMessage msg = iprot_.readMessageBegin();
1402 if (msg.type == TMessageType.EXCEPTION) {
1403 TApplicationException x = TApplicationException.read(iprot_);
1404 iprot_.readMessageEnd();
1405 throw x;
1406 }
1407 deleteAllRow_result result = new deleteAllRow_result();
1408 result.read(iprot_);
1409 iprot_.readMessageEnd();
1410 if (result.io != null) {
1411 throw result.io;
1412 }
1413 return;
1414 }
1415
1416 public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
1417 {
1418 send_deleteAllRowTs(tableName, row, timestamp);
1419 recv_deleteAllRowTs();
1420 }
1421
1422 public void send_deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
1423 {
1424 oprot_.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.CALL, seqid_));
1425 deleteAllRowTs_args args = new deleteAllRowTs_args();
1426 args.tableName = tableName;
1427 args.row = row;
1428 args.timestamp = timestamp;
1429 args.write(oprot_);
1430 oprot_.writeMessageEnd();
1431 oprot_.getTransport().flush();
1432 }
1433
1434 public void recv_deleteAllRowTs() throws IOError, TException
1435 {
1436 TMessage msg = iprot_.readMessageBegin();
1437 if (msg.type == TMessageType.EXCEPTION) {
1438 TApplicationException x = TApplicationException.read(iprot_);
1439 iprot_.readMessageEnd();
1440 throw x;
1441 }
1442 deleteAllRowTs_result result = new deleteAllRowTs_result();
1443 result.read(iprot_);
1444 iprot_.readMessageEnd();
1445 if (result.io != null) {
1446 throw result.io;
1447 }
1448 return;
1449 }
1450
1451 public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException
1452 {
1453 send_scannerOpen(tableName, startRow, columns);
1454 return recv_scannerOpen();
1455 }
1456
1457 public void send_scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws TException
1458 {
1459 oprot_.writeMessageBegin(new TMessage("scannerOpen", TMessageType.CALL, seqid_));
1460 scannerOpen_args args = new scannerOpen_args();
1461 args.tableName = tableName;
1462 args.startRow = startRow;
1463 args.columns = columns;
1464 args.write(oprot_);
1465 oprot_.writeMessageEnd();
1466 oprot_.getTransport().flush();
1467 }
1468
1469 public int recv_scannerOpen() throws IOError, TException
1470 {
1471 TMessage msg = iprot_.readMessageBegin();
1472 if (msg.type == TMessageType.EXCEPTION) {
1473 TApplicationException x = TApplicationException.read(iprot_);
1474 iprot_.readMessageEnd();
1475 throw x;
1476 }
1477 scannerOpen_result result = new scannerOpen_result();
1478 result.read(iprot_);
1479 iprot_.readMessageEnd();
1480 if (result.isSetSuccess()) {
1481 return result.success;
1482 }
1483 if (result.io != null) {
1484 throw result.io;
1485 }
1486 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result");
1487 }
1488
1489 public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException
1490 {
1491 send_scannerOpenWithStop(tableName, startRow, stopRow, columns);
1492 return recv_scannerOpenWithStop();
1493 }
1494
1495 public void send_scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws TException
1496 {
1497 oprot_.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.CALL, seqid_));
1498 scannerOpenWithStop_args args = new scannerOpenWithStop_args();
1499 args.tableName = tableName;
1500 args.startRow = startRow;
1501 args.stopRow = stopRow;
1502 args.columns = columns;
1503 args.write(oprot_);
1504 oprot_.writeMessageEnd();
1505 oprot_.getTransport().flush();
1506 }
1507
1508 public int recv_scannerOpenWithStop() throws IOError, TException
1509 {
1510 TMessage msg = iprot_.readMessageBegin();
1511 if (msg.type == TMessageType.EXCEPTION) {
1512 TApplicationException x = TApplicationException.read(iprot_);
1513 iprot_.readMessageEnd();
1514 throw x;
1515 }
1516 scannerOpenWithStop_result result = new scannerOpenWithStop_result();
1517 result.read(iprot_);
1518 iprot_.readMessageEnd();
1519 if (result.isSetSuccess()) {
1520 return result.success;
1521 }
1522 if (result.io != null) {
1523 throw result.io;
1524 }
1525 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
1526 }
1527
1528 public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException
1529 {
1530 send_scannerOpenWithPrefix(tableName, startAndPrefix, columns);
1531 return recv_scannerOpenWithPrefix();
1532 }
1533
1534 public void send_scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws TException
1535 {
1536 oprot_.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.CALL, seqid_));
1537 scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
1538 args.tableName = tableName;
1539 args.startAndPrefix = startAndPrefix;
1540 args.columns = columns;
1541 args.write(oprot_);
1542 oprot_.writeMessageEnd();
1543 oprot_.getTransport().flush();
1544 }
1545
1546 public int recv_scannerOpenWithPrefix() throws IOError, TException
1547 {
1548 TMessage msg = iprot_.readMessageBegin();
1549 if (msg.type == TMessageType.EXCEPTION) {
1550 TApplicationException x = TApplicationException.read(iprot_);
1551 iprot_.readMessageEnd();
1552 throw x;
1553 }
1554 scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
1555 result.read(iprot_);
1556 iprot_.readMessageEnd();
1557 if (result.isSetSuccess()) {
1558 return result.success;
1559 }
1560 if (result.io != null) {
1561 throw result.io;
1562 }
1563 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
1564 }
1565
1566 public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException
1567 {
1568 send_scannerOpenTs(tableName, startRow, columns, timestamp);
1569 return recv_scannerOpenTs();
1570 }
1571
1572 public void send_scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws TException
1573 {
1574 oprot_.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.CALL, seqid_));
1575 scannerOpenTs_args args = new scannerOpenTs_args();
1576 args.tableName = tableName;
1577 args.startRow = startRow;
1578 args.columns = columns;
1579 args.timestamp = timestamp;
1580 args.write(oprot_);
1581 oprot_.writeMessageEnd();
1582 oprot_.getTransport().flush();
1583 }
1584
1585 public int recv_scannerOpenTs() throws IOError, TException
1586 {
1587 TMessage msg = iprot_.readMessageBegin();
1588 if (msg.type == TMessageType.EXCEPTION) {
1589 TApplicationException x = TApplicationException.read(iprot_);
1590 iprot_.readMessageEnd();
1591 throw x;
1592 }
1593 scannerOpenTs_result result = new scannerOpenTs_result();
1594 result.read(iprot_);
1595 iprot_.readMessageEnd();
1596 if (result.isSetSuccess()) {
1597 return result.success;
1598 }
1599 if (result.io != null) {
1600 throw result.io;
1601 }
1602 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result");
1603 }
1604
1605 public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException
1606 {
1607 send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
1608 return recv_scannerOpenWithStopTs();
1609 }
1610
1611 public void send_scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws TException
1612 {
1613 oprot_.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.CALL, seqid_));
1614 scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
1615 args.tableName = tableName;
1616 args.startRow = startRow;
1617 args.stopRow = stopRow;
1618 args.columns = columns;
1619 args.timestamp = timestamp;
1620 args.write(oprot_);
1621 oprot_.writeMessageEnd();
1622 oprot_.getTransport().flush();
1623 }
1624
1625 public int recv_scannerOpenWithStopTs() throws IOError, TException
1626 {
1627 TMessage msg = iprot_.readMessageBegin();
1628 if (msg.type == TMessageType.EXCEPTION) {
1629 TApplicationException x = TApplicationException.read(iprot_);
1630 iprot_.readMessageEnd();
1631 throw x;
1632 }
1633 scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
1634 result.read(iprot_);
1635 iprot_.readMessageEnd();
1636 if (result.isSetSuccess()) {
1637 return result.success;
1638 }
1639 if (result.io != null) {
1640 throw result.io;
1641 }
1642 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
1643 }
1644
1645 public List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, TException
1646 {
1647 send_scannerGet(id);
1648 return recv_scannerGet();
1649 }
1650
1651 public void send_scannerGet(int id) throws TException
1652 {
1653 oprot_.writeMessageBegin(new TMessage("scannerGet", TMessageType.CALL, seqid_));
1654 scannerGet_args args = new scannerGet_args();
1655 args.id = id;
1656 args.write(oprot_);
1657 oprot_.writeMessageEnd();
1658 oprot_.getTransport().flush();
1659 }
1660
1661 public List<TRowResult> recv_scannerGet() throws IOError, IllegalArgument, TException
1662 {
1663 TMessage msg = iprot_.readMessageBegin();
1664 if (msg.type == TMessageType.EXCEPTION) {
1665 TApplicationException x = TApplicationException.read(iprot_);
1666 iprot_.readMessageEnd();
1667 throw x;
1668 }
1669 scannerGet_result result = new scannerGet_result();
1670 result.read(iprot_);
1671 iprot_.readMessageEnd();
1672 if (result.isSetSuccess()) {
1673 return result.success;
1674 }
1675 if (result.io != null) {
1676 throw result.io;
1677 }
1678 if (result.ia != null) {
1679 throw result.ia;
1680 }
1681 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGet failed: unknown result");
1682 }
1683
1684 public List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException
1685 {
1686 send_scannerGetList(id, nbRows);
1687 return recv_scannerGetList();
1688 }
1689
1690 public void send_scannerGetList(int id, int nbRows) throws TException
1691 {
1692 oprot_.writeMessageBegin(new TMessage("scannerGetList", TMessageType.CALL, seqid_));
1693 scannerGetList_args args = new scannerGetList_args();
1694 args.id = id;
1695 args.nbRows = nbRows;
1696 args.write(oprot_);
1697 oprot_.writeMessageEnd();
1698 oprot_.getTransport().flush();
1699 }
1700
1701 public List<TRowResult> recv_scannerGetList() throws IOError, IllegalArgument, TException
1702 {
1703 TMessage msg = iprot_.readMessageBegin();
1704 if (msg.type == TMessageType.EXCEPTION) {
1705 TApplicationException x = TApplicationException.read(iprot_);
1706 iprot_.readMessageEnd();
1707 throw x;
1708 }
1709 scannerGetList_result result = new scannerGetList_result();
1710 result.read(iprot_);
1711 iprot_.readMessageEnd();
1712 if (result.isSetSuccess()) {
1713 return result.success;
1714 }
1715 if (result.io != null) {
1716 throw result.io;
1717 }
1718 if (result.ia != null) {
1719 throw result.ia;
1720 }
1721 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGetList failed: unknown result");
1722 }
1723
1724 public void scannerClose(int id) throws IOError, IllegalArgument, TException
1725 {
1726 send_scannerClose(id);
1727 recv_scannerClose();
1728 }
1729
1730 public void send_scannerClose(int id) throws TException
1731 {
1732 oprot_.writeMessageBegin(new TMessage("scannerClose", TMessageType.CALL, seqid_));
1733 scannerClose_args args = new scannerClose_args();
1734 args.id = id;
1735 args.write(oprot_);
1736 oprot_.writeMessageEnd();
1737 oprot_.getTransport().flush();
1738 }
1739
1740 public void recv_scannerClose() throws IOError, IllegalArgument, TException
1741 {
1742 TMessage msg = iprot_.readMessageBegin();
1743 if (msg.type == TMessageType.EXCEPTION) {
1744 TApplicationException x = TApplicationException.read(iprot_);
1745 iprot_.readMessageEnd();
1746 throw x;
1747 }
1748 scannerClose_result result = new scannerClose_result();
1749 result.read(iprot_);
1750 iprot_.readMessageEnd();
1751 if (result.io != null) {
1752 throw result.io;
1753 }
1754 if (result.ia != null) {
1755 throw result.ia;
1756 }
1757 return;
1758 }
1759
1760 }
1761 public static class Processor implements TProcessor {
1762 private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1763 public Processor(Iface iface)
1764 {
1765 iface_ = iface;
1766 processMap_.put("enableTable", new enableTable());
1767 processMap_.put("disableTable", new disableTable());
1768 processMap_.put("isTableEnabled", new isTableEnabled());
1769 processMap_.put("compact", new compact());
1770 processMap_.put("majorCompact", new majorCompact());
1771 processMap_.put("getTableNames", new getTableNames());
1772 processMap_.put("getColumnDescriptors", new getColumnDescriptors());
1773 processMap_.put("getTableRegions", new getTableRegions());
1774 processMap_.put("createTable", new createTable());
1775 processMap_.put("deleteTable", new deleteTable());
1776 processMap_.put("get", new get());
1777 processMap_.put("getVer", new getVer());
1778 processMap_.put("getVerTs", new getVerTs());
1779 processMap_.put("getRow", new getRow());
1780 processMap_.put("getRowWithColumns", new getRowWithColumns());
1781 processMap_.put("getRowTs", new getRowTs());
1782 processMap_.put("getRowWithColumnsTs", new getRowWithColumnsTs());
1783 processMap_.put("mutateRow", new mutateRow());
1784 processMap_.put("mutateRowTs", new mutateRowTs());
1785 processMap_.put("mutateRows", new mutateRows());
1786 processMap_.put("mutateRowsTs", new mutateRowsTs());
1787 processMap_.put("atomicIncrement", new atomicIncrement());
1788 processMap_.put("deleteAll", new deleteAll());
1789 processMap_.put("deleteAllTs", new deleteAllTs());
1790 processMap_.put("deleteAllRow", new deleteAllRow());
1791 processMap_.put("deleteAllRowTs", new deleteAllRowTs());
1792 processMap_.put("scannerOpen", new scannerOpen());
1793 processMap_.put("scannerOpenWithStop", new scannerOpenWithStop());
1794 processMap_.put("scannerOpenWithPrefix", new scannerOpenWithPrefix());
1795 processMap_.put("scannerOpenTs", new scannerOpenTs());
1796 processMap_.put("scannerOpenWithStopTs", new scannerOpenWithStopTs());
1797 processMap_.put("scannerGet", new scannerGet());
1798 processMap_.put("scannerGetList", new scannerGetList());
1799 processMap_.put("scannerClose", new scannerClose());
1800 }
1801
1802 protected static interface ProcessFunction {
1803 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException;
1804 }
1805
1806 private Iface iface_;
1807 protected final HashMap<String,ProcessFunction> processMap_ = new HashMap<String,ProcessFunction>();
1808
1809 public boolean process(TProtocol iprot, TProtocol oprot) throws TException
1810 {
1811 TMessage msg = iprot.readMessageBegin();
1812 ProcessFunction fn = processMap_.get(msg.name);
1813 if (fn == null) {
1814 TProtocolUtil.skip(iprot, TType.STRUCT);
1815 iprot.readMessageEnd();
1816 TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'");
1817 oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));
1818 x.write(oprot);
1819 oprot.writeMessageEnd();
1820 oprot.getTransport().flush();
1821 return true;
1822 }
1823 fn.process(msg.seqid, iprot, oprot);
1824 return true;
1825 }
1826
1827 private class enableTable implements ProcessFunction {
1828 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1829 {
1830 enableTable_args args = new enableTable_args();
1831 args.read(iprot);
1832 iprot.readMessageEnd();
1833 enableTable_result result = new enableTable_result();
1834 try {
1835 iface_.enableTable(args.tableName);
1836 } catch (IOError io) {
1837 result.io = io;
1838 } catch (Throwable th) {
1839 LOGGER.error("Internal error processing enableTable", th);
1840 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing enableTable");
1841 oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.EXCEPTION, seqid));
1842 x.write(oprot);
1843 oprot.writeMessageEnd();
1844 oprot.getTransport().flush();
1845 return;
1846 }
1847 oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.REPLY, seqid));
1848 result.write(oprot);
1849 oprot.writeMessageEnd();
1850 oprot.getTransport().flush();
1851 }
1852
1853 }
1854
1855 private class disableTable implements ProcessFunction {
1856 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1857 {
1858 disableTable_args args = new disableTable_args();
1859 args.read(iprot);
1860 iprot.readMessageEnd();
1861 disableTable_result result = new disableTable_result();
1862 try {
1863 iface_.disableTable(args.tableName);
1864 } catch (IOError io) {
1865 result.io = io;
1866 } catch (Throwable th) {
1867 LOGGER.error("Internal error processing disableTable", th);
1868 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing disableTable");
1869 oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.EXCEPTION, seqid));
1870 x.write(oprot);
1871 oprot.writeMessageEnd();
1872 oprot.getTransport().flush();
1873 return;
1874 }
1875 oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.REPLY, seqid));
1876 result.write(oprot);
1877 oprot.writeMessageEnd();
1878 oprot.getTransport().flush();
1879 }
1880
1881 }
1882
1883 private class isTableEnabled implements ProcessFunction {
1884 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1885 {
1886 isTableEnabled_args args = new isTableEnabled_args();
1887 args.read(iprot);
1888 iprot.readMessageEnd();
1889 isTableEnabled_result result = new isTableEnabled_result();
1890 try {
1891 result.success = iface_.isTableEnabled(args.tableName);
1892 result.setSuccessIsSet(true);
1893 } catch (IOError io) {
1894 result.io = io;
1895 } catch (Throwable th) {
1896 LOGGER.error("Internal error processing isTableEnabled", th);
1897 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing isTableEnabled");
1898 oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.EXCEPTION, seqid));
1899 x.write(oprot);
1900 oprot.writeMessageEnd();
1901 oprot.getTransport().flush();
1902 return;
1903 }
1904 oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.REPLY, seqid));
1905 result.write(oprot);
1906 oprot.writeMessageEnd();
1907 oprot.getTransport().flush();
1908 }
1909
1910 }
1911
1912 private class compact implements ProcessFunction {
1913 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1914 {
1915 compact_args args = new compact_args();
1916 args.read(iprot);
1917 iprot.readMessageEnd();
1918 compact_result result = new compact_result();
1919 try {
1920 iface_.compact(args.tableNameOrRegionName);
1921 } catch (IOError io) {
1922 result.io = io;
1923 } catch (Throwable th) {
1924 LOGGER.error("Internal error processing compact", th);
1925 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing compact");
1926 oprot.writeMessageBegin(new TMessage("compact", TMessageType.EXCEPTION, seqid));
1927 x.write(oprot);
1928 oprot.writeMessageEnd();
1929 oprot.getTransport().flush();
1930 return;
1931 }
1932 oprot.writeMessageBegin(new TMessage("compact", TMessageType.REPLY, seqid));
1933 result.write(oprot);
1934 oprot.writeMessageEnd();
1935 oprot.getTransport().flush();
1936 }
1937
1938 }
1939
1940 private class majorCompact implements ProcessFunction {
1941 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1942 {
1943 majorCompact_args args = new majorCompact_args();
1944 args.read(iprot);
1945 iprot.readMessageEnd();
1946 majorCompact_result result = new majorCompact_result();
1947 try {
1948 iface_.majorCompact(args.tableNameOrRegionName);
1949 } catch (IOError io) {
1950 result.io = io;
1951 } catch (Throwable th) {
1952 LOGGER.error("Internal error processing majorCompact", th);
1953 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing majorCompact");
1954 oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.EXCEPTION, seqid));
1955 x.write(oprot);
1956 oprot.writeMessageEnd();
1957 oprot.getTransport().flush();
1958 return;
1959 }
1960 oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.REPLY, seqid));
1961 result.write(oprot);
1962 oprot.writeMessageEnd();
1963 oprot.getTransport().flush();
1964 }
1965
1966 }
1967
1968 private class getTableNames implements ProcessFunction {
1969 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1970 {
1971 getTableNames_args args = new getTableNames_args();
1972 args.read(iprot);
1973 iprot.readMessageEnd();
1974 getTableNames_result result = new getTableNames_result();
1975 try {
1976 result.success = iface_.getTableNames();
1977 } catch (IOError io) {
1978 result.io = io;
1979 } catch (Throwable th) {
1980 LOGGER.error("Internal error processing getTableNames", th);
1981 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableNames");
1982 oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.EXCEPTION, seqid));
1983 x.write(oprot);
1984 oprot.writeMessageEnd();
1985 oprot.getTransport().flush();
1986 return;
1987 }
1988 oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.REPLY, seqid));
1989 result.write(oprot);
1990 oprot.writeMessageEnd();
1991 oprot.getTransport().flush();
1992 }
1993
1994 }
1995
1996 private class getColumnDescriptors implements ProcessFunction {
1997 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1998 {
1999 getColumnDescriptors_args args = new getColumnDescriptors_args();
2000 args.read(iprot);
2001 iprot.readMessageEnd();
2002 getColumnDescriptors_result result = new getColumnDescriptors_result();
2003 try {
2004 result.success = iface_.getColumnDescriptors(args.tableName);
2005 } catch (IOError io) {
2006 result.io = io;
2007 } catch (Throwable th) {
2008 LOGGER.error("Internal error processing getColumnDescriptors", th);
2009 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getColumnDescriptors");
2010 oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.EXCEPTION, seqid));
2011 x.write(oprot);
2012 oprot.writeMessageEnd();
2013 oprot.getTransport().flush();
2014 return;
2015 }
2016 oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.REPLY, seqid));
2017 result.write(oprot);
2018 oprot.writeMessageEnd();
2019 oprot.getTransport().flush();
2020 }
2021
2022 }
2023
2024 private class getTableRegions implements ProcessFunction {
2025 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2026 {
2027 getTableRegions_args args = new getTableRegions_args();
2028 args.read(iprot);
2029 iprot.readMessageEnd();
2030 getTableRegions_result result = new getTableRegions_result();
2031 try {
2032 result.success = iface_.getTableRegions(args.tableName);
2033 } catch (IOError io) {
2034 result.io = io;
2035 } catch (Throwable th) {
2036 LOGGER.error("Internal error processing getTableRegions", th);
2037 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableRegions");
2038 oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.EXCEPTION, seqid));
2039 x.write(oprot);
2040 oprot.writeMessageEnd();
2041 oprot.getTransport().flush();
2042 return;
2043 }
2044 oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.REPLY, seqid));
2045 result.write(oprot);
2046 oprot.writeMessageEnd();
2047 oprot.getTransport().flush();
2048 }
2049
2050 }
2051
2052 private class createTable implements ProcessFunction {
2053 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2054 {
2055 createTable_args args = new createTable_args();
2056 args.read(iprot);
2057 iprot.readMessageEnd();
2058 createTable_result result = new createTable_result();
2059 try {
2060 iface_.createTable(args.tableName, args.columnFamilies);
2061 } catch (IOError io) {
2062 result.io = io;
2063 } catch (IllegalArgument ia) {
2064 result.ia = ia;
2065 } catch (AlreadyExists exist) {
2066 result.exist = exist;
2067 } catch (Throwable th) {
2068 LOGGER.error("Internal error processing createTable", th);
2069 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing createTable");
2070 oprot.writeMessageBegin(new TMessage("createTable", TMessageType.EXCEPTION, seqid));
2071 x.write(oprot);
2072 oprot.writeMessageEnd();
2073 oprot.getTransport().flush();
2074 return;
2075 }
2076 oprot.writeMessageBegin(new TMessage("createTable", TMessageType.REPLY, seqid));
2077 result.write(oprot);
2078 oprot.writeMessageEnd();
2079 oprot.getTransport().flush();
2080 }
2081
2082 }
2083
2084 private class deleteTable implements ProcessFunction {
2085 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2086 {
2087 deleteTable_args args = new deleteTable_args();
2088 args.read(iprot);
2089 iprot.readMessageEnd();
2090 deleteTable_result result = new deleteTable_result();
2091 try {
2092 iface_.deleteTable(args.tableName);
2093 } catch (IOError io) {
2094 result.io = io;
2095 } catch (Throwable th) {
2096 LOGGER.error("Internal error processing deleteTable", th);
2097 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteTable");
2098 oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.EXCEPTION, seqid));
2099 x.write(oprot);
2100 oprot.writeMessageEnd();
2101 oprot.getTransport().flush();
2102 return;
2103 }
2104 oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.REPLY, seqid));
2105 result.write(oprot);
2106 oprot.writeMessageEnd();
2107 oprot.getTransport().flush();
2108 }
2109
2110 }
2111
2112 private class get implements ProcessFunction {
2113 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2114 {
2115 get_args args = new get_args();
2116 args.read(iprot);
2117 iprot.readMessageEnd();
2118 get_result result = new get_result();
2119 try {
2120 result.success = iface_.get(args.tableName, args.row, args.column);
2121 } catch (IOError io) {
2122 result.io = io;
2123 } catch (Throwable th) {
2124 LOGGER.error("Internal error processing get", th);
2125 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing get");
2126 oprot.writeMessageBegin(new TMessage("get", TMessageType.EXCEPTION, seqid));
2127 x.write(oprot);
2128 oprot.writeMessageEnd();
2129 oprot.getTransport().flush();
2130 return;
2131 }
2132 oprot.writeMessageBegin(new TMessage("get", TMessageType.REPLY, seqid));
2133 result.write(oprot);
2134 oprot.writeMessageEnd();
2135 oprot.getTransport().flush();
2136 }
2137
2138 }
2139
2140 private class getVer implements ProcessFunction {
2141 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2142 {
2143 getVer_args args = new getVer_args();
2144 args.read(iprot);
2145 iprot.readMessageEnd();
2146 getVer_result result = new getVer_result();
2147 try {
2148 result.success = iface_.getVer(args.tableName, args.row, args.column, args.numVersions);
2149 } catch (IOError io) {
2150 result.io = io;
2151 } catch (Throwable th) {
2152 LOGGER.error("Internal error processing getVer", th);
2153 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVer");
2154 oprot.writeMessageBegin(new TMessage("getVer", TMessageType.EXCEPTION, seqid));
2155 x.write(oprot);
2156 oprot.writeMessageEnd();
2157 oprot.getTransport().flush();
2158 return;
2159 }
2160 oprot.writeMessageBegin(new TMessage("getVer", TMessageType.REPLY, seqid));
2161 result.write(oprot);
2162 oprot.writeMessageEnd();
2163 oprot.getTransport().flush();
2164 }
2165
2166 }
2167
2168 private class getVerTs implements ProcessFunction {
2169 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2170 {
2171 getVerTs_args args = new getVerTs_args();
2172 args.read(iprot);
2173 iprot.readMessageEnd();
2174 getVerTs_result result = new getVerTs_result();
2175 try {
2176 result.success = iface_.getVerTs(args.tableName, args.row, args.column, args.timestamp, args.numVersions);
2177 } catch (IOError io) {
2178 result.io = io;
2179 } catch (Throwable th) {
2180 LOGGER.error("Internal error processing getVerTs", th);
2181 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVerTs");
2182 oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.EXCEPTION, seqid));
2183 x.write(oprot);
2184 oprot.writeMessageEnd();
2185 oprot.getTransport().flush();
2186 return;
2187 }
2188 oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.REPLY, seqid));
2189 result.write(oprot);
2190 oprot.writeMessageEnd();
2191 oprot.getTransport().flush();
2192 }
2193
2194 }
2195
2196 private class getRow implements ProcessFunction {
2197 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2198 {
2199 getRow_args args = new getRow_args();
2200 args.read(iprot);
2201 iprot.readMessageEnd();
2202 getRow_result result = new getRow_result();
2203 try {
2204 result.success = iface_.getRow(args.tableName, args.row);
2205 } catch (IOError io) {
2206 result.io = io;
2207 } catch (Throwable th) {
2208 LOGGER.error("Internal error processing getRow", th);
2209 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRow");
2210 oprot.writeMessageBegin(new TMessage("getRow", TMessageType.EXCEPTION, seqid));
2211 x.write(oprot);
2212 oprot.writeMessageEnd();
2213 oprot.getTransport().flush();
2214 return;
2215 }
2216 oprot.writeMessageBegin(new TMessage("getRow", TMessageType.REPLY, seqid));
2217 result.write(oprot);
2218 oprot.writeMessageEnd();
2219 oprot.getTransport().flush();
2220 }
2221
2222 }
2223
2224 private class getRowWithColumns implements ProcessFunction {
2225 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2226 {
2227 getRowWithColumns_args args = new getRowWithColumns_args();
2228 args.read(iprot);
2229 iprot.readMessageEnd();
2230 getRowWithColumns_result result = new getRowWithColumns_result();
2231 try {
2232 result.success = iface_.getRowWithColumns(args.tableName, args.row, args.columns);
2233 } catch (IOError io) {
2234 result.io = io;
2235 } catch (Throwable th) {
2236 LOGGER.error("Internal error processing getRowWithColumns", th);
2237 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumns");
2238 oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.EXCEPTION, seqid));
2239 x.write(oprot);
2240 oprot.writeMessageEnd();
2241 oprot.getTransport().flush();
2242 return;
2243 }
2244 oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.REPLY, seqid));
2245 result.write(oprot);
2246 oprot.writeMessageEnd();
2247 oprot.getTransport().flush();
2248 }
2249
2250 }
2251
2252 private class getRowTs implements ProcessFunction {
2253 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2254 {
2255 getRowTs_args args = new getRowTs_args();
2256 args.read(iprot);
2257 iprot.readMessageEnd();
2258 getRowTs_result result = new getRowTs_result();
2259 try {
2260 result.success = iface_.getRowTs(args.tableName, args.row, args.timestamp);
2261 } catch (IOError io) {
2262 result.io = io;
2263 } catch (Throwable th) {
2264 LOGGER.error("Internal error processing getRowTs", th);
2265 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowTs");
2266 oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.EXCEPTION, seqid));
2267 x.write(oprot);
2268 oprot.writeMessageEnd();
2269 oprot.getTransport().flush();
2270 return;
2271 }
2272 oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.REPLY, seqid));
2273 result.write(oprot);
2274 oprot.writeMessageEnd();
2275 oprot.getTransport().flush();
2276 }
2277
2278 }
2279
2280 private class getRowWithColumnsTs implements ProcessFunction {
2281 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2282 {
2283 getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
2284 args.read(iprot);
2285 iprot.readMessageEnd();
2286 getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
2287 try {
2288 result.success = iface_.getRowWithColumnsTs(args.tableName, args.row, args.columns, args.timestamp);
2289 } catch (IOError io) {
2290 result.io = io;
2291 } catch (Throwable th) {
2292 LOGGER.error("Internal error processing getRowWithColumnsTs", th);
2293 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumnsTs");
2294 oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.EXCEPTION, seqid));
2295 x.write(oprot);
2296 oprot.writeMessageEnd();
2297 oprot.getTransport().flush();
2298 return;
2299 }
2300 oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.REPLY, seqid));
2301 result.write(oprot);
2302 oprot.writeMessageEnd();
2303 oprot.getTransport().flush();
2304 }
2305
2306 }
2307
2308 private class mutateRow implements ProcessFunction {
2309 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2310 {
2311 mutateRow_args args = new mutateRow_args();
2312 args.read(iprot);
2313 iprot.readMessageEnd();
2314 mutateRow_result result = new mutateRow_result();
2315 try {
2316 iface_.mutateRow(args.tableName, args.row, args.mutations);
2317 } catch (IOError io) {
2318 result.io = io;
2319 } catch (IllegalArgument ia) {
2320 result.ia = ia;
2321 } catch (Throwable th) {
2322 LOGGER.error("Internal error processing mutateRow", th);
2323 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRow");
2324 oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.EXCEPTION, seqid));
2325 x.write(oprot);
2326 oprot.writeMessageEnd();
2327 oprot.getTransport().flush();
2328 return;
2329 }
2330 oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.REPLY, seqid));
2331 result.write(oprot);
2332 oprot.writeMessageEnd();
2333 oprot.getTransport().flush();
2334 }
2335
2336 }
2337
2338 private class mutateRowTs implements ProcessFunction {
2339 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2340 {
2341 mutateRowTs_args args = new mutateRowTs_args();
2342 args.read(iprot);
2343 iprot.readMessageEnd();
2344 mutateRowTs_result result = new mutateRowTs_result();
2345 try {
2346 iface_.mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp);
2347 } catch (IOError io) {
2348 result.io = io;
2349 } catch (IllegalArgument ia) {
2350 result.ia = ia;
2351 } catch (Throwable th) {
2352 LOGGER.error("Internal error processing mutateRowTs", th);
2353 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowTs");
2354 oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.EXCEPTION, seqid));
2355 x.write(oprot);
2356 oprot.writeMessageEnd();
2357 oprot.getTransport().flush();
2358 return;
2359 }
2360 oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.REPLY, seqid));
2361 result.write(oprot);
2362 oprot.writeMessageEnd();
2363 oprot.getTransport().flush();
2364 }
2365
2366 }
2367
2368 private class mutateRows implements ProcessFunction {
2369 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2370 {
2371 mutateRows_args args = new mutateRows_args();
2372 args.read(iprot);
2373 iprot.readMessageEnd();
2374 mutateRows_result result = new mutateRows_result();
2375 try {
2376 iface_.mutateRows(args.tableName, args.rowBatches);
2377 } catch (IOError io) {
2378 result.io = io;
2379 } catch (IllegalArgument ia) {
2380 result.ia = ia;
2381 } catch (Throwable th) {
2382 LOGGER.error("Internal error processing mutateRows", th);
2383 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRows");
2384 oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.EXCEPTION, seqid));
2385 x.write(oprot);
2386 oprot.writeMessageEnd();
2387 oprot.getTransport().flush();
2388 return;
2389 }
2390 oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.REPLY, seqid));
2391 result.write(oprot);
2392 oprot.writeMessageEnd();
2393 oprot.getTransport().flush();
2394 }
2395
2396 }
2397
2398 private class mutateRowsTs implements ProcessFunction {
2399 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2400 {
2401 mutateRowsTs_args args = new mutateRowsTs_args();
2402 args.read(iprot);
2403 iprot.readMessageEnd();
2404 mutateRowsTs_result result = new mutateRowsTs_result();
2405 try {
2406 iface_.mutateRowsTs(args.tableName, args.rowBatches, args.timestamp);
2407 } catch (IOError io) {
2408 result.io = io;
2409 } catch (IllegalArgument ia) {
2410 result.ia = ia;
2411 } catch (Throwable th) {
2412 LOGGER.error("Internal error processing mutateRowsTs", th);
2413 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowsTs");
2414 oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.EXCEPTION, seqid));
2415 x.write(oprot);
2416 oprot.writeMessageEnd();
2417 oprot.getTransport().flush();
2418 return;
2419 }
2420 oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.REPLY, seqid));
2421 result.write(oprot);
2422 oprot.writeMessageEnd();
2423 oprot.getTransport().flush();
2424 }
2425
2426 }
2427
2428 private class atomicIncrement implements ProcessFunction {
2429 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2430 {
2431 atomicIncrement_args args = new atomicIncrement_args();
2432 args.read(iprot);
2433 iprot.readMessageEnd();
2434 atomicIncrement_result result = new atomicIncrement_result();
2435 try {
2436 result.success = iface_.atomicIncrement(args.tableName, args.row, args.column, args.value);
2437 result.setSuccessIsSet(true);
2438 } catch (IOError io) {
2439 result.io = io;
2440 } catch (IllegalArgument ia) {
2441 result.ia = ia;
2442 } catch (Throwable th) {
2443 LOGGER.error("Internal error processing atomicIncrement", th);
2444 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing atomicIncrement");
2445 oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.EXCEPTION, seqid));
2446 x.write(oprot);
2447 oprot.writeMessageEnd();
2448 oprot.getTransport().flush();
2449 return;
2450 }
2451 oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.REPLY, seqid));
2452 result.write(oprot);
2453 oprot.writeMessageEnd();
2454 oprot.getTransport().flush();
2455 }
2456
2457 }
2458
2459 private class deleteAll implements ProcessFunction {
2460 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2461 {
2462 deleteAll_args args = new deleteAll_args();
2463 args.read(iprot);
2464 iprot.readMessageEnd();
2465 deleteAll_result result = new deleteAll_result();
2466 try {
2467 iface_.deleteAll(args.tableName, args.row, args.column);
2468 } catch (IOError io) {
2469 result.io = io;
2470 } catch (Throwable th) {
2471 LOGGER.error("Internal error processing deleteAll", th);
2472 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAll");
2473 oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.EXCEPTION, seqid));
2474 x.write(oprot);
2475 oprot.writeMessageEnd();
2476 oprot.getTransport().flush();
2477 return;
2478 }
2479 oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.REPLY, seqid));
2480 result.write(oprot);
2481 oprot.writeMessageEnd();
2482 oprot.getTransport().flush();
2483 }
2484
2485 }
2486
2487 private class deleteAllTs implements ProcessFunction {
2488 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2489 {
2490 deleteAllTs_args args = new deleteAllTs_args();
2491 args.read(iprot);
2492 iprot.readMessageEnd();
2493 deleteAllTs_result result = new deleteAllTs_result();
2494 try {
2495 iface_.deleteAllTs(args.tableName, args.row, args.column, args.timestamp);
2496 } catch (IOError io) {
2497 result.io = io;
2498 } catch (Throwable th) {
2499 LOGGER.error("Internal error processing deleteAllTs", th);
2500 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllTs");
2501 oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.EXCEPTION, seqid));
2502 x.write(oprot);
2503 oprot.writeMessageEnd();
2504 oprot.getTransport().flush();
2505 return;
2506 }
2507 oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.REPLY, seqid));
2508 result.write(oprot);
2509 oprot.writeMessageEnd();
2510 oprot.getTransport().flush();
2511 }
2512
2513 }
2514
2515 private class deleteAllRow implements ProcessFunction {
2516 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2517 {
2518 deleteAllRow_args args = new deleteAllRow_args();
2519 args.read(iprot);
2520 iprot.readMessageEnd();
2521 deleteAllRow_result result = new deleteAllRow_result();
2522 try {
2523 iface_.deleteAllRow(args.tableName, args.row);
2524 } catch (IOError io) {
2525 result.io = io;
2526 } catch (Throwable th) {
2527 LOGGER.error("Internal error processing deleteAllRow", th);
2528 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRow");
2529 oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.EXCEPTION, seqid));
2530 x.write(oprot);
2531 oprot.writeMessageEnd();
2532 oprot.getTransport().flush();
2533 return;
2534 }
2535 oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.REPLY, seqid));
2536 result.write(oprot);
2537 oprot.writeMessageEnd();
2538 oprot.getTransport().flush();
2539 }
2540
2541 }
2542
2543 private class deleteAllRowTs implements ProcessFunction {
2544 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2545 {
2546 deleteAllRowTs_args args = new deleteAllRowTs_args();
2547 args.read(iprot);
2548 iprot.readMessageEnd();
2549 deleteAllRowTs_result result = new deleteAllRowTs_result();
2550 try {
2551 iface_.deleteAllRowTs(args.tableName, args.row, args.timestamp);
2552 } catch (IOError io) {
2553 result.io = io;
2554 } catch (Throwable th) {
2555 LOGGER.error("Internal error processing deleteAllRowTs", th);
2556 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRowTs");
2557 oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.EXCEPTION, seqid));
2558 x.write(oprot);
2559 oprot.writeMessageEnd();
2560 oprot.getTransport().flush();
2561 return;
2562 }
2563 oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.REPLY, seqid));
2564 result.write(oprot);
2565 oprot.writeMessageEnd();
2566 oprot.getTransport().flush();
2567 }
2568
2569 }
2570
2571 private class scannerOpen implements ProcessFunction {
2572 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2573 {
2574 scannerOpen_args args = new scannerOpen_args();
2575 args.read(iprot);
2576 iprot.readMessageEnd();
2577 scannerOpen_result result = new scannerOpen_result();
2578 try {
2579 result.success = iface_.scannerOpen(args.tableName, args.startRow, args.columns);
2580 result.setSuccessIsSet(true);
2581 } catch (IOError io) {
2582 result.io = io;
2583 } catch (Throwable th) {
2584 LOGGER.error("Internal error processing scannerOpen", th);
2585 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpen");
2586 oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.EXCEPTION, seqid));
2587 x.write(oprot);
2588 oprot.writeMessageEnd();
2589 oprot.getTransport().flush();
2590 return;
2591 }
2592 oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.REPLY, seqid));
2593 result.write(oprot);
2594 oprot.writeMessageEnd();
2595 oprot.getTransport().flush();
2596 }
2597
2598 }
2599
2600 private class scannerOpenWithStop implements ProcessFunction {
2601 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2602 {
2603 scannerOpenWithStop_args args = new scannerOpenWithStop_args();
2604 args.read(iprot);
2605 iprot.readMessageEnd();
2606 scannerOpenWithStop_result result = new scannerOpenWithStop_result();
2607 try {
2608 result.success = iface_.scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns);
2609 result.setSuccessIsSet(true);
2610 } catch (IOError io) {
2611 result.io = io;
2612 } catch (Throwable th) {
2613 LOGGER.error("Internal error processing scannerOpenWithStop", th);
2614 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStop");
2615 oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.EXCEPTION, seqid));
2616 x.write(oprot);
2617 oprot.writeMessageEnd();
2618 oprot.getTransport().flush();
2619 return;
2620 }
2621 oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.REPLY, seqid));
2622 result.write(oprot);
2623 oprot.writeMessageEnd();
2624 oprot.getTransport().flush();
2625 }
2626
2627 }
2628
2629 private class scannerOpenWithPrefix implements ProcessFunction {
2630 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2631 {
2632 scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
2633 args.read(iprot);
2634 iprot.readMessageEnd();
2635 scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
2636 try {
2637 result.success = iface_.scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns);
2638 result.setSuccessIsSet(true);
2639 } catch (IOError io) {
2640 result.io = io;
2641 } catch (Throwable th) {
2642 LOGGER.error("Internal error processing scannerOpenWithPrefix", th);
2643 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithPrefix");
2644 oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.EXCEPTION, seqid));
2645 x.write(oprot);
2646 oprot.writeMessageEnd();
2647 oprot.getTransport().flush();
2648 return;
2649 }
2650 oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.REPLY, seqid));
2651 result.write(oprot);
2652 oprot.writeMessageEnd();
2653 oprot.getTransport().flush();
2654 }
2655
2656 }
2657
2658 private class scannerOpenTs implements ProcessFunction {
2659 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2660 {
2661 scannerOpenTs_args args = new scannerOpenTs_args();
2662 args.read(iprot);
2663 iprot.readMessageEnd();
2664 scannerOpenTs_result result = new scannerOpenTs_result();
2665 try {
2666 result.success = iface_.scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp);
2667 result.setSuccessIsSet(true);
2668 } catch (IOError io) {
2669 result.io = io;
2670 } catch (Throwable th) {
2671 LOGGER.error("Internal error processing scannerOpenTs", th);
2672 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenTs");
2673 oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.EXCEPTION, seqid));
2674 x.write(oprot);
2675 oprot.writeMessageEnd();
2676 oprot.getTransport().flush();
2677 return;
2678 }
2679 oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.REPLY, seqid));
2680 result.write(oprot);
2681 oprot.writeMessageEnd();
2682 oprot.getTransport().flush();
2683 }
2684
2685 }
2686
2687 private class scannerOpenWithStopTs implements ProcessFunction {
2688 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2689 {
2690 scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
2691 args.read(iprot);
2692 iprot.readMessageEnd();
2693 scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
2694 try {
2695 result.success = iface_.scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp);
2696 result.setSuccessIsSet(true);
2697 } catch (IOError io) {
2698 result.io = io;
2699 } catch (Throwable th) {
2700 LOGGER.error("Internal error processing scannerOpenWithStopTs", th);
2701 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStopTs");
2702 oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.EXCEPTION, seqid));
2703 x.write(oprot);
2704 oprot.writeMessageEnd();
2705 oprot.getTransport().flush();
2706 return;
2707 }
2708 oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.REPLY, seqid));
2709 result.write(oprot);
2710 oprot.writeMessageEnd();
2711 oprot.getTransport().flush();
2712 }
2713
2714 }
2715
2716 private class scannerGet implements ProcessFunction {
2717 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2718 {
2719 scannerGet_args args = new scannerGet_args();
2720 args.read(iprot);
2721 iprot.readMessageEnd();
2722 scannerGet_result result = new scannerGet_result();
2723 try {
2724 result.success = iface_.scannerGet(args.id);
2725 } catch (IOError io) {
2726 result.io = io;
2727 } catch (IllegalArgument ia) {
2728 result.ia = ia;
2729 } catch (Throwable th) {
2730 LOGGER.error("Internal error processing scannerGet", th);
2731 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGet");
2732 oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.EXCEPTION, seqid));
2733 x.write(oprot);
2734 oprot.writeMessageEnd();
2735 oprot.getTransport().flush();
2736 return;
2737 }
2738 oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.REPLY, seqid));
2739 result.write(oprot);
2740 oprot.writeMessageEnd();
2741 oprot.getTransport().flush();
2742 }
2743
2744 }
2745
2746 private class scannerGetList implements ProcessFunction {
2747 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2748 {
2749 scannerGetList_args args = new scannerGetList_args();
2750 args.read(iprot);
2751 iprot.readMessageEnd();
2752 scannerGetList_result result = new scannerGetList_result();
2753 try {
2754 result.success = iface_.scannerGetList(args.id, args.nbRows);
2755 } catch (IOError io) {
2756 result.io = io;
2757 } catch (IllegalArgument ia) {
2758 result.ia = ia;
2759 } catch (Throwable th) {
2760 LOGGER.error("Internal error processing scannerGetList", th);
2761 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGetList");
2762 oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.EXCEPTION, seqid));
2763 x.write(oprot);
2764 oprot.writeMessageEnd();
2765 oprot.getTransport().flush();
2766 return;
2767 }
2768 oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.REPLY, seqid));
2769 result.write(oprot);
2770 oprot.writeMessageEnd();
2771 oprot.getTransport().flush();
2772 }
2773
2774 }
2775
2776 private class scannerClose implements ProcessFunction {
2777 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2778 {
2779 scannerClose_args args = new scannerClose_args();
2780 args.read(iprot);
2781 iprot.readMessageEnd();
2782 scannerClose_result result = new scannerClose_result();
2783 try {
2784 iface_.scannerClose(args.id);
2785 } catch (IOError io) {
2786 result.io = io;
2787 } catch (IllegalArgument ia) {
2788 result.ia = ia;
2789 } catch (Throwable th) {
2790 LOGGER.error("Internal error processing scannerClose", th);
2791 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerClose");
2792 oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.EXCEPTION, seqid));
2793 x.write(oprot);
2794 oprot.writeMessageEnd();
2795 oprot.getTransport().flush();
2796 return;
2797 }
2798 oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.REPLY, seqid));
2799 result.write(oprot);
2800 oprot.writeMessageEnd();
2801 oprot.getTransport().flush();
2802 }
2803
2804 }
2805
2806 }
2807
2808 public static class enableTable_args implements TBase<enableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_args> {
2809 private static final TStruct STRUCT_DESC = new TStruct("enableTable_args");
2810
2811 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
2812
2813
2814
2815
2816 public byte[] tableName;
2817
2818
2819 public enum _Fields implements TFieldIdEnum {
2820
2821
2822
2823 TABLE_NAME((short)1, "tableName");
2824
2825 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
2826 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2827
2828 static {
2829 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2830 byId.put((int)field._thriftId, field);
2831 byName.put(field.getFieldName(), field);
2832 }
2833 }
2834
2835
2836
2837
2838 public static _Fields findByThriftId(int fieldId) {
2839 return byId.get(fieldId);
2840 }
2841
2842
2843
2844
2845
2846 public static _Fields findByThriftIdOrThrow(int fieldId) {
2847 _Fields fields = findByThriftId(fieldId);
2848 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2849 return fields;
2850 }
2851
2852
2853
2854
2855 public static _Fields findByName(String name) {
2856 return byName.get(name);
2857 }
2858
2859 private final short _thriftId;
2860 private final String _fieldName;
2861
2862 _Fields(short thriftId, String fieldName) {
2863 _thriftId = thriftId;
2864 _fieldName = fieldName;
2865 }
2866
2867 public short getThriftFieldId() {
2868 return _thriftId;
2869 }
2870
2871 public String getFieldName() {
2872 return _fieldName;
2873 }
2874 }
2875
2876
2877
2878 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
2879 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
2880 new FieldValueMetaData(TType.STRING)));
2881 }});
2882
2883 static {
2884 FieldMetaData.addStructMetaDataMap(enableTable_args.class, metaDataMap);
2885 }
2886
2887 public enableTable_args() {
2888 }
2889
2890 public enableTable_args(
2891 byte[] tableName)
2892 {
2893 this();
2894 this.tableName = tableName;
2895 }
2896
2897
2898
2899
2900 public enableTable_args(enableTable_args other) {
2901 if (other.isSetTableName()) {
2902 this.tableName = other.tableName;
2903 }
2904 }
2905
2906 public enableTable_args deepCopy() {
2907 return new enableTable_args(this);
2908 }
2909
2910 @Deprecated
2911 public enableTable_args clone() {
2912 return new enableTable_args(this);
2913 }
2914
2915
2916
2917
2918 public byte[] getTableName() {
2919 return this.tableName;
2920 }
2921
2922
2923
2924
2925 public enableTable_args setTableName(byte[] tableName) {
2926 this.tableName = tableName;
2927 return this;
2928 }
2929
2930 public void unsetTableName() {
2931 this.tableName = null;
2932 }
2933
2934
2935 public boolean isSetTableName() {
2936 return this.tableName != null;
2937 }
2938
2939 public void setTableNameIsSet(boolean value) {
2940 if (!value) {
2941 this.tableName = null;
2942 }
2943 }
2944
2945 public void setFieldValue(_Fields field, Object value) {
2946 switch (field) {
2947 case TABLE_NAME:
2948 if (value == null) {
2949 unsetTableName();
2950 } else {
2951 setTableName((byte[])value);
2952 }
2953 break;
2954
2955 }
2956 }
2957
2958 public void setFieldValue(int fieldID, Object value) {
2959 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
2960 }
2961
2962 public Object getFieldValue(_Fields field) {
2963 switch (field) {
2964 case TABLE_NAME:
2965 return getTableName();
2966
2967 }
2968 throw new IllegalStateException();
2969 }
2970
2971 public Object getFieldValue(int fieldId) {
2972 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
2973 }
2974
2975
2976 public boolean isSet(_Fields field) {
2977 switch (field) {
2978 case TABLE_NAME:
2979 return isSetTableName();
2980 }
2981 throw new IllegalStateException();
2982 }
2983
2984 public boolean isSet(int fieldID) {
2985 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
2986 }
2987
2988 @Override
2989 public boolean equals(Object that) {
2990 if (that == null)
2991 return false;
2992 if (that instanceof enableTable_args)
2993 return this.equals((enableTable_args)that);
2994 return false;
2995 }
2996
2997 public boolean equals(enableTable_args that) {
2998 if (that == null)
2999 return false;
3000
3001 boolean this_present_tableName = true && this.isSetTableName();
3002 boolean that_present_tableName = true && that.isSetTableName();
3003 if (this_present_tableName || that_present_tableName) {
3004 if (!(this_present_tableName && that_present_tableName))
3005 return false;
3006 if (!java.util.Arrays.equals(this.tableName, that.tableName))
3007 return false;
3008 }
3009
3010 return true;
3011 }
3012
3013 @Override
3014 public int hashCode() {
3015 HashCodeBuilder builder = new HashCodeBuilder();
3016
3017 boolean present_tableName = true && (isSetTableName());
3018 builder.append(present_tableName);
3019 if (present_tableName)
3020 builder.append(tableName);
3021
3022 return builder.toHashCode();
3023 }
3024
3025 public int compareTo(enableTable_args other) {
3026 if (!getClass().equals(other.getClass())) {
3027 return getClass().getName().compareTo(other.getClass().getName());
3028 }
3029
3030 int lastComparison = 0;
3031 enableTable_args typedOther = (enableTable_args)other;
3032
3033 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
3034 if (lastComparison != 0) {
3035 return lastComparison;
3036 }
3037 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
3038 if (lastComparison != 0) {
3039 return lastComparison;
3040 }
3041 return 0;
3042 }
3043
3044 public void read(TProtocol iprot) throws TException {
3045 TField field;
3046 iprot.readStructBegin();
3047 while (true)
3048 {
3049 field = iprot.readFieldBegin();
3050 if (field.type == TType.STOP) {
3051 break;
3052 }
3053 _Fields fieldId = _Fields.findByThriftId(field.id);
3054 if (fieldId == null) {
3055 TProtocolUtil.skip(iprot, field.type);
3056 } else {
3057 switch (fieldId) {
3058 case TABLE_NAME:
3059 if (field.type == TType.STRING) {
3060 this.tableName = iprot.readBinary();
3061 } else {
3062 TProtocolUtil.skip(iprot, field.type);
3063 }
3064 break;
3065 }
3066 iprot.readFieldEnd();
3067 }
3068 }
3069 iprot.readStructEnd();
3070
3071
3072 validate();
3073 }
3074
3075 public void write(TProtocol oprot) throws TException {
3076 validate();
3077
3078 oprot.writeStructBegin(STRUCT_DESC);
3079 if (this.tableName != null) {
3080 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
3081 oprot.writeBinary(this.tableName);
3082 oprot.writeFieldEnd();
3083 }
3084 oprot.writeFieldStop();
3085 oprot.writeStructEnd();
3086 }
3087
3088 @Override
3089 public String toString() {
3090 StringBuilder sb = new StringBuilder("enableTable_args(");
3091 boolean first = true;
3092
3093 sb.append("tableName:");
3094 if (this.tableName == null) {
3095 sb.append("null");
3096 } else {
3097 sb.append(this.tableName);
3098 }
3099 first = false;
3100 sb.append(")");
3101 return sb.toString();
3102 }
3103
3104 public void validate() throws TException {
3105
3106 }
3107
3108 }
3109
3110 public static class enableTable_result implements TBase<enableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_result> {
3111 private static final TStruct STRUCT_DESC = new TStruct("enableTable_result");
3112
3113 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
3114
3115 public IOError io;
3116
3117
3118 public enum _Fields implements TFieldIdEnum {
3119 IO((short)1, "io");
3120
3121 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3122 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3123
3124 static {
3125 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3126 byId.put((int)field._thriftId, field);
3127 byName.put(field.getFieldName(), field);
3128 }
3129 }
3130
3131
3132
3133
3134 public static _Fields findByThriftId(int fieldId) {
3135 return byId.get(fieldId);
3136 }
3137
3138
3139
3140
3141
3142 public static _Fields findByThriftIdOrThrow(int fieldId) {
3143 _Fields fields = findByThriftId(fieldId);
3144 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3145 return fields;
3146 }
3147
3148
3149
3150
3151 public static _Fields findByName(String name) {
3152 return byName.get(name);
3153 }
3154
3155 private final short _thriftId;
3156 private final String _fieldName;
3157
3158 _Fields(short thriftId, String fieldName) {
3159 _thriftId = thriftId;
3160 _fieldName = fieldName;
3161 }
3162
3163 public short getThriftFieldId() {
3164 return _thriftId;
3165 }
3166
3167 public String getFieldName() {
3168 return _fieldName;
3169 }
3170 }
3171
3172
3173
3174 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3175 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
3176 new FieldValueMetaData(TType.STRUCT)));
3177 }});
3178
3179 static {
3180 FieldMetaData.addStructMetaDataMap(enableTable_result.class, metaDataMap);
3181 }
3182
3183 public enableTable_result() {
3184 }
3185
3186 public enableTable_result(
3187 IOError io)
3188 {
3189 this();
3190 this.io = io;
3191 }
3192
3193
3194
3195
3196 public enableTable_result(enableTable_result other) {
3197 if (other.isSetIo()) {
3198 this.io = new IOError(other.io);
3199 }
3200 }
3201
3202 public enableTable_result deepCopy() {
3203 return new enableTable_result(this);
3204 }
3205
3206 @Deprecated
3207 public enableTable_result clone() {
3208 return new enableTable_result(this);
3209 }
3210
3211 public IOError getIo() {
3212 return this.io;
3213 }
3214
3215 public enableTable_result setIo(IOError io) {
3216 this.io = io;
3217 return this;
3218 }
3219
3220 public void unsetIo() {
3221 this.io = null;
3222 }
3223
3224
3225 public boolean isSetIo() {
3226 return this.io != null;
3227 }
3228
3229 public void setIoIsSet(boolean value) {
3230 if (!value) {
3231 this.io = null;
3232 }
3233 }
3234
3235 public void setFieldValue(_Fields field, Object value) {
3236 switch (field) {
3237 case IO:
3238 if (value == null) {
3239 unsetIo();
3240 } else {
3241 setIo((IOError)value);
3242 }
3243 break;
3244
3245 }
3246 }
3247
3248 public void setFieldValue(int fieldID, Object value) {
3249 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3250 }
3251
3252 public Object getFieldValue(_Fields field) {
3253 switch (field) {
3254 case IO:
3255 return getIo();
3256
3257 }
3258 throw new IllegalStateException();
3259 }
3260
3261 public Object getFieldValue(int fieldId) {
3262 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3263 }
3264
3265
3266 public boolean isSet(_Fields field) {
3267 switch (field) {
3268 case IO:
3269 return isSetIo();
3270 }
3271 throw new IllegalStateException();
3272 }
3273
3274 public boolean isSet(int fieldID) {
3275 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3276 }
3277
3278 @Override
3279 public boolean equals(Object that) {
3280 if (that == null)
3281 return false;
3282 if (that instanceof enableTable_result)
3283 return this.equals((enableTable_result)that);
3284 return false;
3285 }
3286
3287 public boolean equals(enableTable_result that) {
3288 if (that == null)
3289 return false;
3290
3291 boolean this_present_io = true && this.isSetIo();
3292 boolean that_present_io = true && that.isSetIo();
3293 if (this_present_io || that_present_io) {
3294 if (!(this_present_io && that_present_io))
3295 return false;
3296 if (!this.io.equals(that.io))
3297 return false;
3298 }
3299
3300 return true;
3301 }
3302
3303 @Override
3304 public int hashCode() {
3305 HashCodeBuilder builder = new HashCodeBuilder();
3306
3307 boolean present_io = true && (isSetIo());
3308 builder.append(present_io);
3309 if (present_io)
3310 builder.append(io);
3311
3312 return builder.toHashCode();
3313 }
3314
3315 public int compareTo(enableTable_result other) {
3316 if (!getClass().equals(other.getClass())) {
3317 return getClass().getName().compareTo(other.getClass().getName());
3318 }
3319
3320 int lastComparison = 0;
3321 enableTable_result typedOther = (enableTable_result)other;
3322
3323 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
3324 if (lastComparison != 0) {
3325 return lastComparison;
3326 }
3327 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
3328 if (lastComparison != 0) {
3329 return lastComparison;
3330 }
3331 return 0;
3332 }
3333
3334 public void read(TProtocol iprot) throws TException {
3335 TField field;
3336 iprot.readStructBegin();
3337 while (true)
3338 {
3339 field = iprot.readFieldBegin();
3340 if (field.type == TType.STOP) {
3341 break;
3342 }
3343 _Fields fieldId = _Fields.findByThriftId(field.id);
3344 if (fieldId == null) {
3345 TProtocolUtil.skip(iprot, field.type);
3346 } else {
3347 switch (fieldId) {
3348 case IO:
3349 if (field.type == TType.STRUCT) {
3350 this.io = new IOError();
3351 this.io.read(iprot);
3352 } else {
3353 TProtocolUtil.skip(iprot, field.type);
3354 }
3355 break;
3356 }
3357 iprot.readFieldEnd();
3358 }
3359 }
3360 iprot.readStructEnd();
3361
3362
3363 validate();
3364 }
3365
3366 public void write(TProtocol oprot) throws TException {
3367 oprot.writeStructBegin(STRUCT_DESC);
3368
3369 if (this.isSetIo()) {
3370 oprot.writeFieldBegin(IO_FIELD_DESC);
3371 this.io.write(oprot);
3372 oprot.writeFieldEnd();
3373 }
3374 oprot.writeFieldStop();
3375 oprot.writeStructEnd();
3376 }
3377
3378 @Override
3379 public String toString() {
3380 StringBuilder sb = new StringBuilder("enableTable_result(");
3381 boolean first = true;
3382
3383 sb.append("io:");
3384 if (this.io == null) {
3385 sb.append("null");
3386 } else {
3387 sb.append(this.io);
3388 }
3389 first = false;
3390 sb.append(")");
3391 return sb.toString();
3392 }
3393
3394 public void validate() throws TException {
3395
3396 }
3397
3398 }
3399
3400 public static class disableTable_args implements TBase<disableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_args> {
3401 private static final TStruct STRUCT_DESC = new TStruct("disableTable_args");
3402
3403 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
3404
3405
3406
3407
3408 public byte[] tableName;
3409
3410
3411 public enum _Fields implements TFieldIdEnum {
3412
3413
3414
3415 TABLE_NAME((short)1, "tableName");
3416
3417 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3418 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3419
3420 static {
3421 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3422 byId.put((int)field._thriftId, field);
3423 byName.put(field.getFieldName(), field);
3424 }
3425 }
3426
3427
3428
3429
3430 public static _Fields findByThriftId(int fieldId) {
3431 return byId.get(fieldId);
3432 }
3433
3434
3435
3436
3437
3438 public static _Fields findByThriftIdOrThrow(int fieldId) {
3439 _Fields fields = findByThriftId(fieldId);
3440 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3441 return fields;
3442 }
3443
3444
3445
3446
3447 public static _Fields findByName(String name) {
3448 return byName.get(name);
3449 }
3450
3451 private final short _thriftId;
3452 private final String _fieldName;
3453
3454 _Fields(short thriftId, String fieldName) {
3455 _thriftId = thriftId;
3456 _fieldName = fieldName;
3457 }
3458
3459 public short getThriftFieldId() {
3460 return _thriftId;
3461 }
3462
3463 public String getFieldName() {
3464 return _fieldName;
3465 }
3466 }
3467
3468
3469
3470 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3471 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
3472 new FieldValueMetaData(TType.STRING)));
3473 }});
3474
3475 static {
3476 FieldMetaData.addStructMetaDataMap(disableTable_args.class, metaDataMap);
3477 }
3478
3479 public disableTable_args() {
3480 }
3481
3482 public disableTable_args(
3483 byte[] tableName)
3484 {
3485 this();
3486 this.tableName = tableName;
3487 }
3488
3489
3490
3491
3492 public disableTable_args(disableTable_args other) {
3493 if (other.isSetTableName()) {
3494 this.tableName = other.tableName;
3495 }
3496 }
3497
3498 public disableTable_args deepCopy() {
3499 return new disableTable_args(this);
3500 }
3501
3502 @Deprecated
3503 public disableTable_args clone() {
3504 return new disableTable_args(this);
3505 }
3506
3507
3508
3509
3510 public byte[] getTableName() {
3511 return this.tableName;
3512 }
3513
3514
3515
3516
3517 public disableTable_args setTableName(byte[] tableName) {
3518 this.tableName = tableName;
3519 return this;
3520 }
3521
3522 public void unsetTableName() {
3523 this.tableName = null;
3524 }
3525
3526
3527 public boolean isSetTableName() {
3528 return this.tableName != null;
3529 }
3530
3531 public void setTableNameIsSet(boolean value) {
3532 if (!value) {
3533 this.tableName = null;
3534 }
3535 }
3536
3537 public void setFieldValue(_Fields field, Object value) {
3538 switch (field) {
3539 case TABLE_NAME:
3540 if (value == null) {
3541 unsetTableName();
3542 } else {
3543 setTableName((byte[])value);
3544 }
3545 break;
3546
3547 }
3548 }
3549
3550 public void setFieldValue(int fieldID, Object value) {
3551 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3552 }
3553
3554 public Object getFieldValue(_Fields field) {
3555 switch (field) {
3556 case TABLE_NAME:
3557 return getTableName();
3558
3559 }
3560 throw new IllegalStateException();
3561 }
3562
3563 public Object getFieldValue(int fieldId) {
3564 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3565 }
3566
3567
3568 public boolean isSet(_Fields field) {
3569 switch (field) {
3570 case TABLE_NAME:
3571 return isSetTableName();
3572 }
3573 throw new IllegalStateException();
3574 }
3575
3576 public boolean isSet(int fieldID) {
3577 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3578 }
3579
3580 @Override
3581 public boolean equals(Object that) {
3582 if (that == null)
3583 return false;
3584 if (that instanceof disableTable_args)
3585 return this.equals((disableTable_args)that);
3586 return false;
3587 }
3588
3589 public boolean equals(disableTable_args that) {
3590 if (that == null)
3591 return false;
3592
3593 boolean this_present_tableName = true && this.isSetTableName();
3594 boolean that_present_tableName = true && that.isSetTableName();
3595 if (this_present_tableName || that_present_tableName) {
3596 if (!(this_present_tableName && that_present_tableName))
3597 return false;
3598 if (!java.util.Arrays.equals(this.tableName, that.tableName))
3599 return false;
3600 }
3601
3602 return true;
3603 }
3604
3605 @Override
3606 public int hashCode() {
3607 HashCodeBuilder builder = new HashCodeBuilder();
3608
3609 boolean present_tableName = true && (isSetTableName());
3610 builder.append(present_tableName);
3611 if (present_tableName)
3612 builder.append(tableName);
3613
3614 return builder.toHashCode();
3615 }
3616
3617 public int compareTo(disableTable_args other) {
3618 if (!getClass().equals(other.getClass())) {
3619 return getClass().getName().compareTo(other.getClass().getName());
3620 }
3621
3622 int lastComparison = 0;
3623 disableTable_args typedOther = (disableTable_args)other;
3624
3625 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
3626 if (lastComparison != 0) {
3627 return lastComparison;
3628 }
3629 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
3630 if (lastComparison != 0) {
3631 return lastComparison;
3632 }
3633 return 0;
3634 }
3635
3636 public void read(TProtocol iprot) throws TException {
3637 TField field;
3638 iprot.readStructBegin();
3639 while (true)
3640 {
3641 field = iprot.readFieldBegin();
3642 if (field.type == TType.STOP) {
3643 break;
3644 }
3645 _Fields fieldId = _Fields.findByThriftId(field.id);
3646 if (fieldId == null) {
3647 TProtocolUtil.skip(iprot, field.type);
3648 } else {
3649 switch (fieldId) {
3650 case TABLE_NAME:
3651 if (field.type == TType.STRING) {
3652 this.tableName = iprot.readBinary();
3653 } else {
3654 TProtocolUtil.skip(iprot, field.type);
3655 }
3656 break;
3657 }
3658 iprot.readFieldEnd();
3659 }
3660 }
3661 iprot.readStructEnd();
3662
3663
3664 validate();
3665 }
3666
3667 public void write(TProtocol oprot) throws TException {
3668 validate();
3669
3670 oprot.writeStructBegin(STRUCT_DESC);
3671 if (this.tableName != null) {
3672 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
3673 oprot.writeBinary(this.tableName);
3674 oprot.writeFieldEnd();
3675 }
3676 oprot.writeFieldStop();
3677 oprot.writeStructEnd();
3678 }
3679
3680 @Override
3681 public String toString() {
3682 StringBuilder sb = new StringBuilder("disableTable_args(");
3683 boolean first = true;
3684
3685 sb.append("tableName:");
3686 if (this.tableName == null) {
3687 sb.append("null");
3688 } else {
3689 sb.append(this.tableName);
3690 }
3691 first = false;
3692 sb.append(")");
3693 return sb.toString();
3694 }
3695
3696 public void validate() throws TException {
3697
3698 }
3699
3700 }
3701
3702 public static class disableTable_result implements TBase<disableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_result> {
3703 private static final TStruct STRUCT_DESC = new TStruct("disableTable_result");
3704
3705 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
3706
3707 public IOError io;
3708
3709
3710 public enum _Fields implements TFieldIdEnum {
3711 IO((short)1, "io");
3712
3713 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3714 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3715
3716 static {
3717 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3718 byId.put((int)field._thriftId, field);
3719 byName.put(field.getFieldName(), field);
3720 }
3721 }
3722
3723
3724
3725
3726 public static _Fields findByThriftId(int fieldId) {
3727 return byId.get(fieldId);
3728 }
3729
3730
3731
3732
3733
3734 public static _Fields findByThriftIdOrThrow(int fieldId) {
3735 _Fields fields = findByThriftId(fieldId);
3736 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3737 return fields;
3738 }
3739
3740
3741
3742
3743 public static _Fields findByName(String name) {
3744 return byName.get(name);
3745 }
3746
3747 private final short _thriftId;
3748 private final String _fieldName;
3749
3750 _Fields(short thriftId, String fieldName) {
3751 _thriftId = thriftId;
3752 _fieldName = fieldName;
3753 }
3754
3755 public short getThriftFieldId() {
3756 return _thriftId;
3757 }
3758
3759 public String getFieldName() {
3760 return _fieldName;
3761 }
3762 }
3763
3764
3765
3766 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3767 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
3768 new FieldValueMetaData(TType.STRUCT)));
3769 }});
3770
3771 static {
3772 FieldMetaData.addStructMetaDataMap(disableTable_result.class, metaDataMap);
3773 }
3774
3775 public disableTable_result() {
3776 }
3777
3778 public disableTable_result(
3779 IOError io)
3780 {
3781 this();
3782 this.io = io;
3783 }
3784
3785
3786
3787
3788 public disableTable_result(disableTable_result other) {
3789 if (other.isSetIo()) {
3790 this.io = new IOError(other.io);
3791 }
3792 }
3793
3794 public disableTable_result deepCopy() {
3795 return new disableTable_result(this);
3796 }
3797
3798 @Deprecated
3799 public disableTable_result clone() {
3800 return new disableTable_result(this);
3801 }
3802
3803 public IOError getIo() {
3804 return this.io;
3805 }
3806
3807 public disableTable_result setIo(IOError io) {
3808 this.io = io;
3809 return this;
3810 }
3811
3812 public void unsetIo() {
3813 this.io = null;
3814 }
3815
3816
3817 public boolean isSetIo() {
3818 return this.io != null;
3819 }
3820
3821 public void setIoIsSet(boolean value) {
3822 if (!value) {
3823 this.io = null;
3824 }
3825 }
3826
3827 public void setFieldValue(_Fields field, Object value) {
3828 switch (field) {
3829 case IO:
3830 if (value == null) {
3831 unsetIo();
3832 } else {
3833 setIo((IOError)value);
3834 }
3835 break;
3836
3837 }
3838 }
3839
3840 public void setFieldValue(int fieldID, Object value) {
3841 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3842 }
3843
3844 public Object getFieldValue(_Fields field) {
3845 switch (field) {
3846 case IO:
3847 return getIo();
3848
3849 }
3850 throw new IllegalStateException();
3851 }
3852
3853 public Object getFieldValue(int fieldId) {
3854 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3855 }
3856
3857
3858 public boolean isSet(_Fields field) {
3859 switch (field) {
3860 case IO:
3861 return isSetIo();
3862 }
3863 throw new IllegalStateException();
3864 }
3865
3866 public boolean isSet(int fieldID) {
3867 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3868 }
3869
3870 @Override
3871 public boolean equals(Object that) {
3872 if (that == null)
3873 return false;
3874 if (that instanceof disableTable_result)
3875 return this.equals((disableTable_result)that);
3876 return false;
3877 }
3878
3879 public boolean equals(disableTable_result that) {
3880 if (that == null)
3881 return false;
3882
3883 boolean this_present_io = true && this.isSetIo();
3884 boolean that_present_io = true && that.isSetIo();
3885 if (this_present_io || that_present_io) {
3886 if (!(this_present_io && that_present_io))
3887 return false;
3888 if (!this.io.equals(that.io))
3889 return false;
3890 }
3891
3892 return true;
3893 }
3894
3895 @Override
3896 public int hashCode() {
3897 HashCodeBuilder builder = new HashCodeBuilder();
3898
3899 boolean present_io = true && (isSetIo());
3900 builder.append(present_io);
3901 if (present_io)
3902 builder.append(io);
3903
3904 return builder.toHashCode();
3905 }
3906
3907 public int compareTo(disableTable_result other) {
3908 if (!getClass().equals(other.getClass())) {
3909 return getClass().getName().compareTo(other.getClass().getName());
3910 }
3911
3912 int lastComparison = 0;
3913 disableTable_result typedOther = (disableTable_result)other;
3914
3915 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
3916 if (lastComparison != 0) {
3917 return lastComparison;
3918 }
3919 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
3920 if (lastComparison != 0) {
3921 return lastComparison;
3922 }
3923 return 0;
3924 }
3925
3926 public void read(TProtocol iprot) throws TException {
3927 TField field;
3928 iprot.readStructBegin();
3929 while (true)
3930 {
3931 field = iprot.readFieldBegin();
3932 if (field.type == TType.STOP) {
3933 break;
3934 }
3935 _Fields fieldId = _Fields.findByThriftId(field.id);
3936 if (fieldId == null) {
3937 TProtocolUtil.skip(iprot, field.type);
3938 } else {
3939 switch (fieldId) {
3940 case IO:
3941 if (field.type == TType.STRUCT) {
3942 this.io = new IOError();
3943 this.io.read(iprot);
3944 } else {
3945 TProtocolUtil.skip(iprot, field.type);
3946 }
3947 break;
3948 }
3949 iprot.readFieldEnd();
3950 }
3951 }
3952 iprot.readStructEnd();
3953
3954
3955 validate();
3956 }
3957
3958 public void write(TProtocol oprot) throws TException {
3959 oprot.writeStructBegin(STRUCT_DESC);
3960
3961 if (this.isSetIo()) {
3962 oprot.writeFieldBegin(IO_FIELD_DESC);
3963 this.io.write(oprot);
3964 oprot.writeFieldEnd();
3965 }
3966 oprot.writeFieldStop();
3967 oprot.writeStructEnd();
3968 }
3969
3970 @Override
3971 public String toString() {
3972 StringBuilder sb = new StringBuilder("disableTable_result(");
3973 boolean first = true;
3974
3975 sb.append("io:");
3976 if (this.io == null) {
3977 sb.append("null");
3978 } else {
3979 sb.append(this.io);
3980 }
3981 first = false;
3982 sb.append(")");
3983 return sb.toString();
3984 }
3985
3986 public void validate() throws TException {
3987
3988 }
3989
3990 }
3991
3992 public static class isTableEnabled_args implements TBase<isTableEnabled_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_args> {
3993 private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_args");
3994
3995 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
3996
3997
3998
3999
4000 public byte[] tableName;
4001
4002
4003 public enum _Fields implements TFieldIdEnum {
4004
4005
4006
4007 TABLE_NAME((short)1, "tableName");
4008
4009 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4010 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4011
4012 static {
4013 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4014 byId.put((int)field._thriftId, field);
4015 byName.put(field.getFieldName(), field);
4016 }
4017 }
4018
4019
4020
4021
4022 public static _Fields findByThriftId(int fieldId) {
4023 return byId.get(fieldId);
4024 }
4025
4026
4027
4028
4029
4030 public static _Fields findByThriftIdOrThrow(int fieldId) {
4031 _Fields fields = findByThriftId(fieldId);
4032 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4033 return fields;
4034 }
4035
4036
4037
4038
4039 public static _Fields findByName(String name) {
4040 return byName.get(name);
4041 }
4042
4043 private final short _thriftId;
4044 private final String _fieldName;
4045
4046 _Fields(short thriftId, String fieldName) {
4047 _thriftId = thriftId;
4048 _fieldName = fieldName;
4049 }
4050
4051 public short getThriftFieldId() {
4052 return _thriftId;
4053 }
4054
4055 public String getFieldName() {
4056 return _fieldName;
4057 }
4058 }
4059
4060
4061
4062 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4063 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
4064 new FieldValueMetaData(TType.STRING)));
4065 }});
4066
4067 static {
4068 FieldMetaData.addStructMetaDataMap(isTableEnabled_args.class, metaDataMap);
4069 }
4070
4071 public isTableEnabled_args() {
4072 }
4073
4074 public isTableEnabled_args(
4075 byte[] tableName)
4076 {
4077 this();
4078 this.tableName = tableName;
4079 }
4080
4081
4082
4083
4084 public isTableEnabled_args(isTableEnabled_args other) {
4085 if (other.isSetTableName()) {
4086 this.tableName = other.tableName;
4087 }
4088 }
4089
4090 public isTableEnabled_args deepCopy() {
4091 return new isTableEnabled_args(this);
4092 }
4093
4094 @Deprecated
4095 public isTableEnabled_args clone() {
4096 return new isTableEnabled_args(this);
4097 }
4098
4099
4100
4101
4102 public byte[] getTableName() {
4103 return this.tableName;
4104 }
4105
4106
4107
4108
4109 public isTableEnabled_args setTableName(byte[] tableName) {
4110 this.tableName = tableName;
4111 return this;
4112 }
4113
4114 public void unsetTableName() {
4115 this.tableName = null;
4116 }
4117
4118
4119 public boolean isSetTableName() {
4120 return this.tableName != null;
4121 }
4122
4123 public void setTableNameIsSet(boolean value) {
4124 if (!value) {
4125 this.tableName = null;
4126 }
4127 }
4128
4129 public void setFieldValue(_Fields field, Object value) {
4130 switch (field) {
4131 case TABLE_NAME:
4132 if (value == null) {
4133 unsetTableName();
4134 } else {
4135 setTableName((byte[])value);
4136 }
4137 break;
4138
4139 }
4140 }
4141
4142 public void setFieldValue(int fieldID, Object value) {
4143 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4144 }
4145
4146 public Object getFieldValue(_Fields field) {
4147 switch (field) {
4148 case TABLE_NAME:
4149 return getTableName();
4150
4151 }
4152 throw new IllegalStateException();
4153 }
4154
4155 public Object getFieldValue(int fieldId) {
4156 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4157 }
4158
4159
4160 public boolean isSet(_Fields field) {
4161 switch (field) {
4162 case TABLE_NAME:
4163 return isSetTableName();
4164 }
4165 throw new IllegalStateException();
4166 }
4167
4168 public boolean isSet(int fieldID) {
4169 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4170 }
4171
4172 @Override
4173 public boolean equals(Object that) {
4174 if (that == null)
4175 return false;
4176 if (that instanceof isTableEnabled_args)
4177 return this.equals((isTableEnabled_args)that);
4178 return false;
4179 }
4180
4181 public boolean equals(isTableEnabled_args that) {
4182 if (that == null)
4183 return false;
4184
4185 boolean this_present_tableName = true && this.isSetTableName();
4186 boolean that_present_tableName = true && that.isSetTableName();
4187 if (this_present_tableName || that_present_tableName) {
4188 if (!(this_present_tableName && that_present_tableName))
4189 return false;
4190 if (!java.util.Arrays.equals(this.tableName, that.tableName))
4191 return false;
4192 }
4193
4194 return true;
4195 }
4196
4197 @Override
4198 public int hashCode() {
4199 HashCodeBuilder builder = new HashCodeBuilder();
4200
4201 boolean present_tableName = true && (isSetTableName());
4202 builder.append(present_tableName);
4203 if (present_tableName)
4204 builder.append(tableName);
4205
4206 return builder.toHashCode();
4207 }
4208
4209 public int compareTo(isTableEnabled_args other) {
4210 if (!getClass().equals(other.getClass())) {
4211 return getClass().getName().compareTo(other.getClass().getName());
4212 }
4213
4214 int lastComparison = 0;
4215 isTableEnabled_args typedOther = (isTableEnabled_args)other;
4216
4217 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
4218 if (lastComparison != 0) {
4219 return lastComparison;
4220 }
4221 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
4222 if (lastComparison != 0) {
4223 return lastComparison;
4224 }
4225 return 0;
4226 }
4227
4228 public void read(TProtocol iprot) throws TException {
4229 TField field;
4230 iprot.readStructBegin();
4231 while (true)
4232 {
4233 field = iprot.readFieldBegin();
4234 if (field.type == TType.STOP) {
4235 break;
4236 }
4237 _Fields fieldId = _Fields.findByThriftId(field.id);
4238 if (fieldId == null) {
4239 TProtocolUtil.skip(iprot, field.type);
4240 } else {
4241 switch (fieldId) {
4242 case TABLE_NAME:
4243 if (field.type == TType.STRING) {
4244 this.tableName = iprot.readBinary();
4245 } else {
4246 TProtocolUtil.skip(iprot, field.type);
4247 }
4248 break;
4249 }
4250 iprot.readFieldEnd();
4251 }
4252 }
4253 iprot.readStructEnd();
4254
4255
4256 validate();
4257 }
4258
4259 public void write(TProtocol oprot) throws TException {
4260 validate();
4261
4262 oprot.writeStructBegin(STRUCT_DESC);
4263 if (this.tableName != null) {
4264 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
4265 oprot.writeBinary(this.tableName);
4266 oprot.writeFieldEnd();
4267 }
4268 oprot.writeFieldStop();
4269 oprot.writeStructEnd();
4270 }
4271
4272 @Override
4273 public String toString() {
4274 StringBuilder sb = new StringBuilder("isTableEnabled_args(");
4275 boolean first = true;
4276
4277 sb.append("tableName:");
4278 if (this.tableName == null) {
4279 sb.append("null");
4280 } else {
4281 sb.append(this.tableName);
4282 }
4283 first = false;
4284 sb.append(")");
4285 return sb.toString();
4286 }
4287
4288 public void validate() throws TException {
4289
4290 }
4291
4292 }
4293
4294 public static class isTableEnabled_result implements TBase<isTableEnabled_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_result> {
4295 private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_result");
4296
4297 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0);
4298 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
4299
4300 public boolean success;
4301 public IOError io;
4302
4303
4304 public enum _Fields implements TFieldIdEnum {
4305 SUCCESS((short)0, "success"),
4306 IO((short)1, "io");
4307
4308 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4309 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4310
4311 static {
4312 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4313 byId.put((int)field._thriftId, field);
4314 byName.put(field.getFieldName(), field);
4315 }
4316 }
4317
4318
4319
4320
4321 public static _Fields findByThriftId(int fieldId) {
4322 return byId.get(fieldId);
4323 }
4324
4325
4326
4327
4328
4329 public static _Fields findByThriftIdOrThrow(int fieldId) {
4330 _Fields fields = findByThriftId(fieldId);
4331 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4332 return fields;
4333 }
4334
4335
4336
4337
4338 public static _Fields findByName(String name) {
4339 return byName.get(name);
4340 }
4341
4342 private final short _thriftId;
4343 private final String _fieldName;
4344
4345 _Fields(short thriftId, String fieldName) {
4346 _thriftId = thriftId;
4347 _fieldName = fieldName;
4348 }
4349
4350 public short getThriftFieldId() {
4351 return _thriftId;
4352 }
4353
4354 public String getFieldName() {
4355 return _fieldName;
4356 }
4357 }
4358
4359
4360 private static final int __SUCCESS_ISSET_ID = 0;
4361 private BitSet __isset_bit_vector = new BitSet(1);
4362
4363 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4364 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
4365 new FieldValueMetaData(TType.BOOL)));
4366 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
4367 new FieldValueMetaData(TType.STRUCT)));
4368 }});
4369
4370 static {
4371 FieldMetaData.addStructMetaDataMap(isTableEnabled_result.class, metaDataMap);
4372 }
4373
4374 public isTableEnabled_result() {
4375 }
4376
4377 public isTableEnabled_result(
4378 boolean success,
4379 IOError io)
4380 {
4381 this();
4382 this.success = success;
4383 setSuccessIsSet(true);
4384 this.io = io;
4385 }
4386
4387
4388
4389
4390 public isTableEnabled_result(isTableEnabled_result other) {
4391 __isset_bit_vector.clear();
4392 __isset_bit_vector.or(other.__isset_bit_vector);
4393 this.success = other.success;
4394 if (other.isSetIo()) {
4395 this.io = new IOError(other.io);
4396 }
4397 }
4398
4399 public isTableEnabled_result deepCopy() {
4400 return new isTableEnabled_result(this);
4401 }
4402
4403 @Deprecated
4404 public isTableEnabled_result clone() {
4405 return new isTableEnabled_result(this);
4406 }
4407
4408 public boolean isSuccess() {
4409 return this.success;
4410 }
4411
4412 public isTableEnabled_result setSuccess(boolean success) {
4413 this.success = success;
4414 setSuccessIsSet(true);
4415 return this;
4416 }
4417
4418 public void unsetSuccess() {
4419 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
4420 }
4421
4422
4423 public boolean isSetSuccess() {
4424 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
4425 }
4426
4427 public void setSuccessIsSet(boolean value) {
4428 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
4429 }
4430
4431 public IOError getIo() {
4432 return this.io;
4433 }
4434
4435 public isTableEnabled_result setIo(IOError io) {
4436 this.io = io;
4437 return this;
4438 }
4439
4440 public void unsetIo() {
4441 this.io = null;
4442 }
4443
4444
4445 public boolean isSetIo() {
4446 return this.io != null;
4447 }
4448
4449 public void setIoIsSet(boolean value) {
4450 if (!value) {
4451 this.io = null;
4452 }
4453 }
4454
4455 public void setFieldValue(_Fields field, Object value) {
4456 switch (field) {
4457 case SUCCESS:
4458 if (value == null) {
4459 unsetSuccess();
4460 } else {
4461 setSuccess((Boolean)value);
4462 }
4463 break;
4464
4465 case IO:
4466 if (value == null) {
4467 unsetIo();
4468 } else {
4469 setIo((IOError)value);
4470 }
4471 break;
4472
4473 }
4474 }
4475
4476 public void setFieldValue(int fieldID, Object value) {
4477 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4478 }
4479
4480 public Object getFieldValue(_Fields field) {
4481 switch (field) {
4482 case SUCCESS:
4483 return new Boolean(isSuccess());
4484
4485 case IO:
4486 return getIo();
4487
4488 }
4489 throw new IllegalStateException();
4490 }
4491
4492 public Object getFieldValue(int fieldId) {
4493 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4494 }
4495
4496
4497 public boolean isSet(_Fields field) {
4498 switch (field) {
4499 case SUCCESS:
4500 return isSetSuccess();
4501 case IO:
4502 return isSetIo();
4503 }
4504 throw new IllegalStateException();
4505 }
4506
4507 public boolean isSet(int fieldID) {
4508 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4509 }
4510
4511 @Override
4512 public boolean equals(Object that) {
4513 if (that == null)
4514 return false;
4515 if (that instanceof isTableEnabled_result)
4516 return this.equals((isTableEnabled_result)that);
4517 return false;
4518 }
4519
4520 public boolean equals(isTableEnabled_result that) {
4521 if (that == null)
4522 return false;
4523
4524 boolean this_present_success = true;
4525 boolean that_present_success = true;
4526 if (this_present_success || that_present_success) {
4527 if (!(this_present_success && that_present_success))
4528 return false;
4529 if (this.success != that.success)
4530 return false;
4531 }
4532
4533 boolean this_present_io = true && this.isSetIo();
4534 boolean that_present_io = true && that.isSetIo();
4535 if (this_present_io || that_present_io) {
4536 if (!(this_present_io && that_present_io))
4537 return false;
4538 if (!this.io.equals(that.io))
4539 return false;
4540 }
4541
4542 return true;
4543 }
4544
4545 @Override
4546 public int hashCode() {
4547 HashCodeBuilder builder = new HashCodeBuilder();
4548
4549 boolean present_success = true;
4550 builder.append(present_success);
4551 if (present_success)
4552 builder.append(success);
4553
4554 boolean present_io = true && (isSetIo());
4555 builder.append(present_io);
4556 if (present_io)
4557 builder.append(io);
4558
4559 return builder.toHashCode();
4560 }
4561
4562 public int compareTo(isTableEnabled_result other) {
4563 if (!getClass().equals(other.getClass())) {
4564 return getClass().getName().compareTo(other.getClass().getName());
4565 }
4566
4567 int lastComparison = 0;
4568 isTableEnabled_result typedOther = (isTableEnabled_result)other;
4569
4570 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
4571 if (lastComparison != 0) {
4572 return lastComparison;
4573 }
4574 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
4575 if (lastComparison != 0) {
4576 return lastComparison;
4577 }
4578 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
4579 if (lastComparison != 0) {
4580 return lastComparison;
4581 }
4582 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
4583 if (lastComparison != 0) {
4584 return lastComparison;
4585 }
4586 return 0;
4587 }
4588
4589 public void read(TProtocol iprot) throws TException {
4590 TField field;
4591 iprot.readStructBegin();
4592 while (true)
4593 {
4594 field = iprot.readFieldBegin();
4595 if (field.type == TType.STOP) {
4596 break;
4597 }
4598 _Fields fieldId = _Fields.findByThriftId(field.id);
4599 if (fieldId == null) {
4600 TProtocolUtil.skip(iprot, field.type);
4601 } else {
4602 switch (fieldId) {
4603 case SUCCESS:
4604 if (field.type == TType.BOOL) {
4605 this.success = iprot.readBool();
4606 setSuccessIsSet(true);
4607 } else {
4608 TProtocolUtil.skip(iprot, field.type);
4609 }
4610 break;
4611 case IO:
4612 if (field.type == TType.STRUCT) {
4613 this.io = new IOError();
4614 this.io.read(iprot);
4615 } else {
4616 TProtocolUtil.skip(iprot, field.type);
4617 }
4618 break;
4619 }
4620 iprot.readFieldEnd();
4621 }
4622 }
4623 iprot.readStructEnd();
4624
4625
4626 validate();
4627 }
4628
4629 public void write(TProtocol oprot) throws TException {
4630 oprot.writeStructBegin(STRUCT_DESC);
4631
4632 if (this.isSetSuccess()) {
4633 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4634 oprot.writeBool(this.success);
4635 oprot.writeFieldEnd();
4636 } else if (this.isSetIo()) {
4637 oprot.writeFieldBegin(IO_FIELD_DESC);
4638 this.io.write(oprot);
4639 oprot.writeFieldEnd();
4640 }
4641 oprot.writeFieldStop();
4642 oprot.writeStructEnd();
4643 }
4644
4645 @Override
4646 public String toString() {
4647 StringBuilder sb = new StringBuilder("isTableEnabled_result(");
4648 boolean first = true;
4649
4650 sb.append("success:");
4651 sb.append(this.success);
4652 first = false;
4653 if (!first) sb.append(", ");
4654 sb.append("io:");
4655 if (this.io == null) {
4656 sb.append("null");
4657 } else {
4658 sb.append(this.io);
4659 }
4660 first = false;
4661 sb.append(")");
4662 return sb.toString();
4663 }
4664
4665 public void validate() throws TException {
4666
4667 }
4668
4669 }
4670
4671 public static class compact_args implements TBase<compact_args._Fields>, java.io.Serializable, Cloneable, Comparable<compact_args> {
4672 private static final TStruct STRUCT_DESC = new TStruct("compact_args");
4673
4674 private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1);
4675
4676 public byte[] tableNameOrRegionName;
4677
4678
4679 public enum _Fields implements TFieldIdEnum {
4680 TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
4681
4682 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4683 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4684
4685 static {
4686 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4687 byId.put((int)field._thriftId, field);
4688 byName.put(field.getFieldName(), field);
4689 }
4690 }
4691
4692
4693
4694
4695 public static _Fields findByThriftId(int fieldId) {
4696 return byId.get(fieldId);
4697 }
4698
4699
4700
4701
4702
4703 public static _Fields findByThriftIdOrThrow(int fieldId) {
4704 _Fields fields = findByThriftId(fieldId);
4705 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4706 return fields;
4707 }
4708
4709
4710
4711
4712 public static _Fields findByName(String name) {
4713 return byName.get(name);
4714 }
4715
4716 private final short _thriftId;
4717 private final String _fieldName;
4718
4719 _Fields(short thriftId, String fieldName) {
4720 _thriftId = thriftId;
4721 _fieldName = fieldName;
4722 }
4723
4724 public short getThriftFieldId() {
4725 return _thriftId;
4726 }
4727
4728 public String getFieldName() {
4729 return _fieldName;
4730 }
4731 }
4732
4733
4734
4735 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4736 put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT,
4737 new FieldValueMetaData(TType.STRING)));
4738 }});
4739
4740 static {
4741 FieldMetaData.addStructMetaDataMap(compact_args.class, metaDataMap);
4742 }
4743
4744 public compact_args() {
4745 }
4746
4747 public compact_args(
4748 byte[] tableNameOrRegionName)
4749 {
4750 this();
4751 this.tableNameOrRegionName = tableNameOrRegionName;
4752 }
4753
4754
4755
4756
4757 public compact_args(compact_args other) {
4758 if (other.isSetTableNameOrRegionName()) {
4759 this.tableNameOrRegionName = other.tableNameOrRegionName;
4760 }
4761 }
4762
4763 public compact_args deepCopy() {
4764 return new compact_args(this);
4765 }
4766
4767 @Deprecated
4768 public compact_args clone() {
4769 return new compact_args(this);
4770 }
4771
4772 public byte[] getTableNameOrRegionName() {
4773 return this.tableNameOrRegionName;
4774 }
4775
4776 public compact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
4777 this.tableNameOrRegionName = tableNameOrRegionName;
4778 return this;
4779 }
4780
4781 public void unsetTableNameOrRegionName() {
4782 this.tableNameOrRegionName = null;
4783 }
4784
4785
4786 public boolean isSetTableNameOrRegionName() {
4787 return this.tableNameOrRegionName != null;
4788 }
4789
4790 public void setTableNameOrRegionNameIsSet(boolean value) {
4791 if (!value) {
4792 this.tableNameOrRegionName = null;
4793 }
4794 }
4795
4796 public void setFieldValue(_Fields field, Object value) {
4797 switch (field) {
4798 case TABLE_NAME_OR_REGION_NAME:
4799 if (value == null) {
4800 unsetTableNameOrRegionName();
4801 } else {
4802 setTableNameOrRegionName((byte[])value);
4803 }
4804 break;
4805
4806 }
4807 }
4808
4809 public void setFieldValue(int fieldID, Object value) {
4810 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4811 }
4812
4813 public Object getFieldValue(_Fields field) {
4814 switch (field) {
4815 case TABLE_NAME_OR_REGION_NAME:
4816 return getTableNameOrRegionName();
4817
4818 }
4819 throw new IllegalStateException();
4820 }
4821
4822 public Object getFieldValue(int fieldId) {
4823 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4824 }
4825
4826
4827 public boolean isSet(_Fields field) {
4828 switch (field) {
4829 case TABLE_NAME_OR_REGION_NAME:
4830 return isSetTableNameOrRegionName();
4831 }
4832 throw new IllegalStateException();
4833 }
4834
4835 public boolean isSet(int fieldID) {
4836 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4837 }
4838
4839 @Override
4840 public boolean equals(Object that) {
4841 if (that == null)
4842 return false;
4843 if (that instanceof compact_args)
4844 return this.equals((compact_args)that);
4845 return false;
4846 }
4847
4848 public boolean equals(compact_args that) {
4849 if (that == null)
4850 return false;
4851
4852 boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
4853 boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
4854 if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
4855 if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
4856 return false;
4857 if (!java.util.Arrays.equals(this.tableNameOrRegionName, that.tableNameOrRegionName))
4858 return false;
4859 }
4860
4861 return true;
4862 }
4863
4864 @Override
4865 public int hashCode() {
4866 HashCodeBuilder builder = new HashCodeBuilder();
4867
4868 boolean present_tableNameOrRegionName = true && (isSetTableNameOrRegionName());
4869 builder.append(present_tableNameOrRegionName);
4870 if (present_tableNameOrRegionName)
4871 builder.append(tableNameOrRegionName);
4872
4873 return builder.toHashCode();
4874 }
4875
4876 public int compareTo(compact_args other) {
4877 if (!getClass().equals(other.getClass())) {
4878 return getClass().getName().compareTo(other.getClass().getName());
4879 }
4880
4881 int lastComparison = 0;
4882 compact_args typedOther = (compact_args)other;
4883
4884 lastComparison = Boolean.valueOf(isSetTableNameOrRegionName()).compareTo(isSetTableNameOrRegionName());
4885 if (lastComparison != 0) {
4886 return lastComparison;
4887 }
4888 lastComparison = TBaseHelper.compareTo(tableNameOrRegionName, typedOther.tableNameOrRegionName);
4889 if (lastComparison != 0) {
4890 return lastComparison;
4891 }
4892 return 0;
4893 }
4894
4895 public void read(TProtocol iprot) throws TException {
4896 TField field;
4897 iprot.readStructBegin();
4898 while (true)
4899 {
4900 field = iprot.readFieldBegin();
4901 if (field.type == TType.STOP) {
4902 break;
4903 }
4904 _Fields fieldId = _Fields.findByThriftId(field.id);
4905 if (fieldId == null) {
4906 TProtocolUtil.skip(iprot, field.type);
4907 } else {
4908 switch (fieldId) {
4909 case TABLE_NAME_OR_REGION_NAME:
4910 if (field.type == TType.STRING) {
4911 this.tableNameOrRegionName = iprot.readBinary();
4912 } else {
4913 TProtocolUtil.skip(iprot, field.type);
4914 }
4915 break;
4916 }
4917 iprot.readFieldEnd();
4918 }
4919 }
4920 iprot.readStructEnd();
4921
4922
4923 validate();
4924 }
4925
4926 public void write(TProtocol oprot) throws TException {
4927 validate();
4928
4929 oprot.writeStructBegin(STRUCT_DESC);
4930 if (this.tableNameOrRegionName != null) {
4931 oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
4932 oprot.writeBinary(this.tableNameOrRegionName);
4933 oprot.writeFieldEnd();
4934 }
4935 oprot.writeFieldStop();
4936 oprot.writeStructEnd();
4937 }
4938
4939 @Override
4940 public String toString() {
4941 StringBuilder sb = new StringBuilder("compact_args(");
4942 boolean first = true;
4943
4944 sb.append("tableNameOrRegionName:");
4945 if (this.tableNameOrRegionName == null) {
4946 sb.append("null");
4947 } else {
4948 sb.append(this.tableNameOrRegionName);
4949 }
4950 first = false;
4951 sb.append(")");
4952 return sb.toString();
4953 }
4954
4955 public void validate() throws TException {
4956
4957 }
4958
4959 }
4960
4961 public static class compact_result implements TBase<compact_result._Fields>, java.io.Serializable, Cloneable, Comparable<compact_result> {
4962 private static final TStruct STRUCT_DESC = new TStruct("compact_result");
4963
4964 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
4965
4966 public IOError io;
4967
4968
4969 public enum _Fields implements TFieldIdEnum {
4970 IO((short)1, "io");
4971
4972 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4973 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4974
4975 static {
4976 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4977 byId.put((int)field._thriftId, field);
4978 byName.put(field.getFieldName(), field);
4979 }
4980 }
4981
4982
4983
4984
4985 public static _Fields findByThriftId(int fieldId) {
4986 return byId.get(fieldId);
4987 }
4988
4989
4990
4991
4992
4993 public static _Fields findByThriftIdOrThrow(int fieldId) {
4994 _Fields fields = findByThriftId(fieldId);
4995 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4996 return fields;
4997 }
4998
4999
5000
5001
5002 public static _Fields findByName(String name) {
5003 return byName.get(name);
5004 }
5005
5006 private final short _thriftId;
5007 private final String _fieldName;
5008
5009 _Fields(short thriftId, String fieldName) {
5010 _thriftId = thriftId;
5011 _fieldName = fieldName;
5012 }
5013
5014 public short getThriftFieldId() {
5015 return _thriftId;
5016 }
5017
5018 public String getFieldName() {
5019 return _fieldName;
5020 }
5021 }
5022
5023
5024
5025 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5026 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
5027 new FieldValueMetaData(TType.STRUCT)));
5028 }});
5029
5030 static {
5031 FieldMetaData.addStructMetaDataMap(compact_result.class, metaDataMap);
5032 }
5033
5034 public compact_result() {
5035 }
5036
5037 public compact_result(
5038 IOError io)
5039 {
5040 this();
5041 this.io = io;
5042 }
5043
5044
5045
5046
5047 public compact_result(compact_result other) {
5048 if (other.isSetIo()) {
5049 this.io = new IOError(other.io);
5050 }
5051 }
5052
5053 public compact_result deepCopy() {
5054 return new compact_result(this);
5055 }
5056
5057 @Deprecated
5058 public compact_result clone() {
5059 return new compact_result(this);
5060 }
5061
5062 public IOError getIo() {
5063 return this.io;
5064 }
5065
5066 public compact_result setIo(IOError io) {
5067 this.io = io;
5068 return this;
5069 }
5070
5071 public void unsetIo() {
5072 this.io = null;
5073 }
5074
5075
5076 public boolean isSetIo() {
5077 return this.io != null;
5078 }
5079
5080 public void setIoIsSet(boolean value) {
5081 if (!value) {
5082 this.io = null;
5083 }
5084 }
5085
5086 public void setFieldValue(_Fields field, Object value) {
5087 switch (field) {
5088 case IO:
5089 if (value == null) {
5090 unsetIo();
5091 } else {
5092 setIo((IOError)value);
5093 }
5094 break;
5095
5096 }
5097 }
5098
5099 public void setFieldValue(int fieldID, Object value) {
5100 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5101 }
5102
5103 public Object getFieldValue(_Fields field) {
5104 switch (field) {
5105 case IO:
5106 return getIo();
5107
5108 }
5109 throw new IllegalStateException();
5110 }
5111
5112 public Object getFieldValue(int fieldId) {
5113 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5114 }
5115
5116
5117 public boolean isSet(_Fields field) {
5118 switch (field) {
5119 case IO:
5120 return isSetIo();
5121 }
5122 throw new IllegalStateException();
5123 }
5124
5125 public boolean isSet(int fieldID) {
5126 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5127 }
5128
5129 @Override
5130 public boolean equals(Object that) {
5131 if (that == null)
5132 return false;
5133 if (that instanceof compact_result)
5134 return this.equals((compact_result)that);
5135 return false;
5136 }
5137
5138 public boolean equals(compact_result that) {
5139 if (that == null)
5140 return false;
5141
5142 boolean this_present_io = true && this.isSetIo();
5143 boolean that_present_io = true && that.isSetIo();
5144 if (this_present_io || that_present_io) {
5145 if (!(this_present_io && that_present_io))
5146 return false;
5147 if (!this.io.equals(that.io))
5148 return false;
5149 }
5150
5151 return true;
5152 }
5153
5154 @Override
5155 public int hashCode() {
5156 HashCodeBuilder builder = new HashCodeBuilder();
5157
5158 boolean present_io = true && (isSetIo());
5159 builder.append(present_io);
5160 if (present_io)
5161 builder.append(io);
5162
5163 return builder.toHashCode();
5164 }
5165
5166 public int compareTo(compact_result other) {
5167 if (!getClass().equals(other.getClass())) {
5168 return getClass().getName().compareTo(other.getClass().getName());
5169 }
5170
5171 int lastComparison = 0;
5172 compact_result typedOther = (compact_result)other;
5173
5174 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
5175 if (lastComparison != 0) {
5176 return lastComparison;
5177 }
5178 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
5179 if (lastComparison != 0) {
5180 return lastComparison;
5181 }
5182 return 0;
5183 }
5184
5185 public void read(TProtocol iprot) throws TException {
5186 TField field;
5187 iprot.readStructBegin();
5188 while (true)
5189 {
5190 field = iprot.readFieldBegin();
5191 if (field.type == TType.STOP) {
5192 break;
5193 }
5194 _Fields fieldId = _Fields.findByThriftId(field.id);
5195 if (fieldId == null) {
5196 TProtocolUtil.skip(iprot, field.type);
5197 } else {
5198 switch (fieldId) {
5199 case IO:
5200 if (field.type == TType.STRUCT) {
5201 this.io = new IOError();
5202 this.io.read(iprot);
5203 } else {
5204 TProtocolUtil.skip(iprot, field.type);
5205 }
5206 break;
5207 }
5208 iprot.readFieldEnd();
5209 }
5210 }
5211 iprot.readStructEnd();
5212
5213
5214 validate();
5215 }
5216
5217 public void write(TProtocol oprot) throws TException {
5218 oprot.writeStructBegin(STRUCT_DESC);
5219
5220 if (this.isSetIo()) {
5221 oprot.writeFieldBegin(IO_FIELD_DESC);
5222 this.io.write(oprot);
5223 oprot.writeFieldEnd();
5224 }
5225 oprot.writeFieldStop();
5226 oprot.writeStructEnd();
5227 }
5228
5229 @Override
5230 public String toString() {
5231 StringBuilder sb = new StringBuilder("compact_result(");
5232 boolean first = true;
5233
5234 sb.append("io:");
5235 if (this.io == null) {
5236 sb.append("null");
5237 } else {
5238 sb.append(this.io);
5239 }
5240 first = false;
5241 sb.append(")");
5242 return sb.toString();
5243 }
5244
5245 public void validate() throws TException {
5246
5247 }
5248
5249 }
5250
5251 public static class majorCompact_args implements TBase<majorCompact_args._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_args> {
5252 private static final TStruct STRUCT_DESC = new TStruct("majorCompact_args");
5253
5254 private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1);
5255
5256 public byte[] tableNameOrRegionName;
5257
5258
5259 public enum _Fields implements TFieldIdEnum {
5260 TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
5261
5262 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5263 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5264
5265 static {
5266 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5267 byId.put((int)field._thriftId, field);
5268 byName.put(field.getFieldName(), field);
5269 }
5270 }
5271
5272
5273
5274
5275 public static _Fields findByThriftId(int fieldId) {
5276 return byId.get(fieldId);
5277 }
5278
5279
5280
5281
5282
5283 public static _Fields findByThriftIdOrThrow(int fieldId) {
5284 _Fields fields = findByThriftId(fieldId);
5285 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5286 return fields;
5287 }
5288
5289
5290
5291
5292 public static _Fields findByName(String name) {
5293 return byName.get(name);
5294 }
5295
5296 private final short _thriftId;
5297 private final String _fieldName;
5298
5299 _Fields(short thriftId, String fieldName) {
5300 _thriftId = thriftId;
5301 _fieldName = fieldName;
5302 }
5303
5304 public short getThriftFieldId() {
5305 return _thriftId;
5306 }
5307
5308 public String getFieldName() {
5309 return _fieldName;
5310 }
5311 }
5312
5313
5314
5315 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5316 put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT,
5317 new FieldValueMetaData(TType.STRING)));
5318 }});
5319
5320 static {
5321 FieldMetaData.addStructMetaDataMap(majorCompact_args.class, metaDataMap);
5322 }
5323
5324 public majorCompact_args() {
5325 }
5326
5327 public majorCompact_args(
5328 byte[] tableNameOrRegionName)
5329 {
5330 this();
5331 this.tableNameOrRegionName = tableNameOrRegionName;
5332 }
5333
5334
5335
5336
5337 public majorCompact_args(majorCompact_args other) {
5338 if (other.isSetTableNameOrRegionName()) {
5339 this.tableNameOrRegionName = other.tableNameOrRegionName;
5340 }
5341 }
5342
5343 public majorCompact_args deepCopy() {
5344 return new majorCompact_args(this);
5345 }
5346
5347 @Deprecated
5348 public majorCompact_args clone() {
5349 return new majorCompact_args(this);
5350 }
5351
5352 public byte[] getTableNameOrRegionName() {
5353 return this.tableNameOrRegionName;
5354 }
5355
5356 public majorCompact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
5357 this.tableNameOrRegionName = tableNameOrRegionName;
5358 return this;
5359 }
5360
5361 public void unsetTableNameOrRegionName() {
5362 this.tableNameOrRegionName = null;
5363 }
5364
5365
5366 public boolean isSetTableNameOrRegionName() {
5367 return this.tableNameOrRegionName != null;
5368 }
5369
5370 public void setTableNameOrRegionNameIsSet(boolean value) {
5371 if (!value) {
5372 this.tableNameOrRegionName = null;
5373 }
5374 }
5375
5376 public void setFieldValue(_Fields field, Object value) {
5377 switch (field) {
5378 case TABLE_NAME_OR_REGION_NAME:
5379 if (value == null) {
5380 unsetTableNameOrRegionName();
5381 } else {
5382 setTableNameOrRegionName((byte[])value);
5383 }
5384 break;
5385
5386 }
5387 }
5388
5389 public void setFieldValue(int fieldID, Object value) {
5390 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5391 }
5392
5393 public Object getFieldValue(_Fields field) {
5394 switch (field) {
5395 case TABLE_NAME_OR_REGION_NAME:
5396 return getTableNameOrRegionName();
5397
5398 }
5399 throw new IllegalStateException();
5400 }
5401
5402 public Object getFieldValue(int fieldId) {
5403 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5404 }
5405
5406
5407 public boolean isSet(_Fields field) {
5408 switch (field) {
5409 case TABLE_NAME_OR_REGION_NAME:
5410 return isSetTableNameOrRegionName();
5411 }
5412 throw new IllegalStateException();
5413 }
5414
5415 public boolean isSet(int fieldID) {
5416 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5417 }
5418
5419 @Override
5420 public boolean equals(Object that) {
5421 if (that == null)
5422 return false;
5423 if (that instanceof majorCompact_args)
5424 return this.equals((majorCompact_args)that);
5425 return false;
5426 }
5427
5428 public boolean equals(majorCompact_args that) {
5429 if (that == null)
5430 return false;
5431
5432 boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
5433 boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
5434 if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
5435 if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
5436 return false;
5437 if (!java.util.Arrays.equals(this.tableNameOrRegionName, that.tableNameOrRegionName))
5438 return false;
5439 }
5440
5441 return true;
5442 }
5443
5444 @Override
5445 public int hashCode() {
5446 HashCodeBuilder builder = new HashCodeBuilder();
5447
5448 boolean present_tableNameOrRegionName = true && (isSetTableNameOrRegionName());
5449 builder.append(present_tableNameOrRegionName);
5450 if (present_tableNameOrRegionName)
5451 builder.append(tableNameOrRegionName);
5452
5453 return builder.toHashCode();
5454 }
5455
5456 public int compareTo(majorCompact_args other) {
5457 if (!getClass().equals(other.getClass())) {
5458 return getClass().getName().compareTo(other.getClass().getName());
5459 }
5460
5461 int lastComparison = 0;
5462 majorCompact_args typedOther = (majorCompact_args)other;
5463
5464 lastComparison = Boolean.valueOf(isSetTableNameOrRegionName()).compareTo(isSetTableNameOrRegionName());
5465 if (lastComparison != 0) {
5466 return lastComparison;
5467 }
5468 lastComparison = TBaseHelper.compareTo(tableNameOrRegionName, typedOther.tableNameOrRegionName);
5469 if (lastComparison != 0) {
5470 return lastComparison;
5471 }
5472 return 0;
5473 }
5474
5475 public void read(TProtocol iprot) throws TException {
5476 TField field;
5477 iprot.readStructBegin();
5478 while (true)
5479 {
5480 field = iprot.readFieldBegin();
5481 if (field.type == TType.STOP) {
5482 break;
5483 }
5484 _Fields fieldId = _Fields.findByThriftId(field.id);
5485 if (fieldId == null) {
5486 TProtocolUtil.skip(iprot, field.type);
5487 } else {
5488 switch (fieldId) {
5489 case TABLE_NAME_OR_REGION_NAME:
5490 if (field.type == TType.STRING) {
5491 this.tableNameOrRegionName = iprot.readBinary();
5492 } else {
5493 TProtocolUtil.skip(iprot, field.type);
5494 }
5495 break;
5496 }
5497 iprot.readFieldEnd();
5498 }
5499 }
5500 iprot.readStructEnd();
5501
5502
5503 validate();
5504 }
5505
5506 public void write(TProtocol oprot) throws TException {
5507 validate();
5508
5509 oprot.writeStructBegin(STRUCT_DESC);
5510 if (this.tableNameOrRegionName != null) {
5511 oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
5512 oprot.writeBinary(this.tableNameOrRegionName);
5513 oprot.writeFieldEnd();
5514 }
5515 oprot.writeFieldStop();
5516 oprot.writeStructEnd();
5517 }
5518
5519 @Override
5520 public String toString() {
5521 StringBuilder sb = new StringBuilder("majorCompact_args(");
5522 boolean first = true;
5523
5524 sb.append("tableNameOrRegionName:");
5525 if (this.tableNameOrRegionName == null) {
5526 sb.append("null");
5527 } else {
5528 sb.append(this.tableNameOrRegionName);
5529 }
5530 first = false;
5531 sb.append(")");
5532 return sb.toString();
5533 }
5534
5535 public void validate() throws TException {
5536
5537 }
5538
5539 }
5540
5541 public static class majorCompact_result implements TBase<majorCompact_result._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_result> {
5542 private static final TStruct STRUCT_DESC = new TStruct("majorCompact_result");
5543
5544 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
5545
5546 public IOError io;
5547
5548
5549 public enum _Fields implements TFieldIdEnum {
5550 IO((short)1, "io");
5551
5552 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5553 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5554
5555 static {
5556 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5557 byId.put((int)field._thriftId, field);
5558 byName.put(field.getFieldName(), field);
5559 }
5560 }
5561
5562
5563
5564
5565 public static _Fields findByThriftId(int fieldId) {
5566 return byId.get(fieldId);
5567 }
5568
5569
5570
5571
5572
5573 public static _Fields findByThriftIdOrThrow(int fieldId) {
5574 _Fields fields = findByThriftId(fieldId);
5575 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5576 return fields;
5577 }
5578
5579
5580
5581
5582 public static _Fields findByName(String name) {
5583 return byName.get(name);
5584 }
5585
5586 private final short _thriftId;
5587 private final String _fieldName;
5588
5589 _Fields(short thriftId, String fieldName) {
5590 _thriftId = thriftId;
5591 _fieldName = fieldName;
5592 }
5593
5594 public short getThriftFieldId() {
5595 return _thriftId;
5596 }
5597
5598 public String getFieldName() {
5599 return _fieldName;
5600 }
5601 }
5602
5603
5604
5605 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5606 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
5607 new FieldValueMetaData(TType.STRUCT)));
5608 }});
5609
5610 static {
5611 FieldMetaData.addStructMetaDataMap(majorCompact_result.class, metaDataMap);
5612 }
5613
5614 public majorCompact_result() {
5615 }
5616
5617 public majorCompact_result(
5618 IOError io)
5619 {
5620 this();
5621 this.io = io;
5622 }
5623
5624
5625
5626
5627 public majorCompact_result(majorCompact_result other) {
5628 if (other.isSetIo()) {
5629 this.io = new IOError(other.io);
5630 }
5631 }
5632
5633 public majorCompact_result deepCopy() {
5634 return new majorCompact_result(this);
5635 }
5636
5637 @Deprecated
5638 public majorCompact_result clone() {
5639 return new majorCompact_result(this);
5640 }
5641
5642 public IOError getIo() {
5643 return this.io;
5644 }
5645
5646 public majorCompact_result setIo(IOError io) {
5647 this.io = io;
5648 return this;
5649 }
5650
5651 public void unsetIo() {
5652 this.io = null;
5653 }
5654
5655
5656 public boolean isSetIo() {
5657 return this.io != null;
5658 }
5659
5660 public void setIoIsSet(boolean value) {
5661 if (!value) {
5662 this.io = null;
5663 }
5664 }
5665
5666 public void setFieldValue(_Fields field, Object value) {
5667 switch (field) {
5668 case IO:
5669 if (value == null) {
5670 unsetIo();
5671 } else {
5672 setIo((IOError)value);
5673 }
5674 break;
5675
5676 }
5677 }
5678
5679 public void setFieldValue(int fieldID, Object value) {
5680 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5681 }
5682
5683 public Object getFieldValue(_Fields field) {
5684 switch (field) {
5685 case IO:
5686 return getIo();
5687
5688 }
5689 throw new IllegalStateException();
5690 }
5691
5692 public Object getFieldValue(int fieldId) {
5693 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5694 }
5695
5696
5697 public boolean isSet(_Fields field) {
5698 switch (field) {
5699 case IO:
5700 return isSetIo();
5701 }
5702 throw new IllegalStateException();
5703 }
5704
5705 public boolean isSet(int fieldID) {
5706 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5707 }
5708
5709 @Override
5710 public boolean equals(Object that) {
5711 if (that == null)
5712 return false;
5713 if (that instanceof majorCompact_result)
5714 return this.equals((majorCompact_result)that);
5715 return false;
5716 }
5717
5718 public boolean equals(majorCompact_result that) {
5719 if (that == null)
5720 return false;
5721
5722 boolean this_present_io = true && this.isSetIo();
5723 boolean that_present_io = true && that.isSetIo();
5724 if (this_present_io || that_present_io) {
5725 if (!(this_present_io && that_present_io))
5726 return false;
5727 if (!this.io.equals(that.io))
5728 return false;
5729 }
5730
5731 return true;
5732 }
5733
5734 @Override
5735 public int hashCode() {
5736 HashCodeBuilder builder = new HashCodeBuilder();
5737
5738 boolean present_io = true && (isSetIo());
5739 builder.append(present_io);
5740 if (present_io)
5741 builder.append(io);
5742
5743 return builder.toHashCode();
5744 }
5745
5746 public int compareTo(majorCompact_result other) {
5747 if (!getClass().equals(other.getClass())) {
5748 return getClass().getName().compareTo(other.getClass().getName());
5749 }
5750
5751 int lastComparison = 0;
5752 majorCompact_result typedOther = (majorCompact_result)other;
5753
5754 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
5755 if (lastComparison != 0) {
5756 return lastComparison;
5757 }
5758 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
5759 if (lastComparison != 0) {
5760 return lastComparison;
5761 }
5762 return 0;
5763 }
5764
5765 public void read(TProtocol iprot) throws TException {
5766 TField field;
5767 iprot.readStructBegin();
5768 while (true)
5769 {
5770 field = iprot.readFieldBegin();
5771 if (field.type == TType.STOP) {
5772 break;
5773 }
5774 _Fields fieldId = _Fields.findByThriftId(field.id);
5775 if (fieldId == null) {
5776 TProtocolUtil.skip(iprot, field.type);
5777 } else {
5778 switch (fieldId) {
5779 case IO:
5780 if (field.type == TType.STRUCT) {
5781 this.io = new IOError();
5782 this.io.read(iprot);
5783 } else {
5784 TProtocolUtil.skip(iprot, field.type);
5785 }
5786 break;
5787 }
5788 iprot.readFieldEnd();
5789 }
5790 }
5791 iprot.readStructEnd();
5792
5793
5794 validate();
5795 }
5796
5797 public void write(TProtocol oprot) throws TException {
5798 oprot.writeStructBegin(STRUCT_DESC);
5799
5800 if (this.isSetIo()) {
5801 oprot.writeFieldBegin(IO_FIELD_DESC);
5802 this.io.write(oprot);
5803 oprot.writeFieldEnd();
5804 }
5805 oprot.writeFieldStop();
5806 oprot.writeStructEnd();
5807 }
5808
5809 @Override
5810 public String toString() {
5811 StringBuilder sb = new StringBuilder("majorCompact_result(");
5812 boolean first = true;
5813
5814 sb.append("io:");
5815 if (this.io == null) {
5816 sb.append("null");
5817 } else {
5818 sb.append(this.io);
5819 }
5820 first = false;
5821 sb.append(")");
5822 return sb.toString();
5823 }
5824
5825 public void validate() throws TException {
5826
5827 }
5828
5829 }
5830
5831 public static class getTableNames_args implements TBase<getTableNames_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_args> {
5832 private static final TStruct STRUCT_DESC = new TStruct("getTableNames_args");
5833
5834
5835
5836
5837 public enum _Fields implements TFieldIdEnum {
5838 ;
5839
5840 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5841 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5842
5843 static {
5844 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5845 byId.put((int)field._thriftId, field);
5846 byName.put(field.getFieldName(), field);
5847 }
5848 }
5849
5850
5851
5852
5853 public static _Fields findByThriftId(int fieldId) {
5854 return byId.get(fieldId);
5855 }
5856
5857
5858
5859
5860
5861 public static _Fields findByThriftIdOrThrow(int fieldId) {
5862 _Fields fields = findByThriftId(fieldId);
5863 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5864 return fields;
5865 }
5866
5867
5868
5869
5870 public static _Fields findByName(String name) {
5871 return byName.get(name);
5872 }
5873
5874 private final short _thriftId;
5875 private final String _fieldName;
5876
5877 _Fields(short thriftId, String fieldName) {
5878 _thriftId = thriftId;
5879 _fieldName = fieldName;
5880 }
5881
5882 public short getThriftFieldId() {
5883 return _thriftId;
5884 }
5885
5886 public String getFieldName() {
5887 return _fieldName;
5888 }
5889 }
5890 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5891 }});
5892
5893 static {
5894 FieldMetaData.addStructMetaDataMap(getTableNames_args.class, metaDataMap);
5895 }
5896
5897 public getTableNames_args() {
5898 }
5899
5900
5901
5902
5903 public getTableNames_args(getTableNames_args other) {
5904 }
5905
5906 public getTableNames_args deepCopy() {
5907 return new getTableNames_args(this);
5908 }
5909
5910 @Deprecated
5911 public getTableNames_args clone() {
5912 return new getTableNames_args(this);
5913 }
5914
5915 public void setFieldValue(_Fields field, Object value) {
5916 switch (field) {
5917 }
5918 }
5919
5920 public void setFieldValue(int fieldID, Object value) {
5921 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5922 }
5923
5924 public Object getFieldValue(_Fields field) {
5925 switch (field) {
5926 }
5927 throw new IllegalStateException();
5928 }
5929
5930 public Object getFieldValue(int fieldId) {
5931 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5932 }
5933
5934
5935 public boolean isSet(_Fields field) {
5936 switch (field) {
5937 }
5938 throw new IllegalStateException();
5939 }
5940
5941 public boolean isSet(int fieldID) {
5942 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5943 }
5944
5945 @Override
5946 public boolean equals(Object that) {
5947 if (that == null)
5948 return false;
5949 if (that instanceof getTableNames_args)
5950 return this.equals((getTableNames_args)that);
5951 return false;
5952 }
5953
5954 public boolean equals(getTableNames_args that) {
5955 if (that == null)
5956 return false;
5957
5958 return true;
5959 }
5960
5961 @Override
5962 public int hashCode() {
5963 HashCodeBuilder builder = new HashCodeBuilder();
5964
5965 return builder.toHashCode();
5966 }
5967
5968 public int compareTo(getTableNames_args other) {
5969 if (!getClass().equals(other.getClass())) {
5970 return getClass().getName().compareTo(other.getClass().getName());
5971 }
5972
5973 int lastComparison = 0;
5974 getTableNames_args typedOther = (getTableNames_args)other;
5975
5976 return 0;
5977 }
5978
5979 public void read(TProtocol iprot) throws TException {
5980 TField field;
5981 iprot.readStructBegin();
5982 while (true)
5983 {
5984 field = iprot.readFieldBegin();
5985 if (field.type == TType.STOP) {
5986 break;
5987 }
5988 _Fields fieldId = _Fields.findByThriftId(field.id);
5989 if (fieldId == null) {
5990 TProtocolUtil.skip(iprot, field.type);
5991 } else {
5992 switch (fieldId) {
5993 }
5994 iprot.readFieldEnd();
5995 }
5996 }
5997 iprot.readStructEnd();
5998
5999
6000 validate();
6001 }
6002
6003 public void write(TProtocol oprot) throws TException {
6004 validate();
6005
6006 oprot.writeStructBegin(STRUCT_DESC);
6007 oprot.writeFieldStop();
6008 oprot.writeStructEnd();
6009 }
6010
6011 @Override
6012 public String toString() {
6013 StringBuilder sb = new StringBuilder("getTableNames_args(");
6014 boolean first = true;
6015
6016 sb.append(")");
6017 return sb.toString();
6018 }
6019
6020 public void validate() throws TException {
6021
6022 }
6023
6024 }
6025
6026 public static class getTableNames_result implements TBase<getTableNames_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_result> {
6027 private static final TStruct STRUCT_DESC = new TStruct("getTableNames_result");
6028
6029 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
6030 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
6031
6032 public List<byte[]> success;
6033 public IOError io;
6034
6035
6036 public enum _Fields implements TFieldIdEnum {
6037 SUCCESS((short)0, "success"),
6038 IO((short)1, "io");
6039
6040 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6041 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6042
6043 static {
6044 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6045 byId.put((int)field._thriftId, field);
6046 byName.put(field.getFieldName(), field);
6047 }
6048 }
6049
6050
6051
6052
6053 public static _Fields findByThriftId(int fieldId) {
6054 return byId.get(fieldId);
6055 }
6056
6057
6058
6059
6060
6061 public static _Fields findByThriftIdOrThrow(int fieldId) {
6062 _Fields fields = findByThriftId(fieldId);
6063 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6064 return fields;
6065 }
6066
6067
6068
6069
6070 public static _Fields findByName(String name) {
6071 return byName.get(name);
6072 }
6073
6074 private final short _thriftId;
6075 private final String _fieldName;
6076
6077 _Fields(short thriftId, String fieldName) {
6078 _thriftId = thriftId;
6079 _fieldName = fieldName;
6080 }
6081
6082 public short getThriftFieldId() {
6083 return _thriftId;
6084 }
6085
6086 public String getFieldName() {
6087 return _fieldName;
6088 }
6089 }
6090
6091
6092
6093 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6094 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
6095 new ListMetaData(TType.LIST,
6096 new FieldValueMetaData(TType.STRING))));
6097 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
6098 new FieldValueMetaData(TType.STRUCT)));
6099 }});
6100
6101 static {
6102 FieldMetaData.addStructMetaDataMap(getTableNames_result.class, metaDataMap);
6103 }
6104
6105 public getTableNames_result() {
6106 }
6107
6108 public getTableNames_result(
6109 List<byte[]> success,
6110 IOError io)
6111 {
6112 this();
6113 this.success = success;
6114 this.io = io;
6115 }
6116
6117
6118
6119
6120 public getTableNames_result(getTableNames_result other) {
6121 if (other.isSetSuccess()) {
6122 List<byte[]> __this__success = new ArrayList<byte[]>();
6123 for (byte[] other_element : other.success) {
6124 __this__success.add(other_element);
6125 }
6126 this.success = __this__success;
6127 }
6128 if (other.isSetIo()) {
6129 this.io = new IOError(other.io);
6130 }
6131 }
6132
6133 public getTableNames_result deepCopy() {
6134 return new getTableNames_result(this);
6135 }
6136
6137 @Deprecated
6138 public getTableNames_result clone() {
6139 return new getTableNames_result(this);
6140 }
6141
6142 public int getSuccessSize() {
6143 return (this.success == null) ? 0 : this.success.size();
6144 }
6145
6146 public java.util.Iterator<byte[]> getSuccessIterator() {
6147 return (this.success == null) ? null : this.success.iterator();
6148 }
6149
6150 public void addToSuccess(byte[] elem) {
6151 if (this.success == null) {
6152 this.success = new ArrayList<byte[]>();
6153 }
6154 this.success.add(elem);
6155 }
6156
6157 public List<byte[]> getSuccess() {
6158 return this.success;
6159 }
6160
6161 public getTableNames_result setSuccess(List<byte[]> success) {
6162 this.success = success;
6163 return this;
6164 }
6165
6166 public void unsetSuccess() {
6167 this.success = null;
6168 }
6169
6170
6171 public boolean isSetSuccess() {
6172 return this.success != null;
6173 }
6174
6175 public void setSuccessIsSet(boolean value) {
6176 if (!value) {
6177 this.success = null;
6178 }
6179 }
6180
6181 public IOError getIo() {
6182 return this.io;
6183 }
6184
6185 public getTableNames_result setIo(IOError io) {
6186 this.io = io;
6187 return this;
6188 }
6189
6190 public void unsetIo() {
6191 this.io = null;
6192 }
6193
6194
6195 public boolean isSetIo() {
6196 return this.io != null;
6197 }
6198
6199 public void setIoIsSet(boolean value) {
6200 if (!value) {
6201 this.io = null;
6202 }
6203 }
6204
6205 public void setFieldValue(_Fields field, Object value) {
6206 switch (field) {
6207 case SUCCESS:
6208 if (value == null) {
6209 unsetSuccess();
6210 } else {
6211 setSuccess((List<byte[]>)value);
6212 }
6213 break;
6214
6215 case IO:
6216 if (value == null) {
6217 unsetIo();
6218 } else {
6219 setIo((IOError)value);
6220 }
6221 break;
6222
6223 }
6224 }
6225
6226 public void setFieldValue(int fieldID, Object value) {
6227 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6228 }
6229
6230 public Object getFieldValue(_Fields field) {
6231 switch (field) {
6232 case SUCCESS:
6233 return getSuccess();
6234
6235 case IO:
6236 return getIo();
6237
6238 }
6239 throw new IllegalStateException();
6240 }
6241
6242 public Object getFieldValue(int fieldId) {
6243 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6244 }
6245
6246
6247 public boolean isSet(_Fields field) {
6248 switch (field) {
6249 case SUCCESS:
6250 return isSetSuccess();
6251 case IO:
6252 return isSetIo();
6253 }
6254 throw new IllegalStateException();
6255 }
6256
6257 public boolean isSet(int fieldID) {
6258 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6259 }
6260
6261 @Override
6262 public boolean equals(Object that) {
6263 if (that == null)
6264 return false;
6265 if (that instanceof getTableNames_result)
6266 return this.equals((getTableNames_result)that);
6267 return false;
6268 }
6269
6270 public boolean equals(getTableNames_result that) {
6271 if (that == null)
6272 return false;
6273
6274 boolean this_present_success = true && this.isSetSuccess();
6275 boolean that_present_success = true && that.isSetSuccess();
6276 if (this_present_success || that_present_success) {
6277 if (!(this_present_success && that_present_success))
6278 return false;
6279 if (!this.success.equals(that.success))
6280 return false;
6281 }
6282
6283 boolean this_present_io = true && this.isSetIo();
6284 boolean that_present_io = true && that.isSetIo();
6285 if (this_present_io || that_present_io) {
6286 if (!(this_present_io && that_present_io))
6287 return false;
6288 if (!this.io.equals(that.io))
6289 return false;
6290 }
6291
6292 return true;
6293 }
6294
6295 @Override
6296 public int hashCode() {
6297 HashCodeBuilder builder = new HashCodeBuilder();
6298
6299 boolean present_success = true && (isSetSuccess());
6300 builder.append(present_success);
6301 if (present_success)
6302 builder.append(success);
6303
6304 boolean present_io = true && (isSetIo());
6305 builder.append(present_io);
6306 if (present_io)
6307 builder.append(io);
6308
6309 return builder.toHashCode();
6310 }
6311
6312 public int compareTo(getTableNames_result other) {
6313 if (!getClass().equals(other.getClass())) {
6314 return getClass().getName().compareTo(other.getClass().getName());
6315 }
6316
6317 int lastComparison = 0;
6318 getTableNames_result typedOther = (getTableNames_result)other;
6319
6320 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
6321 if (lastComparison != 0) {
6322 return lastComparison;
6323 }
6324 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
6325 if (lastComparison != 0) {
6326 return lastComparison;
6327 }
6328 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
6329 if (lastComparison != 0) {
6330 return lastComparison;
6331 }
6332 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
6333 if (lastComparison != 0) {
6334 return lastComparison;
6335 }
6336 return 0;
6337 }
6338
6339 public void read(TProtocol iprot) throws TException {
6340 TField field;
6341 iprot.readStructBegin();
6342 while (true)
6343 {
6344 field = iprot.readFieldBegin();
6345 if (field.type == TType.STOP) {
6346 break;
6347 }
6348 _Fields fieldId = _Fields.findByThriftId(field.id);
6349 if (fieldId == null) {
6350 TProtocolUtil.skip(iprot, field.type);
6351 } else {
6352 switch (fieldId) {
6353 case SUCCESS:
6354 if (field.type == TType.LIST) {
6355 {
6356 TList _list9 = iprot.readListBegin();
6357 this.success = new ArrayList<byte[]>(_list9.size);
6358 for (int _i10 = 0; _i10 < _list9.size; ++_i10)
6359 {
6360 byte[] _elem11;
6361 _elem11 = iprot.readBinary();
6362 this.success.add(_elem11);
6363 }
6364 iprot.readListEnd();
6365 }
6366 } else {
6367 TProtocolUtil.skip(iprot, field.type);
6368 }
6369 break;
6370 case IO:
6371 if (field.type == TType.STRUCT) {
6372 this.io = new IOError();
6373 this.io.read(iprot);
6374 } else {
6375 TProtocolUtil.skip(iprot, field.type);
6376 }
6377 break;
6378 }
6379 iprot.readFieldEnd();
6380 }
6381 }
6382 iprot.readStructEnd();
6383
6384
6385 validate();
6386 }
6387
6388 public void write(TProtocol oprot) throws TException {
6389 oprot.writeStructBegin(STRUCT_DESC);
6390
6391 if (this.isSetSuccess()) {
6392 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6393 {
6394 oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
6395 for (byte[] _iter12 : this.success)
6396 {
6397 oprot.writeBinary(_iter12);
6398 }
6399 oprot.writeListEnd();
6400 }
6401 oprot.writeFieldEnd();
6402 } else if (this.isSetIo()) {
6403 oprot.writeFieldBegin(IO_FIELD_DESC);
6404 this.io.write(oprot);
6405 oprot.writeFieldEnd();
6406 }
6407 oprot.writeFieldStop();
6408 oprot.writeStructEnd();
6409 }
6410
6411 @Override
6412 public String toString() {
6413 StringBuilder sb = new StringBuilder("getTableNames_result(");
6414 boolean first = true;
6415
6416 sb.append("success:");
6417 if (this.success == null) {
6418 sb.append("null");
6419 } else {
6420 sb.append(this.success);
6421 }
6422 first = false;
6423 if (!first) sb.append(", ");
6424 sb.append("io:");
6425 if (this.io == null) {
6426 sb.append("null");
6427 } else {
6428 sb.append(this.io);
6429 }
6430 first = false;
6431 sb.append(")");
6432 return sb.toString();
6433 }
6434
6435 public void validate() throws TException {
6436
6437 }
6438
6439 }
6440
6441 public static class getColumnDescriptors_args implements TBase<getColumnDescriptors_args._Fields>, java.io.Serializable, Cloneable, Comparable<getColumnDescriptors_args> {
6442 private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_args");
6443
6444 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
6445
6446
6447
6448
6449 public byte[] tableName;
6450
6451
6452 public enum _Fields implements TFieldIdEnum {
6453
6454
6455
6456 TABLE_NAME((short)1, "tableName");
6457
6458 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6459 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6460
6461 static {
6462 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6463 byId.put((int)field._thriftId, field);
6464 byName.put(field.getFieldName(), field);
6465 }
6466 }
6467
6468
6469
6470
6471 public static _Fields findByThriftId(int fieldId) {
6472 return byId.get(fieldId);
6473 }
6474
6475
6476
6477
6478
6479 public static _Fields findByThriftIdOrThrow(int fieldId) {
6480 _Fields fields = findByThriftId(fieldId);
6481 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6482 return fields;
6483 }
6484
6485
6486
6487
6488 public static _Fields findByName(String name) {
6489 return byName.get(name);
6490 }
6491
6492 private final short _thriftId;
6493 private final String _fieldName;
6494
6495 _Fields(short thriftId, String fieldName) {
6496 _thriftId = thriftId;
6497 _fieldName = fieldName;
6498 }
6499
6500 public short getThriftFieldId() {
6501 return _thriftId;
6502 }
6503
6504 public String getFieldName() {
6505 return _fieldName;
6506 }
6507 }
6508
6509
6510
6511 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6512 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
6513 new FieldValueMetaData(TType.STRING)));
6514 }});
6515
6516 static {
6517 FieldMetaData.addStructMetaDataMap(getColumnDescriptors_args.class, metaDataMap);
6518 }
6519
6520 public getColumnDescriptors_args() {
6521 }
6522
6523 public getColumnDescriptors_args(
6524 byte[] tableName)
6525 {
6526 this();
6527 this.tableName = tableName;
6528 }
6529
6530
6531
6532
6533 public getColumnDescriptors_args(getColumnDescriptors_args other) {
6534 if (other.isSetTableName()) {
6535 this.tableName = other.tableName;
6536 }
6537 }
6538
6539 public getColumnDescriptors_args deepCopy() {
6540 return new getColumnDescriptors_args(this);
6541 }
6542
6543 @Deprecated
6544 public getColumnDescriptors_args clone() {
6545 return new getColumnDescriptors_args(this);
6546 }
6547
6548
6549
6550
6551 public byte[] getTableName() {
6552 return this.tableName;
6553 }
6554
6555
6556
6557
6558 public getColumnDescriptors_args setTableName(byte[] tableName) {
6559 this.tableName = tableName;
6560 return this;
6561 }
6562
6563 public void unsetTableName() {
6564 this.tableName = null;
6565 }
6566
6567
6568 public boolean isSetTableName() {
6569 return this.tableName != null;
6570 }
6571
6572 public void setTableNameIsSet(boolean value) {
6573 if (!value) {
6574 this.tableName = null;
6575 }
6576 }
6577
6578 public void setFieldValue(_Fields field, Object value) {
6579 switch (field) {
6580 case TABLE_NAME:
6581 if (value == null) {
6582 unsetTableName();
6583 } else {
6584 setTableName((byte[])value);
6585 }
6586 break;
6587
6588 }
6589 }
6590
6591 public void setFieldValue(int fieldID, Object value) {
6592 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6593 }
6594
6595 public Object getFieldValue(_Fields field) {
6596 switch (field) {
6597 case TABLE_NAME:
6598 return getTableName();
6599
6600 }
6601 throw new IllegalStateException();
6602 }
6603
6604 public Object getFieldValue(int fieldId) {
6605 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6606 }
6607
6608
6609 public boolean isSet(_Fields field) {
6610 switch (field) {
6611 case TABLE_NAME:
6612 return isSetTableName();
6613 }
6614 throw new IllegalStateException();
6615 }
6616
6617 public boolean isSet(int fieldID) {
6618 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6619 }
6620
6621 @Override
6622 public boolean equals(Object that) {
6623 if (that == null)
6624 return false;
6625 if (that instanceof getColumnDescriptors_args)
6626 return this.equals((getColumnDescriptors_args)that);
6627 return false;
6628 }
6629
6630 public boolean equals(getColumnDescriptors_args that) {
6631 if (that == null)
6632 return false;
6633
6634 boolean this_present_tableName = true && this.isSetTableName();
6635 boolean that_present_tableName = true && that.isSetTableName();
6636 if (this_present_tableName || that_present_tableName) {
6637 if (!(this_present_tableName && that_present_tableName))
6638 return false;
6639 if (!java.util.Arrays.equals(this.tableName, that.tableName))
6640 return false;
6641 }
6642
6643 return true;
6644 }
6645
6646 @Override
6647 public int hashCode() {
6648 HashCodeBuilder builder = new HashCodeBuilder();
6649
6650 boolean present_tableName = true && (isSetTableName());
6651 builder.append(present_tableName);
6652 if (present_tableName)
6653 builder.append(tableName);
6654
6655 return builder.toHashCode();
6656 }
6657
6658 public int compareTo(getColumnDescriptors_args other) {
6659 if (!getClass().equals(other.getClass())) {
6660 return getClass().getName().compareTo(other.getClass().getName());
6661 }
6662
6663 int lastComparison = 0;
6664 getColumnDescriptors_args typedOther = (getColumnDescriptors_args)other;
6665
6666 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
6667 if (lastComparison != 0) {
6668 return lastComparison;
6669 }
6670 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
6671 if (lastComparison != 0) {
6672 return lastComparison;
6673 }
6674 return 0;
6675 }
6676
6677 public void read(TProtocol iprot) throws TException {
6678 TField field;
6679 iprot.readStructBegin();
6680 while (true)
6681 {
6682 field = iprot.readFieldBegin();
6683 if (field.type == TType.STOP) {
6684 break;
6685 }
6686 _Fields fieldId = _Fields.findByThriftId(field.id);
6687 if (fieldId == null) {
6688 TProtocolUtil.skip(iprot, field.type);
6689 } else {
6690 switch (fieldId) {
6691 case TABLE_NAME:
6692 if (field.type == TType.STRING) {
6693 this.tableName = iprot.readBinary();
6694 } else {
6695 TProtocolUtil.skip(iprot, field.type);
6696 }
6697 break;
6698 }
6699 iprot.readFieldEnd();
6700 }
6701 }
6702 iprot.readStructEnd();
6703
6704
6705 validate();
6706 }
6707
6708 public void write(TProtocol oprot) throws TException {
6709 validate();
6710
6711 oprot.writeStructBegin(STRUCT_DESC);
6712 if (this.tableName != null) {
6713 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
6714 oprot.writeBinary(this.tableName);
6715 oprot.writeFieldEnd();
6716 }
6717 oprot.writeFieldStop();
6718 oprot.writeStructEnd();
6719 }
6720
6721 @Override
6722 public String toString() {
6723 StringBuilder sb = new StringBuilder("getColumnDescriptors_args(");
6724 boolean first = true;
6725
6726 sb.append("tableName:");
6727 if (this.tableName == null) {
6728 sb.append("null");
6729 } else {
6730 sb.append(this.tableName);
6731 }
6732 first = false;
6733 sb.append(")");
6734 return sb.toString();
6735 }
6736
6737 public void validate() throws TException {
6738
6739 }
6740
6741 }
6742
6743 public static class getColumnDescriptors_result implements TBase<getColumnDescriptors_result._Fields>, java.io.Serializable, Cloneable {
6744 private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_result");
6745
6746 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.MAP, (short)0);
6747 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
6748
6749 public Map<byte[],ColumnDescriptor> success;
6750 public IOError io;
6751
6752
6753 public enum _Fields implements TFieldIdEnum {
6754 SUCCESS((short)0, "success"),
6755 IO((short)1, "io");
6756
6757 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6758 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6759
6760 static {
6761 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6762 byId.put((int)field._thriftId, field);
6763 byName.put(field.getFieldName(), field);
6764 }
6765 }
6766
6767
6768
6769
6770 public static _Fields findByThriftId(int fieldId) {
6771 return byId.get(fieldId);
6772 }
6773
6774
6775
6776
6777
6778 public static _Fields findByThriftIdOrThrow(int fieldId) {
6779 _Fields fields = findByThriftId(fieldId);
6780 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6781 return fields;
6782 }
6783
6784
6785
6786
6787 public static _Fields findByName(String name) {
6788 return byName.get(name);
6789 }
6790
6791 private final short _thriftId;
6792 private final String _fieldName;
6793
6794 _Fields(short thriftId, String fieldName) {
6795 _thriftId = thriftId;
6796 _fieldName = fieldName;
6797 }
6798
6799 public short getThriftFieldId() {
6800 return _thriftId;
6801 }
6802
6803 public String getFieldName() {
6804 return _fieldName;
6805 }
6806 }
6807
6808
6809
6810 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6811 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
6812 new MapMetaData(TType.MAP,
6813 new FieldValueMetaData(TType.STRING),
6814 new StructMetaData(TType.STRUCT, ColumnDescriptor.class))));
6815 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
6816 new FieldValueMetaData(TType.STRUCT)));
6817 }});
6818
6819 static {
6820 FieldMetaData.addStructMetaDataMap(getColumnDescriptors_result.class, metaDataMap);
6821 }
6822
6823 public getColumnDescriptors_result() {
6824 }
6825
6826 public getColumnDescriptors_result(
6827 Map<byte[],ColumnDescriptor> success,
6828 IOError io)
6829 {
6830 this();
6831 this.success = success;
6832 this.io = io;
6833 }
6834
6835
6836
6837
6838 public getColumnDescriptors_result(getColumnDescriptors_result other) {
6839 if (other.isSetSuccess()) {
6840 Map<byte[],ColumnDescriptor> __this__success = new HashMap<byte[],ColumnDescriptor>();
6841 for (Map.Entry<byte[], ColumnDescriptor> other_element : other.success.entrySet()) {
6842
6843 byte[] other_element_key = other_element.getKey();
6844 ColumnDescriptor other_element_value = other_element.getValue();
6845
6846 byte[] __this__success_copy_key = other_element_key;
6847
6848 ColumnDescriptor __this__success_copy_value = new ColumnDescriptor(other_element_value);
6849
6850 __this__success.put(__this__success_copy_key, __this__success_copy_value);
6851 }
6852 this.success = __this__success;
6853 }
6854 if (other.isSetIo()) {
6855 this.io = new IOError(other.io);
6856 }
6857 }
6858
6859 public getColumnDescriptors_result deepCopy() {
6860 return new getColumnDescriptors_result(this);
6861 }
6862
6863 @Deprecated
6864 public getColumnDescriptors_result clone() {
6865 return new getColumnDescriptors_result(this);
6866 }
6867
6868 public int getSuccessSize() {
6869 return (this.success == null) ? 0 : this.success.size();
6870 }
6871
6872 public void putToSuccess(byte[] key, ColumnDescriptor val) {
6873 if (this.success == null) {
6874 this.success = new HashMap<byte[],ColumnDescriptor>();
6875 }
6876 this.success.put(key, val);
6877 }
6878
6879 public Map<byte[],ColumnDescriptor> getSuccess() {
6880 return this.success;
6881 }
6882
6883 public getColumnDescriptors_result setSuccess(Map<byte[],ColumnDescriptor> success) {
6884 this.success = success;
6885 return this;
6886 }
6887
6888 public void unsetSuccess() {
6889 this.success = null;
6890 }
6891
6892
6893 public boolean isSetSuccess() {
6894 return this.success != null;
6895 }
6896
6897 public void setSuccessIsSet(boolean value) {
6898 if (!value) {
6899 this.success = null;
6900 }
6901 }
6902
6903 public IOError getIo() {
6904 return this.io;
6905 }
6906
6907 public getColumnDescriptors_result setIo(IOError io) {
6908 this.io = io;
6909 return this;
6910 }
6911
6912 public void unsetIo() {
6913 this.io = null;
6914 }
6915
6916
6917 public boolean isSetIo() {
6918 return this.io != null;
6919 }
6920
6921 public void setIoIsSet(boolean value) {
6922 if (!value) {
6923 this.io = null;
6924 }
6925 }
6926
6927 public void setFieldValue(_Fields field, Object value) {
6928 switch (field) {
6929 case SUCCESS:
6930 if (value == null) {
6931 unsetSuccess();
6932 } else {
6933 setSuccess((Map<byte[],ColumnDescriptor>)value);
6934 }
6935 break;
6936
6937 case IO:
6938 if (value == null) {
6939 unsetIo();
6940 } else {
6941 setIo((IOError)value);
6942 }
6943 break;
6944
6945 }
6946 }
6947
6948 public void setFieldValue(int fieldID, Object value) {
6949 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6950 }
6951
6952 public Object getFieldValue(_Fields field) {
6953 switch (field) {
6954 case SUCCESS:
6955 return getSuccess();
6956
6957 case IO:
6958 return getIo();
6959
6960 }
6961 throw new IllegalStateException();
6962 }
6963
6964 public Object getFieldValue(int fieldId) {
6965 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6966 }
6967
6968
6969 public boolean isSet(_Fields field) {
6970 switch (field) {
6971 case SUCCESS:
6972 return isSetSuccess();
6973 case IO:
6974 return isSetIo();
6975 }
6976 throw new IllegalStateException();
6977 }
6978
6979 public boolean isSet(int fieldID) {
6980 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6981 }
6982
6983 @Override
6984 public boolean equals(Object that) {
6985 if (that == null)
6986 return false;
6987 if (that instanceof getColumnDescriptors_result)
6988 return this.equals((getColumnDescriptors_result)that);
6989 return false;
6990 }
6991
6992 public boolean equals(getColumnDescriptors_result that) {
6993 if (that == null)
6994 return false;
6995
6996 boolean this_present_success = true && this.isSetSuccess();
6997 boolean that_present_success = true && that.isSetSuccess();
6998 if (this_present_success || that_present_success) {
6999 if (!(this_present_success && that_present_success))
7000 return false;
7001 if (!this.success.equals(that.success))
7002 return false;
7003 }
7004
7005 boolean this_present_io = true && this.isSetIo();
7006 boolean that_present_io = true && that.isSetIo();
7007 if (this_present_io || that_present_io) {
7008 if (!(this_present_io && that_present_io))
7009 return false;
7010 if (!this.io.equals(that.io))
7011 return false;
7012 }
7013
7014 return true;
7015 }
7016
7017 @Override
7018 public int hashCode() {
7019 HashCodeBuilder builder = new HashCodeBuilder();
7020
7021 boolean present_success = true && (isSetSuccess());
7022 builder.append(present_success);
7023 if (present_success)
7024 builder.append(success);
7025
7026 boolean present_io = true && (isSetIo());
7027 builder.append(present_io);
7028 if (present_io)
7029 builder.append(io);
7030
7031 return builder.toHashCode();
7032 }
7033
7034 public void read(TProtocol iprot) throws TException {
7035 TField field;
7036 iprot.readStructBegin();
7037 while (true)
7038 {
7039 field = iprot.readFieldBegin();
7040 if (field.type == TType.STOP) {
7041 break;
7042 }
7043 _Fields fieldId = _Fields.findByThriftId(field.id);
7044 if (fieldId == null) {
7045 TProtocolUtil.skip(iprot, field.type);
7046 } else {
7047 switch (fieldId) {
7048 case SUCCESS:
7049 if (field.type == TType.MAP) {
7050 {
7051 TMap _map13 = iprot.readMapBegin();
7052 this.success = new HashMap<byte[],ColumnDescriptor>(2*_map13.size);
7053 for (int _i14 = 0; _i14 < _map13.size; ++_i14)
7054 {
7055 byte[] _key15;
7056 ColumnDescriptor _val16;
7057 _key15 = iprot.readBinary();
7058 _val16 = new ColumnDescriptor();
7059 _val16.read(iprot);
7060 this.success.put(_key15, _val16);
7061 }
7062 iprot.readMapEnd();
7063 }
7064 } else {
7065 TProtocolUtil.skip(iprot, field.type);
7066 }
7067 break;
7068 case IO:
7069 if (field.type == TType.STRUCT) {
7070 this.io = new IOError();
7071 this.io.read(iprot);
7072 } else {
7073 TProtocolUtil.skip(iprot, field.type);
7074 }
7075 break;
7076 }
7077 iprot.readFieldEnd();
7078 }
7079 }
7080 iprot.readStructEnd();
7081
7082
7083 validate();
7084 }
7085
7086 public void write(TProtocol oprot) throws TException {
7087 oprot.writeStructBegin(STRUCT_DESC);
7088
7089 if (this.isSetSuccess()) {
7090 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
7091 {
7092 oprot.writeMapBegin(new TMap(TType.STRING, TType.STRUCT, this.success.size()));
7093 for (Map.Entry<byte[], ColumnDescriptor> _iter17 : this.success.entrySet())
7094 {
7095 oprot.writeBinary(_iter17.getKey());
7096 _iter17.getValue().write(oprot);
7097 }
7098 oprot.writeMapEnd();
7099 }
7100 oprot.writeFieldEnd();
7101 } else if (this.isSetIo()) {
7102 oprot.writeFieldBegin(IO_FIELD_DESC);
7103 this.io.write(oprot);
7104 oprot.writeFieldEnd();
7105 }
7106 oprot.writeFieldStop();
7107 oprot.writeStructEnd();
7108 }
7109
7110 @Override
7111 public String toString() {
7112 StringBuilder sb = new StringBuilder("getColumnDescriptors_result(");
7113 boolean first = true;
7114
7115 sb.append("success:");
7116 if (this.success == null) {
7117 sb.append("null");
7118 } else {
7119 sb.append(this.success);
7120 }
7121 first = false;
7122 if (!first) sb.append(", ");
7123 sb.append("io:");
7124 if (this.io == null) {
7125 sb.append("null");
7126 } else {
7127 sb.append(this.io);
7128 }
7129 first = false;
7130 sb.append(")");
7131 return sb.toString();
7132 }
7133
7134 public void validate() throws TException {
7135
7136 }
7137
7138 }
7139
7140 public static class getTableRegions_args implements TBase<getTableRegions_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_args> {
7141 private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_args");
7142
7143 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
7144
7145
7146
7147
7148 public byte[] tableName;
7149
7150
7151 public enum _Fields implements TFieldIdEnum {
7152
7153
7154
7155 TABLE_NAME((short)1, "tableName");
7156
7157 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7158 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7159
7160 static {
7161 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7162 byId.put((int)field._thriftId, field);
7163 byName.put(field.getFieldName(), field);
7164 }
7165 }
7166
7167
7168
7169
7170 public static _Fields findByThriftId(int fieldId) {
7171 return byId.get(fieldId);
7172 }
7173
7174
7175
7176
7177
7178 public static _Fields findByThriftIdOrThrow(int fieldId) {
7179 _Fields fields = findByThriftId(fieldId);
7180 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7181 return fields;
7182 }
7183
7184
7185
7186
7187 public static _Fields findByName(String name) {
7188 return byName.get(name);
7189 }
7190
7191 private final short _thriftId;
7192 private final String _fieldName;
7193
7194 _Fields(short thriftId, String fieldName) {
7195 _thriftId = thriftId;
7196 _fieldName = fieldName;
7197 }
7198
7199 public short getThriftFieldId() {
7200 return _thriftId;
7201 }
7202
7203 public String getFieldName() {
7204 return _fieldName;
7205 }
7206 }
7207
7208
7209
7210 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7211 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
7212 new FieldValueMetaData(TType.STRING)));
7213 }});
7214
7215 static {
7216 FieldMetaData.addStructMetaDataMap(getTableRegions_args.class, metaDataMap);
7217 }
7218
7219 public getTableRegions_args() {
7220 }
7221
7222 public getTableRegions_args(
7223 byte[] tableName)
7224 {
7225 this();
7226 this.tableName = tableName;
7227 }
7228
7229
7230
7231
7232 public getTableRegions_args(getTableRegions_args other) {
7233 if (other.isSetTableName()) {
7234 this.tableName = other.tableName;
7235 }
7236 }
7237
7238 public getTableRegions_args deepCopy() {
7239 return new getTableRegions_args(this);
7240 }
7241
7242 @Deprecated
7243 public getTableRegions_args clone() {
7244 return new getTableRegions_args(this);
7245 }
7246
7247
7248
7249
7250 public byte[] getTableName() {
7251 return this.tableName;
7252 }
7253
7254
7255
7256
7257 public getTableRegions_args setTableName(byte[] tableName) {
7258 this.tableName = tableName;
7259 return this;
7260 }
7261
7262 public void unsetTableName() {
7263 this.tableName = null;
7264 }
7265
7266
7267 public boolean isSetTableName() {
7268 return this.tableName != null;
7269 }
7270
7271 public void setTableNameIsSet(boolean value) {
7272 if (!value) {
7273 this.tableName = null;
7274 }
7275 }
7276
7277 public void setFieldValue(_Fields field, Object value) {
7278 switch (field) {
7279 case TABLE_NAME:
7280 if (value == null) {
7281 unsetTableName();
7282 } else {
7283 setTableName((byte[])value);
7284 }
7285 break;
7286
7287 }
7288 }
7289
7290 public void setFieldValue(int fieldID, Object value) {
7291 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7292 }
7293
7294 public Object getFieldValue(_Fields field) {
7295 switch (field) {
7296 case TABLE_NAME:
7297 return getTableName();
7298
7299 }
7300 throw new IllegalStateException();
7301 }
7302
7303 public Object getFieldValue(int fieldId) {
7304 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7305 }
7306
7307
7308 public boolean isSet(_Fields field) {
7309 switch (field) {
7310 case TABLE_NAME:
7311 return isSetTableName();
7312 }
7313 throw new IllegalStateException();
7314 }
7315
7316 public boolean isSet(int fieldID) {
7317 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
7318 }
7319
7320 @Override
7321 public boolean equals(Object that) {
7322 if (that == null)
7323 return false;
7324 if (that instanceof getTableRegions_args)
7325 return this.equals((getTableRegions_args)that);
7326 return false;
7327 }
7328
7329 public boolean equals(getTableRegions_args that) {
7330 if (that == null)
7331 return false;
7332
7333 boolean this_present_tableName = true && this.isSetTableName();
7334 boolean that_present_tableName = true && that.isSetTableName();
7335 if (this_present_tableName || that_present_tableName) {
7336 if (!(this_present_tableName && that_present_tableName))
7337 return false;
7338 if (!java.util.Arrays.equals(this.tableName, that.tableName))
7339 return false;
7340 }
7341
7342 return true;
7343 }
7344
7345 @Override
7346 public int hashCode() {
7347 HashCodeBuilder builder = new HashCodeBuilder();
7348
7349 boolean present_tableName = true && (isSetTableName());
7350 builder.append(present_tableName);
7351 if (present_tableName)
7352 builder.append(tableName);
7353
7354 return builder.toHashCode();
7355 }
7356
7357 public int compareTo(getTableRegions_args other) {
7358 if (!getClass().equals(other.getClass())) {
7359 return getClass().getName().compareTo(other.getClass().getName());
7360 }
7361
7362 int lastComparison = 0;
7363 getTableRegions_args typedOther = (getTableRegions_args)other;
7364
7365 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
7366 if (lastComparison != 0) {
7367 return lastComparison;
7368 }
7369 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
7370 if (lastComparison != 0) {
7371 return lastComparison;
7372 }
7373 return 0;
7374 }
7375
7376 public void read(TProtocol iprot) throws TException {
7377 TField field;
7378 iprot.readStructBegin();
7379 while (true)
7380 {
7381 field = iprot.readFieldBegin();
7382 if (field.type == TType.STOP) {
7383 break;
7384 }
7385 _Fields fieldId = _Fields.findByThriftId(field.id);
7386 if (fieldId == null) {
7387 TProtocolUtil.skip(iprot, field.type);
7388 } else {
7389 switch (fieldId) {
7390 case TABLE_NAME:
7391 if (field.type == TType.STRING) {
7392 this.tableName = iprot.readBinary();
7393 } else {
7394 TProtocolUtil.skip(iprot, field.type);
7395 }
7396 break;
7397 }
7398 iprot.readFieldEnd();
7399 }
7400 }
7401 iprot.readStructEnd();
7402
7403
7404 validate();
7405 }
7406
7407 public void write(TProtocol oprot) throws TException {
7408 validate();
7409
7410 oprot.writeStructBegin(STRUCT_DESC);
7411 if (this.tableName != null) {
7412 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
7413 oprot.writeBinary(this.tableName);
7414 oprot.writeFieldEnd();
7415 }
7416 oprot.writeFieldStop();
7417 oprot.writeStructEnd();
7418 }
7419
7420 @Override
7421 public String toString() {
7422 StringBuilder sb = new StringBuilder("getTableRegions_args(");
7423 boolean first = true;
7424
7425 sb.append("tableName:");
7426 if (this.tableName == null) {
7427 sb.append("null");
7428 } else {
7429 sb.append(this.tableName);
7430 }
7431 first = false;
7432 sb.append(")");
7433 return sb.toString();
7434 }
7435
7436 public void validate() throws TException {
7437
7438 }
7439
7440 }
7441
7442 public static class getTableRegions_result implements TBase<getTableRegions_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_result> {
7443 private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_result");
7444
7445 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
7446 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
7447
7448 public List<TRegionInfo> success;
7449 public IOError io;
7450
7451
7452 public enum _Fields implements TFieldIdEnum {
7453 SUCCESS((short)0, "success"),
7454 IO((short)1, "io");
7455
7456 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7457 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7458
7459 static {
7460 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7461 byId.put((int)field._thriftId, field);
7462 byName.put(field.getFieldName(), field);
7463 }
7464 }
7465
7466
7467
7468
7469 public static _Fields findByThriftId(int fieldId) {
7470 return byId.get(fieldId);
7471 }
7472
7473
7474
7475
7476
7477 public static _Fields findByThriftIdOrThrow(int fieldId) {
7478 _Fields fields = findByThriftId(fieldId);
7479 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7480 return fields;
7481 }
7482
7483
7484
7485
7486 public static _Fields findByName(String name) {
7487 return byName.get(name);
7488 }
7489
7490 private final short _thriftId;
7491 private final String _fieldName;
7492
7493 _Fields(short thriftId, String fieldName) {
7494 _thriftId = thriftId;
7495 _fieldName = fieldName;
7496 }
7497
7498 public short getThriftFieldId() {
7499 return _thriftId;
7500 }
7501
7502 public String getFieldName() {
7503 return _fieldName;
7504 }
7505 }
7506
7507
7508
7509 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7510 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
7511 new ListMetaData(TType.LIST,
7512 new StructMetaData(TType.STRUCT, TRegionInfo.class))));
7513 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
7514 new FieldValueMetaData(TType.STRUCT)));
7515 }});
7516
7517 static {
7518 FieldMetaData.addStructMetaDataMap(getTableRegions_result.class, metaDataMap);
7519 }
7520
7521 public getTableRegions_result() {
7522 }
7523
7524 public getTableRegions_result(
7525 List<TRegionInfo> success,
7526 IOError io)
7527 {
7528 this();
7529 this.success = success;
7530 this.io = io;
7531 }
7532
7533
7534
7535
7536 public getTableRegions_result(getTableRegions_result other) {
7537 if (other.isSetSuccess()) {
7538 List<TRegionInfo> __this__success = new ArrayList<TRegionInfo>();
7539 for (TRegionInfo other_element : other.success) {
7540 __this__success.add(new TRegionInfo(other_element));
7541 }
7542 this.success = __this__success;
7543 }
7544 if (other.isSetIo()) {
7545 this.io = new IOError(other.io);
7546 }
7547 }
7548
7549 public getTableRegions_result deepCopy() {
7550 return new getTableRegions_result(this);
7551 }
7552
7553 @Deprecated
7554 public getTableRegions_result clone() {
7555 return new getTableRegions_result(this);
7556 }
7557
7558 public int getSuccessSize() {
7559 return (this.success == null) ? 0 : this.success.size();
7560 }
7561
7562 public java.util.Iterator<TRegionInfo> getSuccessIterator() {
7563 return (this.success == null) ? null : this.success.iterator();
7564 }
7565
7566 public void addToSuccess(TRegionInfo elem) {
7567 if (this.success == null) {
7568 this.success = new ArrayList<TRegionInfo>();
7569 }
7570 this.success.add(elem);
7571 }
7572
7573 public List<TRegionInfo> getSuccess() {
7574 return this.success;
7575 }
7576
7577 public getTableRegions_result setSuccess(List<TRegionInfo> success) {
7578 this.success = success;
7579 return this;
7580 }
7581
7582 public void unsetSuccess() {
7583 this.success = null;
7584 }
7585
7586
7587 public boolean isSetSuccess() {
7588 return this.success != null;
7589 }
7590
7591 public void setSuccessIsSet(boolean value) {
7592 if (!value) {
7593 this.success = null;
7594 }
7595 }
7596
7597 public IOError getIo() {
7598 return this.io;
7599 }
7600
7601 public getTableRegions_result setIo(IOError io) {
7602 this.io = io;
7603 return this;
7604 }
7605
7606 public void unsetIo() {
7607 this.io = null;
7608 }
7609
7610
7611 public boolean isSetIo() {
7612 return this.io != null;
7613 }
7614
7615 public void setIoIsSet(boolean value) {
7616 if (!value) {
7617 this.io = null;
7618 }
7619 }
7620
7621 public void setFieldValue(_Fields field, Object value) {
7622 switch (field) {
7623 case SUCCESS:
7624 if (value == null) {
7625 unsetSuccess();
7626 } else {
7627 setSuccess((List<TRegionInfo>)value);
7628 }
7629 break;
7630
7631 case IO:
7632 if (value == null) {
7633 unsetIo();
7634 } else {
7635 setIo((IOError)value);
7636 }
7637 break;
7638
7639 }
7640 }
7641
7642 public void setFieldValue(int fieldID, Object value) {
7643 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7644 }
7645
7646 public Object getFieldValue(_Fields field) {
7647 switch (field) {
7648 case SUCCESS:
7649 return getSuccess();
7650
7651 case IO:
7652 return getIo();
7653
7654 }
7655 throw new IllegalStateException();
7656 }
7657
7658 public Object getFieldValue(int fieldId) {
7659 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7660 }
7661
7662
7663 public boolean isSet(_Fields field) {
7664 switch (field) {
7665 case SUCCESS:
7666 return isSetSuccess();
7667 case IO:
7668 return isSetIo();
7669 }
7670 throw new IllegalStateException();
7671 }
7672
7673 public boolean isSet(int fieldID) {
7674 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
7675 }
7676
7677 @Override
7678 public boolean equals(Object that) {
7679 if (that == null)
7680 return false;
7681 if (that instanceof getTableRegions_result)
7682 return this.equals((getTableRegions_result)that);
7683 return false;
7684 }
7685
7686 public boolean equals(getTableRegions_result that) {
7687 if (that == null)
7688 return false;
7689
7690 boolean this_present_success = true && this.isSetSuccess();
7691 boolean that_present_success = true && that.isSetSuccess();
7692 if (this_present_success || that_present_success) {
7693 if (!(this_present_success && that_present_success))
7694 return false;
7695 if (!this.success.equals(that.success))
7696 return false;
7697 }
7698
7699 boolean this_present_io = true && this.isSetIo();
7700 boolean that_present_io = true && that.isSetIo();
7701 if (this_present_io || that_present_io) {
7702 if (!(this_present_io && that_present_io))
7703 return false;
7704 if (!this.io.equals(that.io))
7705 return false;
7706 }
7707
7708 return true;
7709 }
7710
7711 @Override
7712 public int hashCode() {
7713 HashCodeBuilder builder = new HashCodeBuilder();
7714
7715 boolean present_success = true && (isSetSuccess());
7716 builder.append(present_success);
7717 if (present_success)
7718 builder.append(success);
7719
7720 boolean present_io = true && (isSetIo());
7721 builder.append(present_io);
7722 if (present_io)
7723 builder.append(io);
7724
7725 return builder.toHashCode();
7726 }
7727
7728 public int compareTo(getTableRegions_result other) {
7729 if (!getClass().equals(other.getClass())) {
7730 return getClass().getName().compareTo(other.getClass().getName());
7731 }
7732
7733 int lastComparison = 0;
7734 getTableRegions_result typedOther = (getTableRegions_result)other;
7735
7736 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
7737 if (lastComparison != 0) {
7738 return lastComparison;
7739 }
7740 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
7741 if (lastComparison != 0) {
7742 return lastComparison;
7743 }
7744 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
7745 if (lastComparison != 0) {
7746 return lastComparison;
7747 }
7748 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
7749 if (lastComparison != 0) {
7750 return lastComparison;
7751 }
7752 return 0;
7753 }
7754
7755 public void read(TProtocol iprot) throws TException {
7756 TField field;
7757 iprot.readStructBegin();
7758 while (true)
7759 {
7760 field = iprot.readFieldBegin();
7761 if (field.type == TType.STOP) {
7762 break;
7763 }
7764 _Fields fieldId = _Fields.findByThriftId(field.id);
7765 if (fieldId == null) {
7766 TProtocolUtil.skip(iprot, field.type);
7767 } else {
7768 switch (fieldId) {
7769 case SUCCESS:
7770 if (field.type == TType.LIST) {
7771 {
7772 TList _list18 = iprot.readListBegin();
7773 this.success = new ArrayList<TRegionInfo>(_list18.size);
7774 for (int _i19 = 0; _i19 < _list18.size; ++_i19)
7775 {
7776 TRegionInfo _elem20;
7777 _elem20 = new TRegionInfo();
7778 _elem20.read(iprot);
7779 this.success.add(_elem20);
7780 }
7781 iprot.readListEnd();
7782 }
7783 } else {
7784 TProtocolUtil.skip(iprot, field.type);
7785 }
7786 break;
7787 case IO:
7788 if (field.type == TType.STRUCT) {
7789 this.io = new IOError();
7790 this.io.read(iprot);
7791 } else {
7792 TProtocolUtil.skip(iprot, field.type);
7793 }
7794 break;
7795 }
7796 iprot.readFieldEnd();
7797 }
7798 }
7799 iprot.readStructEnd();
7800
7801
7802 validate();
7803 }
7804
7805 public void write(TProtocol oprot) throws TException {
7806 oprot.writeStructBegin(STRUCT_DESC);
7807
7808 if (this.isSetSuccess()) {
7809 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
7810 {
7811 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
7812 for (TRegionInfo _iter21 : this.success)
7813 {
7814 _iter21.write(oprot);
7815 }
7816 oprot.writeListEnd();
7817 }
7818 oprot.writeFieldEnd();
7819 } else if (this.isSetIo()) {
7820 oprot.writeFieldBegin(IO_FIELD_DESC);
7821 this.io.write(oprot);
7822 oprot.writeFieldEnd();
7823 }
7824 oprot.writeFieldStop();
7825 oprot.writeStructEnd();
7826 }
7827
7828 @Override
7829 public String toString() {
7830 StringBuilder sb = new StringBuilder("getTableRegions_result(");
7831 boolean first = true;
7832
7833 sb.append("success:");
7834 if (this.success == null) {
7835 sb.append("null");
7836 } else {
7837 sb.append(this.success);
7838 }
7839 first = false;
7840 if (!first) sb.append(", ");
7841 sb.append("io:");
7842 if (this.io == null) {
7843 sb.append("null");
7844 } else {
7845 sb.append(this.io);
7846 }
7847 first = false;
7848 sb.append(")");
7849 return sb.toString();
7850 }
7851
7852 public void validate() throws TException {
7853
7854 }
7855
7856 }
7857
7858 public static class createTable_args implements TBase<createTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_args> {
7859 private static final TStruct STRUCT_DESC = new TStruct("createTable_args");
7860
7861 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
7862 private static final TField COLUMN_FAMILIES_FIELD_DESC = new TField("columnFamilies", TType.LIST, (short)2);
7863
7864
7865
7866
7867 public byte[] tableName;
7868
7869
7870
7871 public List<ColumnDescriptor> columnFamilies;
7872
7873
7874 public enum _Fields implements TFieldIdEnum {
7875
7876
7877
7878 TABLE_NAME((short)1, "tableName"),
7879
7880
7881
7882 COLUMN_FAMILIES((short)2, "columnFamilies");
7883
7884 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7885 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7886
7887 static {
7888 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7889 byId.put((int)field._thriftId, field);
7890 byName.put(field.getFieldName(), field);
7891 }
7892 }
7893
7894
7895
7896
7897 public static _Fields findByThriftId(int fieldId) {
7898 return byId.get(fieldId);
7899 }
7900
7901
7902
7903
7904
7905 public static _Fields findByThriftIdOrThrow(int fieldId) {
7906 _Fields fields = findByThriftId(fieldId);
7907 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7908 return fields;
7909 }
7910
7911
7912
7913
7914 public static _Fields findByName(String name) {
7915 return byName.get(name);
7916 }
7917
7918 private final short _thriftId;
7919 private final String _fieldName;
7920
7921 _Fields(short thriftId, String fieldName) {
7922 _thriftId = thriftId;
7923 _fieldName = fieldName;
7924 }
7925
7926 public short getThriftFieldId() {
7927 return _thriftId;
7928 }
7929
7930 public String getFieldName() {
7931 return _fieldName;
7932 }
7933 }
7934
7935
7936
7937 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7938 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
7939 new FieldValueMetaData(TType.STRING)));
7940 put(_Fields.COLUMN_FAMILIES, new FieldMetaData("columnFamilies", TFieldRequirementType.DEFAULT,
7941 new ListMetaData(TType.LIST,
7942 new StructMetaData(TType.STRUCT, ColumnDescriptor.class))));
7943 }});
7944
7945 static {
7946 FieldMetaData.addStructMetaDataMap(createTable_args.class, metaDataMap);
7947 }
7948
7949 public createTable_args() {
7950 }
7951
7952 public createTable_args(
7953 byte[] tableName,
7954 List<ColumnDescriptor> columnFamilies)
7955 {
7956 this();
7957 this.tableName = tableName;
7958 this.columnFamilies = columnFamilies;
7959 }
7960
7961
7962
7963
7964 public createTable_args(createTable_args other) {
7965 if (other.isSetTableName()) {
7966 this.tableName = other.tableName;
7967 }
7968 if (other.isSetColumnFamilies()) {
7969 List<ColumnDescriptor> __this__columnFamilies = new ArrayList<ColumnDescriptor>();
7970 for (ColumnDescriptor other_element : other.columnFamilies) {
7971 __this__columnFamilies.add(new ColumnDescriptor(other_element));
7972 }
7973 this.columnFamilies = __this__columnFamilies;
7974 }
7975 }
7976
7977 public createTable_args deepCopy() {
7978 return new createTable_args(this);
7979 }
7980
7981 @Deprecated
7982 public createTable_args clone() {
7983 return new createTable_args(this);
7984 }
7985
7986
7987
7988
7989 public byte[] getTableName() {
7990 return this.tableName;
7991 }
7992
7993
7994
7995
7996 public createTable_args setTableName(byte[] tableName) {
7997 this.tableName = tableName;
7998 return this;
7999 }
8000
8001 public void unsetTableName() {
8002 this.tableName = null;
8003 }
8004
8005
8006 public boolean isSetTableName() {
8007 return this.tableName != null;
8008 }
8009
8010 public void setTableNameIsSet(boolean value) {
8011 if (!value) {
8012 this.tableName = null;
8013 }
8014 }
8015
8016 public int getColumnFamiliesSize() {
8017 return (this.columnFamilies == null) ? 0 : this.columnFamilies.size();
8018 }
8019
8020 public java.util.Iterator<ColumnDescriptor> getColumnFamiliesIterator() {
8021 return (this.columnFamilies == null) ? null : this.columnFamilies.iterator();
8022 }
8023
8024 public void addToColumnFamilies(ColumnDescriptor elem) {
8025 if (this.columnFamilies == null) {
8026 this.columnFamilies = new ArrayList<ColumnDescriptor>();
8027 }
8028 this.columnFamilies.add(elem);
8029 }
8030
8031
8032
8033
8034 public List<ColumnDescriptor> getColumnFamilies() {
8035 return this.columnFamilies;
8036 }
8037
8038
8039
8040
8041 public createTable_args setColumnFamilies(List<ColumnDescriptor> columnFamilies) {
8042 this.columnFamilies = columnFamilies;
8043 return this;
8044 }
8045
8046 public void unsetColumnFamilies() {
8047 this.columnFamilies = null;
8048 }
8049
8050
8051 public boolean isSetColumnFamilies() {
8052 return this.columnFamilies != null;
8053 }
8054
8055 public void setColumnFamiliesIsSet(boolean value) {
8056 if (!value) {
8057 this.columnFamilies = null;
8058 }
8059 }
8060
8061 public void setFieldValue(_Fields field, Object value) {
8062 switch (field) {
8063 case TABLE_NAME:
8064 if (value == null) {
8065 unsetTableName();
8066 } else {
8067 setTableName((byte[])value);
8068 }
8069 break;
8070
8071 case COLUMN_FAMILIES:
8072 if (value == null) {
8073 unsetColumnFamilies();
8074 } else {
8075 setColumnFamilies((List<ColumnDescriptor>)value);
8076 }
8077 break;
8078
8079 }
8080 }
8081
8082 public void setFieldValue(int fieldID, Object value) {
8083 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8084 }
8085
8086 public Object getFieldValue(_Fields field) {
8087 switch (field) {
8088 case TABLE_NAME:
8089 return getTableName();
8090
8091 case COLUMN_FAMILIES:
8092 return getColumnFamilies();
8093
8094 }
8095 throw new IllegalStateException();
8096 }
8097
8098 public Object getFieldValue(int fieldId) {
8099 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8100 }
8101
8102
8103 public boolean isSet(_Fields field) {
8104 switch (field) {
8105 case TABLE_NAME:
8106 return isSetTableName();
8107 case COLUMN_FAMILIES:
8108 return isSetColumnFamilies();
8109 }
8110 throw new IllegalStateException();
8111 }
8112
8113 public boolean isSet(int fieldID) {
8114 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8115 }
8116
8117 @Override
8118 public boolean equals(Object that) {
8119 if (that == null)
8120 return false;
8121 if (that instanceof createTable_args)
8122 return this.equals((createTable_args)that);
8123 return false;
8124 }
8125
8126 public boolean equals(createTable_args that) {
8127 if (that == null)
8128 return false;
8129
8130 boolean this_present_tableName = true && this.isSetTableName();
8131 boolean that_present_tableName = true && that.isSetTableName();
8132 if (this_present_tableName || that_present_tableName) {
8133 if (!(this_present_tableName && that_present_tableName))
8134 return false;
8135 if (!java.util.Arrays.equals(this.tableName, that.tableName))
8136 return false;
8137 }
8138
8139 boolean this_present_columnFamilies = true && this.isSetColumnFamilies();
8140 boolean that_present_columnFamilies = true && that.isSetColumnFamilies();
8141 if (this_present_columnFamilies || that_present_columnFamilies) {
8142 if (!(this_present_columnFamilies && that_present_columnFamilies))
8143 return false;
8144 if (!this.columnFamilies.equals(that.columnFamilies))
8145 return false;
8146 }
8147
8148 return true;
8149 }
8150
8151 @Override
8152 public int hashCode() {
8153 HashCodeBuilder builder = new HashCodeBuilder();
8154
8155 boolean present_tableName = true && (isSetTableName());
8156 builder.append(present_tableName);
8157 if (present_tableName)
8158 builder.append(tableName);
8159
8160 boolean present_columnFamilies = true && (isSetColumnFamilies());
8161 builder.append(present_columnFamilies);
8162 if (present_columnFamilies)
8163 builder.append(columnFamilies);
8164
8165 return builder.toHashCode();
8166 }
8167
8168 public int compareTo(createTable_args other) {
8169 if (!getClass().equals(other.getClass())) {
8170 return getClass().getName().compareTo(other.getClass().getName());
8171 }
8172
8173 int lastComparison = 0;
8174 createTable_args typedOther = (createTable_args)other;
8175
8176 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
8177 if (lastComparison != 0) {
8178 return lastComparison;
8179 }
8180 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
8181 if (lastComparison != 0) {
8182 return lastComparison;
8183 }
8184 lastComparison = Boolean.valueOf(isSetColumnFamilies()).compareTo(isSetColumnFamilies());
8185 if (lastComparison != 0) {
8186 return lastComparison;
8187 }
8188 lastComparison = TBaseHelper.compareTo(columnFamilies, typedOther.columnFamilies);
8189 if (lastComparison != 0) {
8190 return lastComparison;
8191 }
8192 return 0;
8193 }
8194
8195 public void read(TProtocol iprot) throws TException {
8196 TField field;
8197 iprot.readStructBegin();
8198 while (true)
8199 {
8200 field = iprot.readFieldBegin();
8201 if (field.type == TType.STOP) {
8202 break;
8203 }
8204 _Fields fieldId = _Fields.findByThriftId(field.id);
8205 if (fieldId == null) {
8206 TProtocolUtil.skip(iprot, field.type);
8207 } else {
8208 switch (fieldId) {
8209 case TABLE_NAME:
8210 if (field.type == TType.STRING) {
8211 this.tableName = iprot.readBinary();
8212 } else {
8213 TProtocolUtil.skip(iprot, field.type);
8214 }
8215 break;
8216 case COLUMN_FAMILIES:
8217 if (field.type == TType.LIST) {
8218 {
8219 TList _list22 = iprot.readListBegin();
8220 this.columnFamilies = new ArrayList<ColumnDescriptor>(_list22.size);
8221 for (int _i23 = 0; _i23 < _list22.size; ++_i23)
8222 {
8223 ColumnDescriptor _elem24;
8224 _elem24 = new ColumnDescriptor();
8225 _elem24.read(iprot);
8226 this.columnFamilies.add(_elem24);
8227 }
8228 iprot.readListEnd();
8229 }
8230 } else {
8231 TProtocolUtil.skip(iprot, field.type);
8232 }
8233 break;
8234 }
8235 iprot.readFieldEnd();
8236 }
8237 }
8238 iprot.readStructEnd();
8239
8240
8241 validate();
8242 }
8243
8244 public void write(TProtocol oprot) throws TException {
8245 validate();
8246
8247 oprot.writeStructBegin(STRUCT_DESC);
8248 if (this.tableName != null) {
8249 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
8250 oprot.writeBinary(this.tableName);
8251 oprot.writeFieldEnd();
8252 }
8253 if (this.columnFamilies != null) {
8254 oprot.writeFieldBegin(COLUMN_FAMILIES_FIELD_DESC);
8255 {
8256 oprot.writeListBegin(new TList(TType.STRUCT, this.columnFamilies.size()));
8257 for (ColumnDescriptor _iter25 : this.columnFamilies)
8258 {
8259 _iter25.write(oprot);
8260 }
8261 oprot.writeListEnd();
8262 }
8263 oprot.writeFieldEnd();
8264 }
8265 oprot.writeFieldStop();
8266 oprot.writeStructEnd();
8267 }
8268
8269 @Override
8270 public String toString() {
8271 StringBuilder sb = new StringBuilder("createTable_args(");
8272 boolean first = true;
8273
8274 sb.append("tableName:");
8275 if (this.tableName == null) {
8276 sb.append("null");
8277 } else {
8278 sb.append(this.tableName);
8279 }
8280 first = false;
8281 if (!first) sb.append(", ");
8282 sb.append("columnFamilies:");
8283 if (this.columnFamilies == null) {
8284 sb.append("null");
8285 } else {
8286 sb.append(this.columnFamilies);
8287 }
8288 first = false;
8289 sb.append(")");
8290 return sb.toString();
8291 }
8292
8293 public void validate() throws TException {
8294
8295 }
8296
8297 }
8298
8299 public static class createTable_result implements TBase<createTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_result> {
8300 private static final TStruct STRUCT_DESC = new TStruct("createTable_result");
8301
8302 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
8303 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
8304 private static final TField EXIST_FIELD_DESC = new TField("exist", TType.STRUCT, (short)3);
8305
8306 public IOError io;
8307 public IllegalArgument ia;
8308 public AlreadyExists exist;
8309
8310
8311 public enum _Fields implements TFieldIdEnum {
8312 IO((short)1, "io"),
8313 IA((short)2, "ia"),
8314 EXIST((short)3, "exist");
8315
8316 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
8317 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8318
8319 static {
8320 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8321 byId.put((int)field._thriftId, field);
8322 byName.put(field.getFieldName(), field);
8323 }
8324 }
8325
8326
8327
8328
8329 public static _Fields findByThriftId(int fieldId) {
8330 return byId.get(fieldId);
8331 }
8332
8333
8334
8335
8336
8337 public static _Fields findByThriftIdOrThrow(int fieldId) {
8338 _Fields fields = findByThriftId(fieldId);
8339 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8340 return fields;
8341 }
8342
8343
8344
8345
8346 public static _Fields findByName(String name) {
8347 return byName.get(name);
8348 }
8349
8350 private final short _thriftId;
8351 private final String _fieldName;
8352
8353 _Fields(short thriftId, String fieldName) {
8354 _thriftId = thriftId;
8355 _fieldName = fieldName;
8356 }
8357
8358 public short getThriftFieldId() {
8359 return _thriftId;
8360 }
8361
8362 public String getFieldName() {
8363 return _fieldName;
8364 }
8365 }
8366
8367
8368
8369 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
8370 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
8371 new FieldValueMetaData(TType.STRUCT)));
8372 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
8373 new FieldValueMetaData(TType.STRUCT)));
8374 put(_Fields.EXIST, new FieldMetaData("exist", TFieldRequirementType.DEFAULT,
8375 new FieldValueMetaData(TType.STRUCT)));
8376 }});
8377
8378 static {
8379 FieldMetaData.addStructMetaDataMap(createTable_result.class, metaDataMap);
8380 }
8381
8382 public createTable_result() {
8383 }
8384
8385 public createTable_result(
8386 IOError io,
8387 IllegalArgument ia,
8388 AlreadyExists exist)
8389 {
8390 this();
8391 this.io = io;
8392 this.ia = ia;
8393 this.exist = exist;
8394 }
8395
8396
8397
8398
8399 public createTable_result(createTable_result other) {
8400 if (other.isSetIo()) {
8401 this.io = new IOError(other.io);
8402 }
8403 if (other.isSetIa()) {
8404 this.ia = new IllegalArgument(other.ia);
8405 }
8406 if (other.isSetExist()) {
8407 this.exist = new AlreadyExists(other.exist);
8408 }
8409 }
8410
8411 public createTable_result deepCopy() {
8412 return new createTable_result(this);
8413 }
8414
8415 @Deprecated
8416 public createTable_result clone() {
8417 return new createTable_result(this);
8418 }
8419
8420 public IOError getIo() {
8421 return this.io;
8422 }
8423
8424 public createTable_result setIo(IOError io) {
8425 this.io = io;
8426 return this;
8427 }
8428
8429 public void unsetIo() {
8430 this.io = null;
8431 }
8432
8433
8434 public boolean isSetIo() {
8435 return this.io != null;
8436 }
8437
8438 public void setIoIsSet(boolean value) {
8439 if (!value) {
8440 this.io = null;
8441 }
8442 }
8443
8444 public IllegalArgument getIa() {
8445 return this.ia;
8446 }
8447
8448 public createTable_result setIa(IllegalArgument ia) {
8449 this.ia = ia;
8450 return this;
8451 }
8452
8453 public void unsetIa() {
8454 this.ia = null;
8455 }
8456
8457
8458 public boolean isSetIa() {
8459 return this.ia != null;
8460 }
8461
8462 public void setIaIsSet(boolean value) {
8463 if (!value) {
8464 this.ia = null;
8465 }
8466 }
8467
8468 public AlreadyExists getExist() {
8469 return this.exist;
8470 }
8471
8472 public createTable_result setExist(AlreadyExists exist) {
8473 this.exist = exist;
8474 return this;
8475 }
8476
8477 public void unsetExist() {
8478 this.exist = null;
8479 }
8480
8481
8482 public boolean isSetExist() {
8483 return this.exist != null;
8484 }
8485
8486 public void setExistIsSet(boolean value) {
8487 if (!value) {
8488 this.exist = null;
8489 }
8490 }
8491
8492 public void setFieldValue(_Fields field, Object value) {
8493 switch (field) {
8494 case IO:
8495 if (value == null) {
8496 unsetIo();
8497 } else {
8498 setIo((IOError)value);
8499 }
8500 break;
8501
8502 case IA:
8503 if (value == null) {
8504 unsetIa();
8505 } else {
8506 setIa((IllegalArgument)value);
8507 }
8508 break;
8509
8510 case EXIST:
8511 if (value == null) {
8512 unsetExist();
8513 } else {
8514 setExist((AlreadyExists)value);
8515 }
8516 break;
8517
8518 }
8519 }
8520
8521 public void setFieldValue(int fieldID, Object value) {
8522 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8523 }
8524
8525 public Object getFieldValue(_Fields field) {
8526 switch (field) {
8527 case IO:
8528 return getIo();
8529
8530 case IA:
8531 return getIa();
8532
8533 case EXIST:
8534 return getExist();
8535
8536 }
8537 throw new IllegalStateException();
8538 }
8539
8540 public Object getFieldValue(int fieldId) {
8541 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8542 }
8543
8544
8545 public boolean isSet(_Fields field) {
8546 switch (field) {
8547 case IO:
8548 return isSetIo();
8549 case IA:
8550 return isSetIa();
8551 case EXIST:
8552 return isSetExist();
8553 }
8554 throw new IllegalStateException();
8555 }
8556
8557 public boolean isSet(int fieldID) {
8558 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8559 }
8560
8561 @Override
8562 public boolean equals(Object that) {
8563 if (that == null)
8564 return false;
8565 if (that instanceof createTable_result)
8566 return this.equals((createTable_result)that);
8567 return false;
8568 }
8569
8570 public boolean equals(createTable_result that) {
8571 if (that == null)
8572 return false;
8573
8574 boolean this_present_io = true && this.isSetIo();
8575 boolean that_present_io = true && that.isSetIo();
8576 if (this_present_io || that_present_io) {
8577 if (!(this_present_io && that_present_io))
8578 return false;
8579 if (!this.io.equals(that.io))
8580 return false;
8581 }
8582
8583 boolean this_present_ia = true && this.isSetIa();
8584 boolean that_present_ia = true && that.isSetIa();
8585 if (this_present_ia || that_present_ia) {
8586 if (!(this_present_ia && that_present_ia))
8587 return false;
8588 if (!this.ia.equals(that.ia))
8589 return false;
8590 }
8591
8592 boolean this_present_exist = true && this.isSetExist();
8593 boolean that_present_exist = true && that.isSetExist();
8594 if (this_present_exist || that_present_exist) {
8595 if (!(this_present_exist && that_present_exist))
8596 return false;
8597 if (!this.exist.equals(that.exist))
8598 return false;
8599 }
8600
8601 return true;
8602 }
8603
8604 @Override
8605 public int hashCode() {
8606 HashCodeBuilder builder = new HashCodeBuilder();
8607
8608 boolean present_io = true && (isSetIo());
8609 builder.append(present_io);
8610 if (present_io)
8611 builder.append(io);
8612
8613 boolean present_ia = true && (isSetIa());
8614 builder.append(present_ia);
8615 if (present_ia)
8616 builder.append(ia);
8617
8618 boolean present_exist = true && (isSetExist());
8619 builder.append(present_exist);
8620 if (present_exist)
8621 builder.append(exist);
8622
8623 return builder.toHashCode();
8624 }
8625
8626 public int compareTo(createTable_result other) {
8627 if (!getClass().equals(other.getClass())) {
8628 return getClass().getName().compareTo(other.getClass().getName());
8629 }
8630
8631 int lastComparison = 0;
8632 createTable_result typedOther = (createTable_result)other;
8633
8634 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
8635 if (lastComparison != 0) {
8636 return lastComparison;
8637 }
8638 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
8639 if (lastComparison != 0) {
8640 return lastComparison;
8641 }
8642 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
8643 if (lastComparison != 0) {
8644 return lastComparison;
8645 }
8646 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
8647 if (lastComparison != 0) {
8648 return lastComparison;
8649 }
8650 lastComparison = Boolean.valueOf(isSetExist()).compareTo(isSetExist());
8651 if (lastComparison != 0) {
8652 return lastComparison;
8653 }
8654 lastComparison = TBaseHelper.compareTo(exist, typedOther.exist);
8655 if (lastComparison != 0) {
8656 return lastComparison;
8657 }
8658 return 0;
8659 }
8660
8661 public void read(TProtocol iprot) throws TException {
8662 TField field;
8663 iprot.readStructBegin();
8664 while (true)
8665 {
8666 field = iprot.readFieldBegin();
8667 if (field.type == TType.STOP) {
8668 break;
8669 }
8670 _Fields fieldId = _Fields.findByThriftId(field.id);
8671 if (fieldId == null) {
8672 TProtocolUtil.skip(iprot, field.type);
8673 } else {
8674 switch (fieldId) {
8675 case IO:
8676 if (field.type == TType.STRUCT) {
8677 this.io = new IOError();
8678 this.io.read(iprot);
8679 } else {
8680 TProtocolUtil.skip(iprot, field.type);
8681 }
8682 break;
8683 case IA:
8684 if (field.type == TType.STRUCT) {
8685 this.ia = new IllegalArgument();
8686 this.ia.read(iprot);
8687 } else {
8688 TProtocolUtil.skip(iprot, field.type);
8689 }
8690 break;
8691 case EXIST:
8692 if (field.type == TType.STRUCT) {
8693 this.exist = new AlreadyExists();
8694 this.exist.read(iprot);
8695 } else {
8696 TProtocolUtil.skip(iprot, field.type);
8697 }
8698 break;
8699 }
8700 iprot.readFieldEnd();
8701 }
8702 }
8703 iprot.readStructEnd();
8704
8705
8706 validate();
8707 }
8708
8709 public void write(TProtocol oprot) throws TException {
8710 oprot.writeStructBegin(STRUCT_DESC);
8711
8712 if (this.isSetIo()) {
8713 oprot.writeFieldBegin(IO_FIELD_DESC);
8714 this.io.write(oprot);
8715 oprot.writeFieldEnd();
8716 } else if (this.isSetIa()) {
8717 oprot.writeFieldBegin(IA_FIELD_DESC);
8718 this.ia.write(oprot);
8719 oprot.writeFieldEnd();
8720 } else if (this.isSetExist()) {
8721 oprot.writeFieldBegin(EXIST_FIELD_DESC);
8722 this.exist.write(oprot);
8723 oprot.writeFieldEnd();
8724 }
8725 oprot.writeFieldStop();
8726 oprot.writeStructEnd();
8727 }
8728
8729 @Override
8730 public String toString() {
8731 StringBuilder sb = new StringBuilder("createTable_result(");
8732 boolean first = true;
8733
8734 sb.append("io:");
8735 if (this.io == null) {
8736 sb.append("null");
8737 } else {
8738 sb.append(this.io);
8739 }
8740 first = false;
8741 if (!first) sb.append(", ");
8742 sb.append("ia:");
8743 if (this.ia == null) {
8744 sb.append("null");
8745 } else {
8746 sb.append(this.ia);
8747 }
8748 first = false;
8749 if (!first) sb.append(", ");
8750 sb.append("exist:");
8751 if (this.exist == null) {
8752 sb.append("null");
8753 } else {
8754 sb.append(this.exist);
8755 }
8756 first = false;
8757 sb.append(")");
8758 return sb.toString();
8759 }
8760
8761 public void validate() throws TException {
8762
8763 }
8764
8765 }
8766
8767 public static class deleteTable_args implements TBase<deleteTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_args> {
8768 private static final TStruct STRUCT_DESC = new TStruct("deleteTable_args");
8769
8770 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
8771
8772
8773
8774
8775 public byte[] tableName;
8776
8777
8778 public enum _Fields implements TFieldIdEnum {
8779
8780
8781
8782 TABLE_NAME((short)1, "tableName");
8783
8784 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
8785 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8786
8787 static {
8788 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8789 byId.put((int)field._thriftId, field);
8790 byName.put(field.getFieldName(), field);
8791 }
8792 }
8793
8794
8795
8796
8797 public static _Fields findByThriftId(int fieldId) {
8798 return byId.get(fieldId);
8799 }
8800
8801
8802
8803
8804
8805 public static _Fields findByThriftIdOrThrow(int fieldId) {
8806 _Fields fields = findByThriftId(fieldId);
8807 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8808 return fields;
8809 }
8810
8811
8812
8813
8814 public static _Fields findByName(String name) {
8815 return byName.get(name);
8816 }
8817
8818 private final short _thriftId;
8819 private final String _fieldName;
8820
8821 _Fields(short thriftId, String fieldName) {
8822 _thriftId = thriftId;
8823 _fieldName = fieldName;
8824 }
8825
8826 public short getThriftFieldId() {
8827 return _thriftId;
8828 }
8829
8830 public String getFieldName() {
8831 return _fieldName;
8832 }
8833 }
8834
8835
8836
8837 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
8838 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
8839 new FieldValueMetaData(TType.STRING)));
8840 }});
8841
8842 static {
8843 FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap);
8844 }
8845
8846 public deleteTable_args() {
8847 }
8848
8849 public deleteTable_args(
8850 byte[] tableName)
8851 {
8852 this();
8853 this.tableName = tableName;
8854 }
8855
8856
8857
8858
8859 public deleteTable_args(deleteTable_args other) {
8860 if (other.isSetTableName()) {
8861 this.tableName = other.tableName;
8862 }
8863 }
8864
8865 public deleteTable_args deepCopy() {
8866 return new deleteTable_args(this);
8867 }
8868
8869 @Deprecated
8870 public deleteTable_args clone() {
8871 return new deleteTable_args(this);
8872 }
8873
8874
8875
8876
8877 public byte[] getTableName() {
8878 return this.tableName;
8879 }
8880
8881
8882
8883
8884 public deleteTable_args setTableName(byte[] tableName) {
8885 this.tableName = tableName;
8886 return this;
8887 }
8888
8889 public void unsetTableName() {
8890 this.tableName = null;
8891 }
8892
8893
8894 public boolean isSetTableName() {
8895 return this.tableName != null;
8896 }
8897
8898 public void setTableNameIsSet(boolean value) {
8899 if (!value) {
8900 this.tableName = null;
8901 }
8902 }
8903
8904 public void setFieldValue(_Fields field, Object value) {
8905 switch (field) {
8906 case TABLE_NAME:
8907 if (value == null) {
8908 unsetTableName();
8909 } else {
8910 setTableName((byte[])value);
8911 }
8912 break;
8913
8914 }
8915 }
8916
8917 public void setFieldValue(int fieldID, Object value) {
8918 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8919 }
8920
8921 public Object getFieldValue(_Fields field) {
8922 switch (field) {
8923 case TABLE_NAME:
8924 return getTableName();
8925
8926 }
8927 throw new IllegalStateException();
8928 }
8929
8930 public Object getFieldValue(int fieldId) {
8931 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8932 }
8933
8934
8935 public boolean isSet(_Fields field) {
8936 switch (field) {
8937 case TABLE_NAME:
8938 return isSetTableName();
8939 }
8940 throw new IllegalStateException();
8941 }
8942
8943 public boolean isSet(int fieldID) {
8944 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8945 }
8946
8947 @Override
8948 public boolean equals(Object that) {
8949 if (that == null)
8950 return false;
8951 if (that instanceof deleteTable_args)
8952 return this.equals((deleteTable_args)that);
8953 return false;
8954 }
8955
8956 public boolean equals(deleteTable_args that) {
8957 if (that == null)
8958 return false;
8959
8960 boolean this_present_tableName = true && this.isSetTableName();
8961 boolean that_present_tableName = true && that.isSetTableName();
8962 if (this_present_tableName || that_present_tableName) {
8963 if (!(this_present_tableName && that_present_tableName))
8964 return false;
8965 if (!java.util.Arrays.equals(this.tableName, that.tableName))
8966 return false;
8967 }
8968
8969 return true;
8970 }
8971
8972 @Override
8973 public int hashCode() {
8974 HashCodeBuilder builder = new HashCodeBuilder();
8975
8976 boolean present_tableName = true && (isSetTableName());
8977 builder.append(present_tableName);
8978 if (present_tableName)
8979 builder.append(tableName);
8980
8981 return builder.toHashCode();
8982 }
8983
8984 public int compareTo(deleteTable_args other) {
8985 if (!getClass().equals(other.getClass())) {
8986 return getClass().getName().compareTo(other.getClass().getName());
8987 }
8988
8989 int lastComparison = 0;
8990 deleteTable_args typedOther = (deleteTable_args)other;
8991
8992 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
8993 if (lastComparison != 0) {
8994 return lastComparison;
8995 }
8996 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
8997 if (lastComparison != 0) {
8998 return lastComparison;
8999 }
9000 return 0;
9001 }
9002
9003 public void read(TProtocol iprot) throws TException {
9004 TField field;
9005 iprot.readStructBegin();
9006 while (true)
9007 {
9008 field = iprot.readFieldBegin();
9009 if (field.type == TType.STOP) {
9010 break;
9011 }
9012 _Fields fieldId = _Fields.findByThriftId(field.id);
9013 if (fieldId == null) {
9014 TProtocolUtil.skip(iprot, field.type);
9015 } else {
9016 switch (fieldId) {
9017 case TABLE_NAME:
9018 if (field.type == TType.STRING) {
9019 this.tableName = iprot.readBinary();
9020 } else {
9021 TProtocolUtil.skip(iprot, field.type);
9022 }
9023 break;
9024 }
9025 iprot.readFieldEnd();
9026 }
9027 }
9028 iprot.readStructEnd();
9029
9030
9031 validate();
9032 }
9033
9034 public void write(TProtocol oprot) throws TException {
9035 validate();
9036
9037 oprot.writeStructBegin(STRUCT_DESC);
9038 if (this.tableName != null) {
9039 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
9040 oprot.writeBinary(this.tableName);
9041 oprot.writeFieldEnd();
9042 }
9043 oprot.writeFieldStop();
9044 oprot.writeStructEnd();
9045 }
9046
9047 @Override
9048 public String toString() {
9049 StringBuilder sb = new StringBuilder("deleteTable_args(");
9050 boolean first = true;
9051
9052 sb.append("tableName:");
9053 if (this.tableName == null) {
9054 sb.append("null");
9055 } else {
9056 sb.append(this.tableName);
9057 }
9058 first = false;
9059 sb.append(")");
9060 return sb.toString();
9061 }
9062
9063 public void validate() throws TException {
9064
9065 }
9066
9067 }
9068
9069 public static class deleteTable_result implements TBase<deleteTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_result> {
9070 private static final TStruct STRUCT_DESC = new TStruct("deleteTable_result");
9071
9072 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
9073
9074 public IOError io;
9075
9076
9077 public enum _Fields implements TFieldIdEnum {
9078 IO((short)1, "io");
9079
9080 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9081 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9082
9083 static {
9084 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9085 byId.put((int)field._thriftId, field);
9086 byName.put(field.getFieldName(), field);
9087 }
9088 }
9089
9090
9091
9092
9093 public static _Fields findByThriftId(int fieldId) {
9094 return byId.get(fieldId);
9095 }
9096
9097
9098
9099
9100
9101 public static _Fields findByThriftIdOrThrow(int fieldId) {
9102 _Fields fields = findByThriftId(fieldId);
9103 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9104 return fields;
9105 }
9106
9107
9108
9109
9110 public static _Fields findByName(String name) {
9111 return byName.get(name);
9112 }
9113
9114 private final short _thriftId;
9115 private final String _fieldName;
9116
9117 _Fields(short thriftId, String fieldName) {
9118 _thriftId = thriftId;
9119 _fieldName = fieldName;
9120 }
9121
9122 public short getThriftFieldId() {
9123 return _thriftId;
9124 }
9125
9126 public String getFieldName() {
9127 return _fieldName;
9128 }
9129 }
9130
9131
9132
9133 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9134 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
9135 new FieldValueMetaData(TType.STRUCT)));
9136 }});
9137
9138 static {
9139 FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap);
9140 }
9141
9142 public deleteTable_result() {
9143 }
9144
9145 public deleteTable_result(
9146 IOError io)
9147 {
9148 this();
9149 this.io = io;
9150 }
9151
9152
9153
9154
9155 public deleteTable_result(deleteTable_result other) {
9156 if (other.isSetIo()) {
9157 this.io = new IOError(other.io);
9158 }
9159 }
9160
9161 public deleteTable_result deepCopy() {
9162 return new deleteTable_result(this);
9163 }
9164
9165 @Deprecated
9166 public deleteTable_result clone() {
9167 return new deleteTable_result(this);
9168 }
9169
9170 public IOError getIo() {
9171 return this.io;
9172 }
9173
9174 public deleteTable_result setIo(IOError io) {
9175 this.io = io;
9176 return this;
9177 }
9178
9179 public void unsetIo() {
9180 this.io = null;
9181 }
9182
9183
9184 public boolean isSetIo() {
9185 return this.io != null;
9186 }
9187
9188 public void setIoIsSet(boolean value) {
9189 if (!value) {
9190 this.io = null;
9191 }
9192 }
9193
9194 public void setFieldValue(_Fields field, Object value) {
9195 switch (field) {
9196 case IO:
9197 if (value == null) {
9198 unsetIo();
9199 } else {
9200 setIo((IOError)value);
9201 }
9202 break;
9203
9204 }
9205 }
9206
9207 public void setFieldValue(int fieldID, Object value) {
9208 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9209 }
9210
9211 public Object getFieldValue(_Fields field) {
9212 switch (field) {
9213 case IO:
9214 return getIo();
9215
9216 }
9217 throw new IllegalStateException();
9218 }
9219
9220 public Object getFieldValue(int fieldId) {
9221 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9222 }
9223
9224
9225 public boolean isSet(_Fields field) {
9226 switch (field) {
9227 case IO:
9228 return isSetIo();
9229 }
9230 throw new IllegalStateException();
9231 }
9232
9233 public boolean isSet(int fieldID) {
9234 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9235 }
9236
9237 @Override
9238 public boolean equals(Object that) {
9239 if (that == null)
9240 return false;
9241 if (that instanceof deleteTable_result)
9242 return this.equals((deleteTable_result)that);
9243 return false;
9244 }
9245
9246 public boolean equals(deleteTable_result that) {
9247 if (that == null)
9248 return false;
9249
9250 boolean this_present_io = true && this.isSetIo();
9251 boolean that_present_io = true && that.isSetIo();
9252 if (this_present_io || that_present_io) {
9253 if (!(this_present_io && that_present_io))
9254 return false;
9255 if (!this.io.equals(that.io))
9256 return false;
9257 }
9258
9259 return true;
9260 }
9261
9262 @Override
9263 public int hashCode() {
9264 HashCodeBuilder builder = new HashCodeBuilder();
9265
9266 boolean present_io = true && (isSetIo());
9267 builder.append(present_io);
9268 if (present_io)
9269 builder.append(io);
9270
9271 return builder.toHashCode();
9272 }
9273
9274 public int compareTo(deleteTable_result other) {
9275 if (!getClass().equals(other.getClass())) {
9276 return getClass().getName().compareTo(other.getClass().getName());
9277 }
9278
9279 int lastComparison = 0;
9280 deleteTable_result typedOther = (deleteTable_result)other;
9281
9282 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
9283 if (lastComparison != 0) {
9284 return lastComparison;
9285 }
9286 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
9287 if (lastComparison != 0) {
9288 return lastComparison;
9289 }
9290 return 0;
9291 }
9292
9293 public void read(TProtocol iprot) throws TException {
9294 TField field;
9295 iprot.readStructBegin();
9296 while (true)
9297 {
9298 field = iprot.readFieldBegin();
9299 if (field.type == TType.STOP) {
9300 break;
9301 }
9302 _Fields fieldId = _Fields.findByThriftId(field.id);
9303 if (fieldId == null) {
9304 TProtocolUtil.skip(iprot, field.type);
9305 } else {
9306 switch (fieldId) {
9307 case IO:
9308 if (field.type == TType.STRUCT) {
9309 this.io = new IOError();
9310 this.io.read(iprot);
9311 } else {
9312 TProtocolUtil.skip(iprot, field.type);
9313 }
9314 break;
9315 }
9316 iprot.readFieldEnd();
9317 }
9318 }
9319 iprot.readStructEnd();
9320
9321
9322 validate();
9323 }
9324
9325 public void write(TProtocol oprot) throws TException {
9326 oprot.writeStructBegin(STRUCT_DESC);
9327
9328 if (this.isSetIo()) {
9329 oprot.writeFieldBegin(IO_FIELD_DESC);
9330 this.io.write(oprot);
9331 oprot.writeFieldEnd();
9332 }
9333 oprot.writeFieldStop();
9334 oprot.writeStructEnd();
9335 }
9336
9337 @Override
9338 public String toString() {
9339 StringBuilder sb = new StringBuilder("deleteTable_result(");
9340 boolean first = true;
9341
9342 sb.append("io:");
9343 if (this.io == null) {
9344 sb.append("null");
9345 } else {
9346 sb.append(this.io);
9347 }
9348 first = false;
9349 sb.append(")");
9350 return sb.toString();
9351 }
9352
9353 public void validate() throws TException {
9354
9355 }
9356
9357 }
9358
9359 public static class get_args implements TBase<get_args._Fields>, java.io.Serializable, Cloneable, Comparable<get_args> {
9360 private static final TStruct STRUCT_DESC = new TStruct("get_args");
9361
9362 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
9363 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
9364 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
9365
9366
9367
9368
9369 public byte[] tableName;
9370
9371
9372
9373 public byte[] row;
9374
9375
9376
9377 public byte[] column;
9378
9379
9380 public enum _Fields implements TFieldIdEnum {
9381
9382
9383
9384 TABLE_NAME((short)1, "tableName"),
9385
9386
9387
9388 ROW((short)2, "row"),
9389
9390
9391
9392 COLUMN((short)3, "column");
9393
9394 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9395 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9396
9397 static {
9398 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9399 byId.put((int)field._thriftId, field);
9400 byName.put(field.getFieldName(), field);
9401 }
9402 }
9403
9404
9405
9406
9407 public static _Fields findByThriftId(int fieldId) {
9408 return byId.get(fieldId);
9409 }
9410
9411
9412
9413
9414
9415 public static _Fields findByThriftIdOrThrow(int fieldId) {
9416 _Fields fields = findByThriftId(fieldId);
9417 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9418 return fields;
9419 }
9420
9421
9422
9423
9424 public static _Fields findByName(String name) {
9425 return byName.get(name);
9426 }
9427
9428 private final short _thriftId;
9429 private final String _fieldName;
9430
9431 _Fields(short thriftId, String fieldName) {
9432 _thriftId = thriftId;
9433 _fieldName = fieldName;
9434 }
9435
9436 public short getThriftFieldId() {
9437 return _thriftId;
9438 }
9439
9440 public String getFieldName() {
9441 return _fieldName;
9442 }
9443 }
9444
9445
9446
9447 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9448 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
9449 new FieldValueMetaData(TType.STRING)));
9450 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
9451 new FieldValueMetaData(TType.STRING)));
9452 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
9453 new FieldValueMetaData(TType.STRING)));
9454 }});
9455
9456 static {
9457 FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
9458 }
9459
9460 public get_args() {
9461 }
9462
9463 public get_args(
9464 byte[] tableName,
9465 byte[] row,
9466 byte[] column)
9467 {
9468 this();
9469 this.tableName = tableName;
9470 this.row = row;
9471 this.column = column;
9472 }
9473
9474
9475
9476
9477 public get_args(get_args other) {
9478 if (other.isSetTableName()) {
9479 this.tableName = other.tableName;
9480 }
9481 if (other.isSetRow()) {
9482 this.row = other.row;
9483 }
9484 if (other.isSetColumn()) {
9485 this.column = other.column;
9486 }
9487 }
9488
9489 public get_args deepCopy() {
9490 return new get_args(this);
9491 }
9492
9493 @Deprecated
9494 public get_args clone() {
9495 return new get_args(this);
9496 }
9497
9498
9499
9500
9501 public byte[] getTableName() {
9502 return this.tableName;
9503 }
9504
9505
9506
9507
9508 public get_args setTableName(byte[] tableName) {
9509 this.tableName = tableName;
9510 return this;
9511 }
9512
9513 public void unsetTableName() {
9514 this.tableName = null;
9515 }
9516
9517
9518 public boolean isSetTableName() {
9519 return this.tableName != null;
9520 }
9521
9522 public void setTableNameIsSet(boolean value) {
9523 if (!value) {
9524 this.tableName = null;
9525 }
9526 }
9527
9528
9529
9530
9531 public byte[] getRow() {
9532 return this.row;
9533 }
9534
9535
9536
9537
9538 public get_args setRow(byte[] row) {
9539 this.row = row;
9540 return this;
9541 }
9542
9543 public void unsetRow() {
9544 this.row = null;
9545 }
9546
9547
9548 public boolean isSetRow() {
9549 return this.row != null;
9550 }
9551
9552 public void setRowIsSet(boolean value) {
9553 if (!value) {
9554 this.row = null;
9555 }
9556 }
9557
9558
9559
9560
9561 public byte[] getColumn() {
9562 return this.column;
9563 }
9564
9565
9566
9567
9568 public get_args setColumn(byte[] column) {
9569 this.column = column;
9570 return this;
9571 }
9572
9573 public void unsetColumn() {
9574 this.column = null;
9575 }
9576
9577
9578 public boolean isSetColumn() {
9579 return this.column != null;
9580 }
9581
9582 public void setColumnIsSet(boolean value) {
9583 if (!value) {
9584 this.column = null;
9585 }
9586 }
9587
9588 public void setFieldValue(_Fields field, Object value) {
9589 switch (field) {
9590 case TABLE_NAME:
9591 if (value == null) {
9592 unsetTableName();
9593 } else {
9594 setTableName((byte[])value);
9595 }
9596 break;
9597
9598 case ROW:
9599 if (value == null) {
9600 unsetRow();
9601 } else {
9602 setRow((byte[])value);
9603 }
9604 break;
9605
9606 case COLUMN:
9607 if (value == null) {
9608 unsetColumn();
9609 } else {
9610 setColumn((byte[])value);
9611 }
9612 break;
9613
9614 }
9615 }
9616
9617 public void setFieldValue(int fieldID, Object value) {
9618 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9619 }
9620
9621 public Object getFieldValue(_Fields field) {
9622 switch (field) {
9623 case TABLE_NAME:
9624 return getTableName();
9625
9626 case ROW:
9627 return getRow();
9628
9629 case COLUMN:
9630 return getColumn();
9631
9632 }
9633 throw new IllegalStateException();
9634 }
9635
9636 public Object getFieldValue(int fieldId) {
9637 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9638 }
9639
9640
9641 public boolean isSet(_Fields field) {
9642 switch (field) {
9643 case TABLE_NAME:
9644 return isSetTableName();
9645 case ROW:
9646 return isSetRow();
9647 case COLUMN:
9648 return isSetColumn();
9649 }
9650 throw new IllegalStateException();
9651 }
9652
9653 public boolean isSet(int fieldID) {
9654 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9655 }
9656
9657 @Override
9658 public boolean equals(Object that) {
9659 if (that == null)
9660 return false;
9661 if (that instanceof get_args)
9662 return this.equals((get_args)that);
9663 return false;
9664 }
9665
9666 public boolean equals(get_args that) {
9667 if (that == null)
9668 return false;
9669
9670 boolean this_present_tableName = true && this.isSetTableName();
9671 boolean that_present_tableName = true && that.isSetTableName();
9672 if (this_present_tableName || that_present_tableName) {
9673 if (!(this_present_tableName && that_present_tableName))
9674 return false;
9675 if (!java.util.Arrays.equals(this.tableName, that.tableName))
9676 return false;
9677 }
9678
9679 boolean this_present_row = true && this.isSetRow();
9680 boolean that_present_row = true && that.isSetRow();
9681 if (this_present_row || that_present_row) {
9682 if (!(this_present_row && that_present_row))
9683 return false;
9684 if (!java.util.Arrays.equals(this.row, that.row))
9685 return false;
9686 }
9687
9688 boolean this_present_column = true && this.isSetColumn();
9689 boolean that_present_column = true && that.isSetColumn();
9690 if (this_present_column || that_present_column) {
9691 if (!(this_present_column && that_present_column))
9692 return false;
9693 if (!java.util.Arrays.equals(this.column, that.column))
9694 return false;
9695 }
9696
9697 return true;
9698 }
9699
9700 @Override
9701 public int hashCode() {
9702 HashCodeBuilder builder = new HashCodeBuilder();
9703
9704 boolean present_tableName = true && (isSetTableName());
9705 builder.append(present_tableName);
9706 if (present_tableName)
9707 builder.append(tableName);
9708
9709 boolean present_row = true && (isSetRow());
9710 builder.append(present_row);
9711 if (present_row)
9712 builder.append(row);
9713
9714 boolean present_column = true && (isSetColumn());
9715 builder.append(present_column);
9716 if (present_column)
9717 builder.append(column);
9718
9719 return builder.toHashCode();
9720 }
9721
9722 public int compareTo(get_args other) {
9723 if (!getClass().equals(other.getClass())) {
9724 return getClass().getName().compareTo(other.getClass().getName());
9725 }
9726
9727 int lastComparison = 0;
9728 get_args typedOther = (get_args)other;
9729
9730 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
9731 if (lastComparison != 0) {
9732 return lastComparison;
9733 }
9734 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
9735 if (lastComparison != 0) {
9736 return lastComparison;
9737 }
9738 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
9739 if (lastComparison != 0) {
9740 return lastComparison;
9741 }
9742 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
9743 if (lastComparison != 0) {
9744 return lastComparison;
9745 }
9746 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
9747 if (lastComparison != 0) {
9748 return lastComparison;
9749 }
9750 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
9751 if (lastComparison != 0) {
9752 return lastComparison;
9753 }
9754 return 0;
9755 }
9756
9757 public void read(TProtocol iprot) throws TException {
9758 TField field;
9759 iprot.readStructBegin();
9760 while (true)
9761 {
9762 field = iprot.readFieldBegin();
9763 if (field.type == TType.STOP) {
9764 break;
9765 }
9766 _Fields fieldId = _Fields.findByThriftId(field.id);
9767 if (fieldId == null) {
9768 TProtocolUtil.skip(iprot, field.type);
9769 } else {
9770 switch (fieldId) {
9771 case TABLE_NAME:
9772 if (field.type == TType.STRING) {
9773 this.tableName = iprot.readBinary();
9774 } else {
9775 TProtocolUtil.skip(iprot, field.type);
9776 }
9777 break;
9778 case ROW:
9779 if (field.type == TType.STRING) {
9780 this.row = iprot.readBinary();
9781 } else {
9782 TProtocolUtil.skip(iprot, field.type);
9783 }
9784 break;
9785 case COLUMN:
9786 if (field.type == TType.STRING) {
9787 this.column = iprot.readBinary();
9788 } else {
9789 TProtocolUtil.skip(iprot, field.type);
9790 }
9791 break;
9792 }
9793 iprot.readFieldEnd();
9794 }
9795 }
9796 iprot.readStructEnd();
9797
9798
9799 validate();
9800 }
9801
9802 public void write(TProtocol oprot) throws TException {
9803 validate();
9804
9805 oprot.writeStructBegin(STRUCT_DESC);
9806 if (this.tableName != null) {
9807 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
9808 oprot.writeBinary(this.tableName);
9809 oprot.writeFieldEnd();
9810 }
9811 if (this.row != null) {
9812 oprot.writeFieldBegin(ROW_FIELD_DESC);
9813 oprot.writeBinary(this.row);
9814 oprot.writeFieldEnd();
9815 }
9816 if (this.column != null) {
9817 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
9818 oprot.writeBinary(this.column);
9819 oprot.writeFieldEnd();
9820 }
9821 oprot.writeFieldStop();
9822 oprot.writeStructEnd();
9823 }
9824
9825 @Override
9826 public String toString() {
9827 StringBuilder sb = new StringBuilder("get_args(");
9828 boolean first = true;
9829
9830 sb.append("tableName:");
9831 if (this.tableName == null) {
9832 sb.append("null");
9833 } else {
9834 sb.append(this.tableName);
9835 }
9836 first = false;
9837 if (!first) sb.append(", ");
9838 sb.append("row:");
9839 if (this.row == null) {
9840 sb.append("null");
9841 } else {
9842 sb.append(this.row);
9843 }
9844 first = false;
9845 if (!first) sb.append(", ");
9846 sb.append("column:");
9847 if (this.column == null) {
9848 sb.append("null");
9849 } else {
9850 sb.append(this.column);
9851 }
9852 first = false;
9853 sb.append(")");
9854 return sb.toString();
9855 }
9856
9857 public void validate() throws TException {
9858
9859 }
9860
9861 }
9862
9863 public static class get_result implements TBase<get_result._Fields>, java.io.Serializable, Cloneable, Comparable<get_result> {
9864 private static final TStruct STRUCT_DESC = new TStruct("get_result");
9865
9866 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
9867 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
9868
9869 public List<TCell> success;
9870 public IOError io;
9871
9872
9873 public enum _Fields implements TFieldIdEnum {
9874 SUCCESS((short)0, "success"),
9875 IO((short)1, "io");
9876
9877 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9878 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9879
9880 static {
9881 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9882 byId.put((int)field._thriftId, field);
9883 byName.put(field.getFieldName(), field);
9884 }
9885 }
9886
9887
9888
9889
9890 public static _Fields findByThriftId(int fieldId) {
9891 return byId.get(fieldId);
9892 }
9893
9894
9895
9896
9897
9898 public static _Fields findByThriftIdOrThrow(int fieldId) {
9899 _Fields fields = findByThriftId(fieldId);
9900 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9901 return fields;
9902 }
9903
9904
9905
9906
9907 public static _Fields findByName(String name) {
9908 return byName.get(name);
9909 }
9910
9911 private final short _thriftId;
9912 private final String _fieldName;
9913
9914 _Fields(short thriftId, String fieldName) {
9915 _thriftId = thriftId;
9916 _fieldName = fieldName;
9917 }
9918
9919 public short getThriftFieldId() {
9920 return _thriftId;
9921 }
9922
9923 public String getFieldName() {
9924 return _fieldName;
9925 }
9926 }
9927
9928
9929
9930 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9931 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
9932 new ListMetaData(TType.LIST,
9933 new StructMetaData(TType.STRUCT, TCell.class))));
9934 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
9935 new FieldValueMetaData(TType.STRUCT)));
9936 }});
9937
9938 static {
9939 FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
9940 }
9941
9942 public get_result() {
9943 }
9944
9945 public get_result(
9946 List<TCell> success,
9947 IOError io)
9948 {
9949 this();
9950 this.success = success;
9951 this.io = io;
9952 }
9953
9954
9955
9956
9957 public get_result(get_result other) {
9958 if (other.isSetSuccess()) {
9959 List<TCell> __this__success = new ArrayList<TCell>();
9960 for (TCell other_element : other.success) {
9961 __this__success.add(new TCell(other_element));
9962 }
9963 this.success = __this__success;
9964 }
9965 if (other.isSetIo()) {
9966 this.io = new IOError(other.io);
9967 }
9968 }
9969
9970 public get_result deepCopy() {
9971 return new get_result(this);
9972 }
9973
9974 @Deprecated
9975 public get_result clone() {
9976 return new get_result(this);
9977 }
9978
9979 public int getSuccessSize() {
9980 return (this.success == null) ? 0 : this.success.size();
9981 }
9982
9983 public java.util.Iterator<TCell> getSuccessIterator() {
9984 return (this.success == null) ? null : this.success.iterator();
9985 }
9986
9987 public void addToSuccess(TCell elem) {
9988 if (this.success == null) {
9989 this.success = new ArrayList<TCell>();
9990 }
9991 this.success.add(elem);
9992 }
9993
9994 public List<TCell> getSuccess() {
9995 return this.success;
9996 }
9997
9998 public get_result setSuccess(List<TCell> success) {
9999 this.success = success;
10000 return this;
10001 }
10002
10003 public void unsetSuccess() {
10004 this.success = null;
10005 }
10006
10007
10008 public boolean isSetSuccess() {
10009 return this.success != null;
10010 }
10011
10012 public void setSuccessIsSet(boolean value) {
10013 if (!value) {
10014 this.success = null;
10015 }
10016 }
10017
10018 public IOError getIo() {
10019 return this.io;
10020 }
10021
10022 public get_result setIo(IOError io) {
10023 this.io = io;
10024 return this;
10025 }
10026
10027 public void unsetIo() {
10028 this.io = null;
10029 }
10030
10031
10032 public boolean isSetIo() {
10033 return this.io != null;
10034 }
10035
10036 public void setIoIsSet(boolean value) {
10037 if (!value) {
10038 this.io = null;
10039 }
10040 }
10041
10042 public void setFieldValue(_Fields field, Object value) {
10043 switch (field) {
10044 case SUCCESS:
10045 if (value == null) {
10046 unsetSuccess();
10047 } else {
10048 setSuccess((List<TCell>)value);
10049 }
10050 break;
10051
10052 case IO:
10053 if (value == null) {
10054 unsetIo();
10055 } else {
10056 setIo((IOError)value);
10057 }
10058 break;
10059
10060 }
10061 }
10062
10063 public void setFieldValue(int fieldID, Object value) {
10064 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
10065 }
10066
10067 public Object getFieldValue(_Fields field) {
10068 switch (field) {
10069 case SUCCESS:
10070 return getSuccess();
10071
10072 case IO:
10073 return getIo();
10074
10075 }
10076 throw new IllegalStateException();
10077 }
10078
10079 public Object getFieldValue(int fieldId) {
10080 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
10081 }
10082
10083
10084 public boolean isSet(_Fields field) {
10085 switch (field) {
10086 case SUCCESS:
10087 return isSetSuccess();
10088 case IO:
10089 return isSetIo();
10090 }
10091 throw new IllegalStateException();
10092 }
10093
10094 public boolean isSet(int fieldID) {
10095 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
10096 }
10097
10098 @Override
10099 public boolean equals(Object that) {
10100 if (that == null)
10101 return false;
10102 if (that instanceof get_result)
10103 return this.equals((get_result)that);
10104 return false;
10105 }
10106
10107 public boolean equals(get_result that) {
10108 if (that == null)
10109 return false;
10110
10111 boolean this_present_success = true && this.isSetSuccess();
10112 boolean that_present_success = true && that.isSetSuccess();
10113 if (this_present_success || that_present_success) {
10114 if (!(this_present_success && that_present_success))
10115 return false;
10116 if (!this.success.equals(that.success))
10117 return false;
10118 }
10119
10120 boolean this_present_io = true && this.isSetIo();
10121 boolean that_present_io = true && that.isSetIo();
10122 if (this_present_io || that_present_io) {
10123 if (!(this_present_io && that_present_io))
10124 return false;
10125 if (!this.io.equals(that.io))
10126 return false;
10127 }
10128
10129 return true;
10130 }
10131
10132 @Override
10133 public int hashCode() {
10134 HashCodeBuilder builder = new HashCodeBuilder();
10135
10136 boolean present_success = true && (isSetSuccess());
10137 builder.append(present_success);
10138 if (present_success)
10139 builder.append(success);
10140
10141 boolean present_io = true && (isSetIo());
10142 builder.append(present_io);
10143 if (present_io)
10144 builder.append(io);
10145
10146 return builder.toHashCode();
10147 }
10148
10149 public int compareTo(get_result other) {
10150 if (!getClass().equals(other.getClass())) {
10151 return getClass().getName().compareTo(other.getClass().getName());
10152 }
10153
10154 int lastComparison = 0;
10155 get_result typedOther = (get_result)other;
10156
10157 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
10158 if (lastComparison != 0) {
10159 return lastComparison;
10160 }
10161 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
10162 if (lastComparison != 0) {
10163 return lastComparison;
10164 }
10165 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
10166 if (lastComparison != 0) {
10167 return lastComparison;
10168 }
10169 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
10170 if (lastComparison != 0) {
10171 return lastComparison;
10172 }
10173 return 0;
10174 }
10175
10176 public void read(TProtocol iprot) throws TException {
10177 TField field;
10178 iprot.readStructBegin();
10179 while (true)
10180 {
10181 field = iprot.readFieldBegin();
10182 if (field.type == TType.STOP) {
10183 break;
10184 }
10185 _Fields fieldId = _Fields.findByThriftId(field.id);
10186 if (fieldId == null) {
10187 TProtocolUtil.skip(iprot, field.type);
10188 } else {
10189 switch (fieldId) {
10190 case SUCCESS:
10191 if (field.type == TType.LIST) {
10192 {
10193 TList _list26 = iprot.readListBegin();
10194 this.success = new ArrayList<TCell>(_list26.size);
10195 for (int _i27 = 0; _i27 < _list26.size; ++_i27)
10196 {
10197 TCell _elem28;
10198 _elem28 = new TCell();
10199 _elem28.read(iprot);
10200 this.success.add(_elem28);
10201 }
10202 iprot.readListEnd();
10203 }
10204 } else {
10205 TProtocolUtil.skip(iprot, field.type);
10206 }
10207 break;
10208 case IO:
10209 if (field.type == TType.STRUCT) {
10210 this.io = new IOError();
10211 this.io.read(iprot);
10212 } else {
10213 TProtocolUtil.skip(iprot, field.type);
10214 }
10215 break;
10216 }
10217 iprot.readFieldEnd();
10218 }
10219 }
10220 iprot.readStructEnd();
10221
10222
10223 validate();
10224 }
10225
10226 public void write(TProtocol oprot) throws TException {
10227 oprot.writeStructBegin(STRUCT_DESC);
10228
10229 if (this.isSetSuccess()) {
10230 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
10231 {
10232 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
10233 for (TCell _iter29 : this.success)
10234 {
10235 _iter29.write(oprot);
10236 }
10237 oprot.writeListEnd();
10238 }
10239 oprot.writeFieldEnd();
10240 } else if (this.isSetIo()) {
10241 oprot.writeFieldBegin(IO_FIELD_DESC);
10242 this.io.write(oprot);
10243 oprot.writeFieldEnd();
10244 }
10245 oprot.writeFieldStop();
10246 oprot.writeStructEnd();
10247 }
10248
10249 @Override
10250 public String toString() {
10251 StringBuilder sb = new StringBuilder("get_result(");
10252 boolean first = true;
10253
10254 sb.append("success:");
10255 if (this.success == null) {
10256 sb.append("null");
10257 } else {
10258 sb.append(this.success);
10259 }
10260 first = false;
10261 if (!first) sb.append(", ");
10262 sb.append("io:");
10263 if (this.io == null) {
10264 sb.append("null");
10265 } else {
10266 sb.append(this.io);
10267 }
10268 first = false;
10269 sb.append(")");
10270 return sb.toString();
10271 }
10272
10273 public void validate() throws TException {
10274
10275 }
10276
10277 }
10278
10279 public static class getVer_args implements TBase<getVer_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_args> {
10280 private static final TStruct STRUCT_DESC = new TStruct("getVer_args");
10281
10282 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
10283 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
10284 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
10285 private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)4);
10286
10287
10288
10289
10290 public byte[] tableName;
10291
10292
10293
10294 public byte[] row;
10295
10296
10297
10298 public byte[] column;
10299
10300
10301
10302 public int numVersions;
10303
10304
10305 public enum _Fields implements TFieldIdEnum {
10306
10307
10308
10309 TABLE_NAME((short)1, "tableName"),
10310
10311
10312
10313 ROW((short)2, "row"),
10314
10315
10316
10317 COLUMN((short)3, "column"),
10318
10319
10320
10321 NUM_VERSIONS((short)4, "numVersions");
10322
10323 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
10324 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10325
10326 static {
10327 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10328 byId.put((int)field._thriftId, field);
10329 byName.put(field.getFieldName(), field);
10330 }
10331 }
10332
10333
10334
10335
10336 public static _Fields findByThriftId(int fieldId) {
10337 return byId.get(fieldId);
10338 }
10339
10340
10341
10342
10343
10344 public static _Fields findByThriftIdOrThrow(int fieldId) {
10345 _Fields fields = findByThriftId(fieldId);
10346 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10347 return fields;
10348 }
10349
10350
10351
10352
10353 public static _Fields findByName(String name) {
10354 return byName.get(name);
10355 }
10356
10357 private final short _thriftId;
10358 private final String _fieldName;
10359
10360 _Fields(short thriftId, String fieldName) {
10361 _thriftId = thriftId;
10362 _fieldName = fieldName;
10363 }
10364
10365 public short getThriftFieldId() {
10366 return _thriftId;
10367 }
10368
10369 public String getFieldName() {
10370 return _fieldName;
10371 }
10372 }
10373
10374
10375 private static final int __NUMVERSIONS_ISSET_ID = 0;
10376 private BitSet __isset_bit_vector = new BitSet(1);
10377
10378 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
10379 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
10380 new FieldValueMetaData(TType.STRING)));
10381 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
10382 new FieldValueMetaData(TType.STRING)));
10383 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
10384 new FieldValueMetaData(TType.STRING)));
10385 put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT,
10386 new FieldValueMetaData(TType.I32)));
10387 }});
10388
10389 static {
10390 FieldMetaData.addStructMetaDataMap(getVer_args.class, metaDataMap);
10391 }
10392
10393 public getVer_args() {
10394 }
10395
10396 public getVer_args(
10397 byte[] tableName,
10398 byte[] row,
10399 byte[] column,
10400 int numVersions)
10401 {
10402 this();
10403 this.tableName = tableName;
10404 this.row = row;
10405 this.column = column;
10406 this.numVersions = numVersions;
10407 setNumVersionsIsSet(true);
10408 }
10409
10410
10411
10412
10413 public getVer_args(getVer_args other) {
10414 __isset_bit_vector.clear();
10415 __isset_bit_vector.or(other.__isset_bit_vector);
10416 if (other.isSetTableName()) {
10417 this.tableName = other.tableName;
10418 }
10419 if (other.isSetRow()) {
10420 this.row = other.row;
10421 }
10422 if (other.isSetColumn()) {
10423 this.column = other.column;
10424 }
10425 this.numVersions = other.numVersions;
10426 }
10427
10428 public getVer_args deepCopy() {
10429 return new getVer_args(this);
10430 }
10431
10432 @Deprecated
10433 public getVer_args clone() {
10434 return new getVer_args(this);
10435 }
10436
10437
10438
10439
10440 public byte[] getTableName() {
10441 return this.tableName;
10442 }
10443
10444
10445
10446
10447 public getVer_args setTableName(byte[] tableName) {
10448 this.tableName = tableName;
10449 return this;
10450 }
10451
10452 public void unsetTableName() {
10453 this.tableName = null;
10454 }
10455
10456
10457 public boolean isSetTableName() {
10458 return this.tableName != null;
10459 }
10460
10461 public void setTableNameIsSet(boolean value) {
10462 if (!value) {
10463 this.tableName = null;
10464 }
10465 }
10466
10467
10468
10469
10470 public byte[] getRow() {
10471 return this.row;
10472 }
10473
10474
10475
10476
10477 public getVer_args setRow(byte[] row) {
10478 this.row = row;
10479 return this;
10480 }
10481
10482 public void unsetRow() {
10483 this.row = null;
10484 }
10485
10486
10487 public boolean isSetRow() {
10488 return this.row != null;
10489 }
10490
10491 public void setRowIsSet(boolean value) {
10492 if (!value) {
10493 this.row = null;
10494 }
10495 }
10496
10497
10498
10499
10500 public byte[] getColumn() {
10501 return this.column;
10502 }
10503
10504
10505
10506
10507 public getVer_args setColumn(byte[] column) {
10508 this.column = column;
10509 return this;
10510 }
10511
10512 public void unsetColumn() {
10513 this.column = null;
10514 }
10515
10516
10517 public boolean isSetColumn() {
10518 return this.column != null;
10519 }
10520
10521 public void setColumnIsSet(boolean value) {
10522 if (!value) {
10523 this.column = null;
10524 }
10525 }
10526
10527
10528
10529
10530 public int getNumVersions() {
10531 return this.numVersions;
10532 }
10533
10534
10535
10536
10537 public getVer_args setNumVersions(int numVersions) {
10538 this.numVersions = numVersions;
10539 setNumVersionsIsSet(true);
10540 return this;
10541 }
10542
10543 public void unsetNumVersions() {
10544 __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID);
10545 }
10546
10547
10548 public boolean isSetNumVersions() {
10549 return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID);
10550 }
10551
10552 public void setNumVersionsIsSet(boolean value) {
10553 __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value);
10554 }
10555
10556 public void setFieldValue(_Fields field, Object value) {
10557 switch (field) {
10558 case TABLE_NAME:
10559 if (value == null) {
10560 unsetTableName();
10561 } else {
10562 setTableName((byte[])value);
10563 }
10564 break;
10565
10566 case ROW:
10567 if (value == null) {
10568 unsetRow();
10569 } else {
10570 setRow((byte[])value);
10571 }
10572 break;
10573
10574 case COLUMN:
10575 if (value == null) {
10576 unsetColumn();
10577 } else {
10578 setColumn((byte[])value);
10579 }
10580 break;
10581
10582 case NUM_VERSIONS:
10583 if (value == null) {
10584 unsetNumVersions();
10585 } else {
10586 setNumVersions((Integer)value);
10587 }
10588 break;
10589
10590 }
10591 }
10592
10593 public void setFieldValue(int fieldID, Object value) {
10594 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
10595 }
10596
10597 public Object getFieldValue(_Fields field) {
10598 switch (field) {
10599 case TABLE_NAME:
10600 return getTableName();
10601
10602 case ROW:
10603 return getRow();
10604
10605 case COLUMN:
10606 return getColumn();
10607
10608 case NUM_VERSIONS:
10609 return new Integer(getNumVersions());
10610
10611 }
10612 throw new IllegalStateException();
10613 }
10614
10615 public Object getFieldValue(int fieldId) {
10616 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
10617 }
10618
10619
10620 public boolean isSet(_Fields field) {
10621 switch (field) {
10622 case TABLE_NAME:
10623 return isSetTableName();
10624 case ROW:
10625 return isSetRow();
10626 case COLUMN:
10627 return isSetColumn();
10628 case NUM_VERSIONS:
10629 return isSetNumVersions();
10630 }
10631 throw new IllegalStateException();
10632 }
10633
10634 public boolean isSet(int fieldID) {
10635 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
10636 }
10637
10638 @Override
10639 public boolean equals(Object that) {
10640 if (that == null)
10641 return false;
10642 if (that instanceof getVer_args)
10643 return this.equals((getVer_args)that);
10644 return false;
10645 }
10646
10647 public boolean equals(getVer_args that) {
10648 if (that == null)
10649 return false;
10650
10651 boolean this_present_tableName = true && this.isSetTableName();
10652 boolean that_present_tableName = true && that.isSetTableName();
10653 if (this_present_tableName || that_present_tableName) {
10654 if (!(this_present_tableName && that_present_tableName))
10655 return false;
10656 if (!java.util.Arrays.equals(this.tableName, that.tableName))
10657 return false;
10658 }
10659
10660 boolean this_present_row = true && this.isSetRow();
10661 boolean that_present_row = true && that.isSetRow();
10662 if (this_present_row || that_present_row) {
10663 if (!(this_present_row && that_present_row))
10664 return false;
10665 if (!java.util.Arrays.equals(this.row, that.row))
10666 return false;
10667 }
10668
10669 boolean this_present_column = true && this.isSetColumn();
10670 boolean that_present_column = true && that.isSetColumn();
10671 if (this_present_column || that_present_column) {
10672 if (!(this_present_column && that_present_column))
10673 return false;
10674 if (!java.util.Arrays.equals(this.column, that.column))
10675 return false;
10676 }
10677
10678 boolean this_present_numVersions = true;
10679 boolean that_present_numVersions = true;
10680 if (this_present_numVersions || that_present_numVersions) {
10681 if (!(this_present_numVersions && that_present_numVersions))
10682 return false;
10683 if (this.numVersions != that.numVersions)
10684 return false;
10685 }
10686
10687 return true;
10688 }
10689
10690 @Override
10691 public int hashCode() {
10692 HashCodeBuilder builder = new HashCodeBuilder();
10693
10694 boolean present_tableName = true && (isSetTableName());
10695 builder.append(present_tableName);
10696 if (present_tableName)
10697 builder.append(tableName);
10698
10699 boolean present_row = true && (isSetRow());
10700 builder.append(present_row);
10701 if (present_row)
10702 builder.append(row);
10703
10704 boolean present_column = true && (isSetColumn());
10705 builder.append(present_column);
10706 if (present_column)
10707 builder.append(column);
10708
10709 boolean present_numVersions = true;
10710 builder.append(present_numVersions);
10711 if (present_numVersions)
10712 builder.append(numVersions);
10713
10714 return builder.toHashCode();
10715 }
10716
10717 public int compareTo(getVer_args other) {
10718 if (!getClass().equals(other.getClass())) {
10719 return getClass().getName().compareTo(other.getClass().getName());
10720 }
10721
10722 int lastComparison = 0;
10723 getVer_args typedOther = (getVer_args)other;
10724
10725 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
10726 if (lastComparison != 0) {
10727 return lastComparison;
10728 }
10729 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
10730 if (lastComparison != 0) {
10731 return lastComparison;
10732 }
10733 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
10734 if (lastComparison != 0) {
10735 return lastComparison;
10736 }
10737 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
10738 if (lastComparison != 0) {
10739 return lastComparison;
10740 }
10741 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
10742 if (lastComparison != 0) {
10743 return lastComparison;
10744 }
10745 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
10746 if (lastComparison != 0) {
10747 return lastComparison;
10748 }
10749 lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(isSetNumVersions());
10750 if (lastComparison != 0) {
10751 return lastComparison;
10752 }
10753 lastComparison = TBaseHelper.compareTo(numVersions, typedOther.numVersions);
10754 if (lastComparison != 0) {
10755 return lastComparison;
10756 }
10757 return 0;
10758 }
10759
10760 public void read(TProtocol iprot) throws TException {
10761 TField field;
10762 iprot.readStructBegin();
10763 while (true)
10764 {
10765 field = iprot.readFieldBegin();
10766 if (field.type == TType.STOP) {
10767 break;
10768 }
10769 _Fields fieldId = _Fields.findByThriftId(field.id);
10770 if (fieldId == null) {
10771 TProtocolUtil.skip(iprot, field.type);
10772 } else {
10773 switch (fieldId) {
10774 case TABLE_NAME:
10775 if (field.type == TType.STRING) {
10776 this.tableName = iprot.readBinary();
10777 } else {
10778 TProtocolUtil.skip(iprot, field.type);
10779 }
10780 break;
10781 case ROW:
10782 if (field.type == TType.STRING) {
10783 this.row = iprot.readBinary();
10784 } else {
10785 TProtocolUtil.skip(iprot, field.type);
10786 }
10787 break;
10788 case COLUMN:
10789 if (field.type == TType.STRING) {
10790 this.column = iprot.readBinary();
10791 } else {
10792 TProtocolUtil.skip(iprot, field.type);
10793 }
10794 break;
10795 case NUM_VERSIONS:
10796 if (field.type == TType.I32) {
10797 this.numVersions = iprot.readI32();
10798 setNumVersionsIsSet(true);
10799 } else {
10800 TProtocolUtil.skip(iprot, field.type);
10801 }
10802 break;
10803 }
10804 iprot.readFieldEnd();
10805 }
10806 }
10807 iprot.readStructEnd();
10808
10809
10810 validate();
10811 }
10812
10813 public void write(TProtocol oprot) throws TException {
10814 validate();
10815
10816 oprot.writeStructBegin(STRUCT_DESC);
10817 if (this.tableName != null) {
10818 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
10819 oprot.writeBinary(this.tableName);
10820 oprot.writeFieldEnd();
10821 }
10822 if (this.row != null) {
10823 oprot.writeFieldBegin(ROW_FIELD_DESC);
10824 oprot.writeBinary(this.row);
10825 oprot.writeFieldEnd();
10826 }
10827 if (this.column != null) {
10828 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
10829 oprot.writeBinary(this.column);
10830 oprot.writeFieldEnd();
10831 }
10832 oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
10833 oprot.writeI32(this.numVersions);
10834 oprot.writeFieldEnd();
10835 oprot.writeFieldStop();
10836 oprot.writeStructEnd();
10837 }
10838
10839 @Override
10840 public String toString() {
10841 StringBuilder sb = new StringBuilder("getVer_args(");
10842 boolean first = true;
10843
10844 sb.append("tableName:");
10845 if (this.tableName == null) {
10846 sb.append("null");
10847 } else {
10848 sb.append(this.tableName);
10849 }
10850 first = false;
10851 if (!first) sb.append(", ");
10852 sb.append("row:");
10853 if (this.row == null) {
10854 sb.append("null");
10855 } else {
10856 sb.append(this.row);
10857 }
10858 first = false;
10859 if (!first) sb.append(", ");
10860 sb.append("column:");
10861 if (this.column == null) {
10862 sb.append("null");
10863 } else {
10864 sb.append(this.column);
10865 }
10866 first = false;
10867 if (!first) sb.append(", ");
10868 sb.append("numVersions:");
10869 sb.append(this.numVersions);
10870 first = false;
10871 sb.append(")");
10872 return sb.toString();
10873 }
10874
10875 public void validate() throws TException {
10876
10877 }
10878
10879 }
10880
10881 public static class getVer_result implements TBase<getVer_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_result> {
10882 private static final TStruct STRUCT_DESC = new TStruct("getVer_result");
10883
10884 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
10885 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
10886
10887 public List<TCell> success;
10888 public IOError io;
10889
10890
10891 public enum _Fields implements TFieldIdEnum {
10892 SUCCESS((short)0, "success"),
10893 IO((short)1, "io");
10894
10895 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
10896 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10897
10898 static {
10899 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10900 byId.put((int)field._thriftId, field);
10901 byName.put(field.getFieldName(), field);
10902 }
10903 }
10904
10905
10906
10907
10908 public static _Fields findByThriftId(int fieldId) {
10909 return byId.get(fieldId);
10910 }
10911
10912
10913
10914
10915
10916 public static _Fields findByThriftIdOrThrow(int fieldId) {
10917 _Fields fields = findByThriftId(fieldId);
10918 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10919 return fields;
10920 }
10921
10922
10923
10924
10925 public static _Fields findByName(String name) {
10926 return byName.get(name);
10927 }
10928
10929 private final short _thriftId;
10930 private final String _fieldName;
10931
10932 _Fields(short thriftId, String fieldName) {
10933 _thriftId = thriftId;
10934 _fieldName = fieldName;
10935 }
10936
10937 public short getThriftFieldId() {
10938 return _thriftId;
10939 }
10940
10941 public String getFieldName() {
10942 return _fieldName;
10943 }
10944 }
10945
10946
10947
10948 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
10949 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
10950 new ListMetaData(TType.LIST,
10951 new StructMetaData(TType.STRUCT, TCell.class))));
10952 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
10953 new FieldValueMetaData(TType.STRUCT)));
10954 }});
10955
10956 static {
10957 FieldMetaData.addStructMetaDataMap(getVer_result.class, metaDataMap);
10958 }
10959
10960 public getVer_result() {
10961 }
10962
10963 public getVer_result(
10964 List<TCell> success,
10965 IOError io)
10966 {
10967 this();
10968 this.success = success;
10969 this.io = io;
10970 }
10971
10972
10973
10974
10975 public getVer_result(getVer_result other) {
10976 if (other.isSetSuccess()) {
10977 List<TCell> __this__success = new ArrayList<TCell>();
10978 for (TCell other_element : other.success) {
10979 __this__success.add(new TCell(other_element));
10980 }
10981 this.success = __this__success;
10982 }
10983 if (other.isSetIo()) {
10984 this.io = new IOError(other.io);
10985 }
10986 }
10987
10988 public getVer_result deepCopy() {
10989 return new getVer_result(this);
10990 }
10991
10992 @Deprecated
10993 public getVer_result clone() {
10994 return new getVer_result(this);
10995 }
10996
10997 public int getSuccessSize() {
10998 return (this.success == null) ? 0 : this.success.size();
10999 }
11000
11001 public java.util.Iterator<TCell> getSuccessIterator() {
11002 return (this.success == null) ? null : this.success.iterator();
11003 }
11004
11005 public void addToSuccess(TCell elem) {
11006 if (this.success == null) {
11007 this.success = new ArrayList<TCell>();
11008 }
11009 this.success.add(elem);
11010 }
11011
11012 public List<TCell> getSuccess() {
11013 return this.success;
11014 }
11015
11016 public getVer_result setSuccess(List<TCell> success) {
11017 this.success = success;
11018 return this;
11019 }
11020
11021 public void unsetSuccess() {
11022 this.success = null;
11023 }
11024
11025
11026 public boolean isSetSuccess() {
11027 return this.success != null;
11028 }
11029
11030 public void setSuccessIsSet(boolean value) {
11031 if (!value) {
11032 this.success = null;
11033 }
11034 }
11035
11036 public IOError getIo() {
11037 return this.io;
11038 }
11039
11040 public getVer_result setIo(IOError io) {
11041 this.io = io;
11042 return this;
11043 }
11044
11045 public void unsetIo() {
11046 this.io = null;
11047 }
11048
11049
11050 public boolean isSetIo() {
11051 return this.io != null;
11052 }
11053
11054 public void setIoIsSet(boolean value) {
11055 if (!value) {
11056 this.io = null;
11057 }
11058 }
11059
11060 public void setFieldValue(_Fields field, Object value) {
11061 switch (field) {
11062 case SUCCESS:
11063 if (value == null) {
11064 unsetSuccess();
11065 } else {
11066 setSuccess((List<TCell>)value);
11067 }
11068 break;
11069
11070 case IO:
11071 if (value == null) {
11072 unsetIo();
11073 } else {
11074 setIo((IOError)value);
11075 }
11076 break;
11077
11078 }
11079 }
11080
11081 public void setFieldValue(int fieldID, Object value) {
11082 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
11083 }
11084
11085 public Object getFieldValue(_Fields field) {
11086 switch (field) {
11087 case SUCCESS:
11088 return getSuccess();
11089
11090 case IO:
11091 return getIo();
11092
11093 }
11094 throw new IllegalStateException();
11095 }
11096
11097 public Object getFieldValue(int fieldId) {
11098 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
11099 }
11100
11101
11102 public boolean isSet(_Fields field) {
11103 switch (field) {
11104 case SUCCESS:
11105 return isSetSuccess();
11106 case IO:
11107 return isSetIo();
11108 }
11109 throw new IllegalStateException();
11110 }
11111
11112 public boolean isSet(int fieldID) {
11113 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
11114 }
11115
11116 @Override
11117 public boolean equals(Object that) {
11118 if (that == null)
11119 return false;
11120 if (that instanceof getVer_result)
11121 return this.equals((getVer_result)that);
11122 return false;
11123 }
11124
11125 public boolean equals(getVer_result that) {
11126 if (that == null)
11127 return false;
11128
11129 boolean this_present_success = true && this.isSetSuccess();
11130 boolean that_present_success = true && that.isSetSuccess();
11131 if (this_present_success || that_present_success) {
11132 if (!(this_present_success && that_present_success))
11133 return false;
11134 if (!this.success.equals(that.success))
11135 return false;
11136 }
11137
11138 boolean this_present_io = true && this.isSetIo();
11139 boolean that_present_io = true && that.isSetIo();
11140 if (this_present_io || that_present_io) {
11141 if (!(this_present_io && that_present_io))
11142 return false;
11143 if (!this.io.equals(that.io))
11144 return false;
11145 }
11146
11147 return true;
11148 }
11149
11150 @Override
11151 public int hashCode() {
11152 HashCodeBuilder builder = new HashCodeBuilder();
11153
11154 boolean present_success = true && (isSetSuccess());
11155 builder.append(present_success);
11156 if (present_success)
11157 builder.append(success);
11158
11159 boolean present_io = true && (isSetIo());
11160 builder.append(present_io);
11161 if (present_io)
11162 builder.append(io);
11163
11164 return builder.toHashCode();
11165 }
11166
11167 public int compareTo(getVer_result other) {
11168 if (!getClass().equals(other.getClass())) {
11169 return getClass().getName().compareTo(other.getClass().getName());
11170 }
11171
11172 int lastComparison = 0;
11173 getVer_result typedOther = (getVer_result)other;
11174
11175 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
11176 if (lastComparison != 0) {
11177 return lastComparison;
11178 }
11179 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
11180 if (lastComparison != 0) {
11181 return lastComparison;
11182 }
11183 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
11184 if (lastComparison != 0) {
11185 return lastComparison;
11186 }
11187 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
11188 if (lastComparison != 0) {
11189 return lastComparison;
11190 }
11191 return 0;
11192 }
11193
11194 public void read(TProtocol iprot) throws TException {
11195 TField field;
11196 iprot.readStructBegin();
11197 while (true)
11198 {
11199 field = iprot.readFieldBegin();
11200 if (field.type == TType.STOP) {
11201 break;
11202 }
11203 _Fields fieldId = _Fields.findByThriftId(field.id);
11204 if (fieldId == null) {
11205 TProtocolUtil.skip(iprot, field.type);
11206 } else {
11207 switch (fieldId) {
11208 case SUCCESS:
11209 if (field.type == TType.LIST) {
11210 {
11211 TList _list30 = iprot.readListBegin();
11212 this.success = new ArrayList<TCell>(_list30.size);
11213 for (int _i31 = 0; _i31 < _list30.size; ++_i31)
11214 {
11215 TCell _elem32;
11216 _elem32 = new TCell();
11217 _elem32.read(iprot);
11218 this.success.add(_elem32);
11219 }
11220 iprot.readListEnd();
11221 }
11222 } else {
11223 TProtocolUtil.skip(iprot, field.type);
11224 }
11225 break;
11226 case IO:
11227 if (field.type == TType.STRUCT) {
11228 this.io = new IOError();
11229 this.io.read(iprot);
11230 } else {
11231 TProtocolUtil.skip(iprot, field.type);
11232 }
11233 break;
11234 }
11235 iprot.readFieldEnd();
11236 }
11237 }
11238 iprot.readStructEnd();
11239
11240
11241 validate();
11242 }
11243
11244 public void write(TProtocol oprot) throws TException {
11245 oprot.writeStructBegin(STRUCT_DESC);
11246
11247 if (this.isSetSuccess()) {
11248 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11249 {
11250 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
11251 for (TCell _iter33 : this.success)
11252 {
11253 _iter33.write(oprot);
11254 }
11255 oprot.writeListEnd();
11256 }
11257 oprot.writeFieldEnd();
11258 } else if (this.isSetIo()) {
11259 oprot.writeFieldBegin(IO_FIELD_DESC);
11260 this.io.write(oprot);
11261 oprot.writeFieldEnd();
11262 }
11263 oprot.writeFieldStop();
11264 oprot.writeStructEnd();
11265 }
11266
11267 @Override
11268 public String toString() {
11269 StringBuilder sb = new StringBuilder("getVer_result(");
11270 boolean first = true;
11271
11272 sb.append("success:");
11273 if (this.success == null) {
11274 sb.append("null");
11275 } else {
11276 sb.append(this.success);
11277 }
11278 first = false;
11279 if (!first) sb.append(", ");
11280 sb.append("io:");
11281 if (this.io == null) {
11282 sb.append("null");
11283 } else {
11284 sb.append(this.io);
11285 }
11286 first = false;
11287 sb.append(")");
11288 return sb.toString();
11289 }
11290
11291 public void validate() throws TException {
11292
11293 }
11294
11295 }
11296
11297 public static class getVerTs_args implements TBase<getVerTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_args> {
11298 private static final TStruct STRUCT_DESC = new TStruct("getVerTs_args");
11299
11300 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
11301 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
11302 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
11303 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
11304 private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)5);
11305
11306
11307
11308
11309 public byte[] tableName;
11310
11311
11312
11313 public byte[] row;
11314
11315
11316
11317 public byte[] column;
11318
11319
11320
11321 public long timestamp;
11322
11323
11324
11325 public int numVersions;
11326
11327
11328 public enum _Fields implements TFieldIdEnum {
11329
11330
11331
11332 TABLE_NAME((short)1, "tableName"),
11333
11334
11335
11336 ROW((short)2, "row"),
11337
11338
11339
11340 COLUMN((short)3, "column"),
11341
11342
11343
11344 TIMESTAMP((short)4, "timestamp"),
11345
11346
11347
11348 NUM_VERSIONS((short)5, "numVersions");
11349
11350 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
11351 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11352
11353 static {
11354 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11355 byId.put((int)field._thriftId, field);
11356 byName.put(field.getFieldName(), field);
11357 }
11358 }
11359
11360
11361
11362
11363 public static _Fields findByThriftId(int fieldId) {
11364 return byId.get(fieldId);
11365 }
11366
11367
11368
11369
11370
11371 public static _Fields findByThriftIdOrThrow(int fieldId) {
11372 _Fields fields = findByThriftId(fieldId);
11373 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11374 return fields;
11375 }
11376
11377
11378
11379
11380 public static _Fields findByName(String name) {
11381 return byName.get(name);
11382 }
11383
11384 private final short _thriftId;
11385 private final String _fieldName;
11386
11387 _Fields(short thriftId, String fieldName) {
11388 _thriftId = thriftId;
11389 _fieldName = fieldName;
11390 }
11391
11392 public short getThriftFieldId() {
11393 return _thriftId;
11394 }
11395
11396 public String getFieldName() {
11397 return _fieldName;
11398 }
11399 }
11400
11401
11402 private static final int __TIMESTAMP_ISSET_ID = 0;
11403 private static final int __NUMVERSIONS_ISSET_ID = 1;
11404 private BitSet __isset_bit_vector = new BitSet(2);
11405
11406 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
11407 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
11408 new FieldValueMetaData(TType.STRING)));
11409 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
11410 new FieldValueMetaData(TType.STRING)));
11411 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
11412 new FieldValueMetaData(TType.STRING)));
11413 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
11414 new FieldValueMetaData(TType.I64)));
11415 put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT,
11416 new FieldValueMetaData(TType.I32)));
11417 }});
11418
11419 static {
11420 FieldMetaData.addStructMetaDataMap(getVerTs_args.class, metaDataMap);
11421 }
11422
11423 public getVerTs_args() {
11424 }
11425
11426 public getVerTs_args(
11427 byte[] tableName,
11428 byte[] row,
11429 byte[] column,
11430 long timestamp,
11431 int numVersions)
11432 {
11433 this();
11434 this.tableName = tableName;
11435 this.row = row;
11436 this.column = column;
11437 this.timestamp = timestamp;
11438 setTimestampIsSet(true);
11439 this.numVersions = numVersions;
11440 setNumVersionsIsSet(true);
11441 }
11442
11443
11444
11445
11446 public getVerTs_args(getVerTs_args other) {
11447 __isset_bit_vector.clear();
11448 __isset_bit_vector.or(other.__isset_bit_vector);
11449 if (other.isSetTableName()) {
11450 this.tableName = other.tableName;
11451 }
11452 if (other.isSetRow()) {
11453 this.row = other.row;
11454 }
11455 if (other.isSetColumn()) {
11456 this.column = other.column;
11457 }
11458 this.timestamp = other.timestamp;
11459 this.numVersions = other.numVersions;
11460 }
11461
11462 public getVerTs_args deepCopy() {
11463 return new getVerTs_args(this);
11464 }
11465
11466 @Deprecated
11467 public getVerTs_args clone() {
11468 return new getVerTs_args(this);
11469 }
11470
11471
11472
11473
11474 public byte[] getTableName() {
11475 return this.tableName;
11476 }
11477
11478
11479
11480
11481 public getVerTs_args setTableName(byte[] tableName) {
11482 this.tableName = tableName;
11483 return this;
11484 }
11485
11486 public void unsetTableName() {
11487 this.tableName = null;
11488 }
11489
11490
11491 public boolean isSetTableName() {
11492 return this.tableName != null;
11493 }
11494
11495 public void setTableNameIsSet(boolean value) {
11496 if (!value) {
11497 this.tableName = null;
11498 }
11499 }
11500
11501
11502
11503
11504 public byte[] getRow() {
11505 return this.row;
11506 }
11507
11508
11509
11510
11511 public getVerTs_args setRow(byte[] row) {
11512 this.row = row;
11513 return this;
11514 }
11515
11516 public void unsetRow() {
11517 this.row = null;
11518 }
11519
11520
11521 public boolean isSetRow() {
11522 return this.row != null;
11523 }
11524
11525 public void setRowIsSet(boolean value) {
11526 if (!value) {
11527 this.row = null;
11528 }
11529 }
11530
11531
11532
11533
11534 public byte[] getColumn() {
11535 return this.column;
11536 }
11537
11538
11539
11540
11541 public getVerTs_args setColumn(byte[] column) {
11542 this.column = column;
11543 return this;
11544 }
11545
11546 public void unsetColumn() {
11547 this.column = null;
11548 }
11549
11550
11551 public boolean isSetColumn() {
11552 return this.column != null;
11553 }
11554
11555 public void setColumnIsSet(boolean value) {
11556 if (!value) {
11557 this.column = null;
11558 }
11559 }
11560
11561
11562
11563
11564 public long getTimestamp() {
11565 return this.timestamp;
11566 }
11567
11568
11569
11570
11571 public getVerTs_args setTimestamp(long timestamp) {
11572 this.timestamp = timestamp;
11573 setTimestampIsSet(true);
11574 return this;
11575 }
11576
11577 public void unsetTimestamp() {
11578 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
11579 }
11580
11581
11582 public boolean isSetTimestamp() {
11583 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
11584 }
11585
11586 public void setTimestampIsSet(boolean value) {
11587 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
11588 }
11589
11590
11591
11592
11593 public int getNumVersions() {
11594 return this.numVersions;
11595 }
11596
11597
11598
11599
11600 public getVerTs_args setNumVersions(int numVersions) {
11601 this.numVersions = numVersions;
11602 setNumVersionsIsSet(true);
11603 return this;
11604 }
11605
11606 public void unsetNumVersions() {
11607 __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID);
11608 }
11609
11610
11611 public boolean isSetNumVersions() {
11612 return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID);
11613 }
11614
11615 public void setNumVersionsIsSet(boolean value) {
11616 __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value);
11617 }
11618
11619 public void setFieldValue(_Fields field, Object value) {
11620 switch (field) {
11621 case TABLE_NAME:
11622 if (value == null) {
11623 unsetTableName();
11624 } else {
11625 setTableName((byte[])value);
11626 }
11627 break;
11628
11629 case ROW:
11630 if (value == null) {
11631 unsetRow();
11632 } else {
11633 setRow((byte[])value);
11634 }
11635 break;
11636
11637 case COLUMN:
11638 if (value == null) {
11639 unsetColumn();
11640 } else {
11641 setColumn((byte[])value);
11642 }
11643 break;
11644
11645 case TIMESTAMP:
11646 if (value == null) {
11647 unsetTimestamp();
11648 } else {
11649 setTimestamp((Long)value);
11650 }
11651 break;
11652
11653 case NUM_VERSIONS:
11654 if (value == null) {
11655 unsetNumVersions();
11656 } else {
11657 setNumVersions((Integer)value);
11658 }
11659 break;
11660
11661 }
11662 }
11663
11664 public void setFieldValue(int fieldID, Object value) {
11665 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
11666 }
11667
11668 public Object getFieldValue(_Fields field) {
11669 switch (field) {
11670 case TABLE_NAME:
11671 return getTableName();
11672
11673 case ROW:
11674 return getRow();
11675
11676 case COLUMN:
11677 return getColumn();
11678
11679 case TIMESTAMP:
11680 return new Long(getTimestamp());
11681
11682 case NUM_VERSIONS:
11683 return new Integer(getNumVersions());
11684
11685 }
11686 throw new IllegalStateException();
11687 }
11688
11689 public Object getFieldValue(int fieldId) {
11690 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
11691 }
11692
11693
11694 public boolean isSet(_Fields field) {
11695 switch (field) {
11696 case TABLE_NAME:
11697 return isSetTableName();
11698 case ROW:
11699 return isSetRow();
11700 case COLUMN:
11701 return isSetColumn();
11702 case TIMESTAMP:
11703 return isSetTimestamp();
11704 case NUM_VERSIONS:
11705 return isSetNumVersions();
11706 }
11707 throw new IllegalStateException();
11708 }
11709
11710 public boolean isSet(int fieldID) {
11711 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
11712 }
11713
11714 @Override
11715 public boolean equals(Object that) {
11716 if (that == null)
11717 return false;
11718 if (that instanceof getVerTs_args)
11719 return this.equals((getVerTs_args)that);
11720 return false;
11721 }
11722
11723 public boolean equals(getVerTs_args that) {
11724 if (that == null)
11725 return false;
11726
11727 boolean this_present_tableName = true && this.isSetTableName();
11728 boolean that_present_tableName = true && that.isSetTableName();
11729 if (this_present_tableName || that_present_tableName) {
11730 if (!(this_present_tableName && that_present_tableName))
11731 return false;
11732 if (!java.util.Arrays.equals(this.tableName, that.tableName))
11733 return false;
11734 }
11735
11736 boolean this_present_row = true && this.isSetRow();
11737 boolean that_present_row = true && that.isSetRow();
11738 if (this_present_row || that_present_row) {
11739 if (!(this_present_row && that_present_row))
11740 return false;
11741 if (!java.util.Arrays.equals(this.row, that.row))
11742 return false;
11743 }
11744
11745 boolean this_present_column = true && this.isSetColumn();
11746 boolean that_present_column = true && that.isSetColumn();
11747 if (this_present_column || that_present_column) {
11748 if (!(this_present_column && that_present_column))
11749 return false;
11750 if (!java.util.Arrays.equals(this.column, that.column))
11751 return false;
11752 }
11753
11754 boolean this_present_timestamp = true;
11755 boolean that_present_timestamp = true;
11756 if (this_present_timestamp || that_present_timestamp) {
11757 if (!(this_present_timestamp && that_present_timestamp))
11758 return false;
11759 if (this.timestamp != that.timestamp)
11760 return false;
11761 }
11762
11763 boolean this_present_numVersions = true;
11764 boolean that_present_numVersions = true;
11765 if (this_present_numVersions || that_present_numVersions) {
11766 if (!(this_present_numVersions && that_present_numVersions))
11767 return false;
11768 if (this.numVersions != that.numVersions)
11769 return false;
11770 }
11771
11772 return true;
11773 }
11774
11775 @Override
11776 public int hashCode() {
11777 HashCodeBuilder builder = new HashCodeBuilder();
11778
11779 boolean present_tableName = true && (isSetTableName());
11780 builder.append(present_tableName);
11781 if (present_tableName)
11782 builder.append(tableName);
11783
11784 boolean present_row = true && (isSetRow());
11785 builder.append(present_row);
11786 if (present_row)
11787 builder.append(row);
11788
11789 boolean present_column = true && (isSetColumn());
11790 builder.append(present_column);
11791 if (present_column)
11792 builder.append(column);
11793
11794 boolean present_timestamp = true;
11795 builder.append(present_timestamp);
11796 if (present_timestamp)
11797 builder.append(timestamp);
11798
11799 boolean present_numVersions = true;
11800 builder.append(present_numVersions);
11801 if (present_numVersions)
11802 builder.append(numVersions);
11803
11804 return builder.toHashCode();
11805 }
11806
11807 public int compareTo(getVerTs_args other) {
11808 if (!getClass().equals(other.getClass())) {
11809 return getClass().getName().compareTo(other.getClass().getName());
11810 }
11811
11812 int lastComparison = 0;
11813 getVerTs_args typedOther = (getVerTs_args)other;
11814
11815 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
11816 if (lastComparison != 0) {
11817 return lastComparison;
11818 }
11819 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
11820 if (lastComparison != 0) {
11821 return lastComparison;
11822 }
11823 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
11824 if (lastComparison != 0) {
11825 return lastComparison;
11826 }
11827 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
11828 if (lastComparison != 0) {
11829 return lastComparison;
11830 }
11831 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
11832 if (lastComparison != 0) {
11833 return lastComparison;
11834 }
11835 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
11836 if (lastComparison != 0) {
11837 return lastComparison;
11838 }
11839 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
11840 if (lastComparison != 0) {
11841 return lastComparison;
11842 }
11843 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
11844 if (lastComparison != 0) {
11845 return lastComparison;
11846 }
11847 lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(isSetNumVersions());
11848 if (lastComparison != 0) {
11849 return lastComparison;
11850 }
11851 lastComparison = TBaseHelper.compareTo(numVersions, typedOther.numVersions);
11852 if (lastComparison != 0) {
11853 return lastComparison;
11854 }
11855 return 0;
11856 }
11857
11858 public void read(TProtocol iprot) throws TException {
11859 TField field;
11860 iprot.readStructBegin();
11861 while (true)
11862 {
11863 field = iprot.readFieldBegin();
11864 if (field.type == TType.STOP) {
11865 break;
11866 }
11867 _Fields fieldId = _Fields.findByThriftId(field.id);
11868 if (fieldId == null) {
11869 TProtocolUtil.skip(iprot, field.type);
11870 } else {
11871 switch (fieldId) {
11872 case TABLE_NAME:
11873 if (field.type == TType.STRING) {
11874 this.tableName = iprot.readBinary();
11875 } else {
11876 TProtocolUtil.skip(iprot, field.type);
11877 }
11878 break;
11879 case ROW:
11880 if (field.type == TType.STRING) {
11881 this.row = iprot.readBinary();
11882 } else {
11883 TProtocolUtil.skip(iprot, field.type);
11884 }
11885 break;
11886 case COLUMN:
11887 if (field.type == TType.STRING) {
11888 this.column = iprot.readBinary();
11889 } else {
11890 TProtocolUtil.skip(iprot, field.type);
11891 }
11892 break;
11893 case TIMESTAMP:
11894 if (field.type == TType.I64) {
11895 this.timestamp = iprot.readI64();
11896 setTimestampIsSet(true);
11897 } else {
11898 TProtocolUtil.skip(iprot, field.type);
11899 }
11900 break;
11901 case NUM_VERSIONS:
11902 if (field.type == TType.I32) {
11903 this.numVersions = iprot.readI32();
11904 setNumVersionsIsSet(true);
11905 } else {
11906 TProtocolUtil.skip(iprot, field.type);
11907 }
11908 break;
11909 }
11910 iprot.readFieldEnd();
11911 }
11912 }
11913 iprot.readStructEnd();
11914
11915
11916 validate();
11917 }
11918
11919 public void write(TProtocol oprot) throws TException {
11920 validate();
11921
11922 oprot.writeStructBegin(STRUCT_DESC);
11923 if (this.tableName != null) {
11924 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
11925 oprot.writeBinary(this.tableName);
11926 oprot.writeFieldEnd();
11927 }
11928 if (this.row != null) {
11929 oprot.writeFieldBegin(ROW_FIELD_DESC);
11930 oprot.writeBinary(this.row);
11931 oprot.writeFieldEnd();
11932 }
11933 if (this.column != null) {
11934 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
11935 oprot.writeBinary(this.column);
11936 oprot.writeFieldEnd();
11937 }
11938 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
11939 oprot.writeI64(this.timestamp);
11940 oprot.writeFieldEnd();
11941 oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
11942 oprot.writeI32(this.numVersions);
11943 oprot.writeFieldEnd();
11944 oprot.writeFieldStop();
11945 oprot.writeStructEnd();
11946 }
11947
11948 @Override
11949 public String toString() {
11950 StringBuilder sb = new StringBuilder("getVerTs_args(");
11951 boolean first = true;
11952
11953 sb.append("tableName:");
11954 if (this.tableName == null) {
11955 sb.append("null");
11956 } else {
11957 sb.append(this.tableName);
11958 }
11959 first = false;
11960 if (!first) sb.append(", ");
11961 sb.append("row:");
11962 if (this.row == null) {
11963 sb.append("null");
11964 } else {
11965 sb.append(this.row);
11966 }
11967 first = false;
11968 if (!first) sb.append(", ");
11969 sb.append("column:");
11970 if (this.column == null) {
11971 sb.append("null");
11972 } else {
11973 sb.append(this.column);
11974 }
11975 first = false;
11976 if (!first) sb.append(", ");
11977 sb.append("timestamp:");
11978 sb.append(this.timestamp);
11979 first = false;
11980 if (!first) sb.append(", ");
11981 sb.append("numVersions:");
11982 sb.append(this.numVersions);
11983 first = false;
11984 sb.append(")");
11985 return sb.toString();
11986 }
11987
11988 public void validate() throws TException {
11989
11990 }
11991
11992 }
11993
11994 public static class getVerTs_result implements TBase<getVerTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_result> {
11995 private static final TStruct STRUCT_DESC = new TStruct("getVerTs_result");
11996
11997 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
11998 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
11999
12000 public List<TCell> success;
12001 public IOError io;
12002
12003
12004 public enum _Fields implements TFieldIdEnum {
12005 SUCCESS((short)0, "success"),
12006 IO((short)1, "io");
12007
12008 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12009 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12010
12011 static {
12012 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12013 byId.put((int)field._thriftId, field);
12014 byName.put(field.getFieldName(), field);
12015 }
12016 }
12017
12018
12019
12020
12021 public static _Fields findByThriftId(int fieldId) {
12022 return byId.get(fieldId);
12023 }
12024
12025
12026
12027
12028
12029 public static _Fields findByThriftIdOrThrow(int fieldId) {
12030 _Fields fields = findByThriftId(fieldId);
12031 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12032 return fields;
12033 }
12034
12035
12036
12037
12038 public static _Fields findByName(String name) {
12039 return byName.get(name);
12040 }
12041
12042 private final short _thriftId;
12043 private final String _fieldName;
12044
12045 _Fields(short thriftId, String fieldName) {
12046 _thriftId = thriftId;
12047 _fieldName = fieldName;
12048 }
12049
12050 public short getThriftFieldId() {
12051 return _thriftId;
12052 }
12053
12054 public String getFieldName() {
12055 return _fieldName;
12056 }
12057 }
12058
12059
12060
12061 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12062 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
12063 new ListMetaData(TType.LIST,
12064 new StructMetaData(TType.STRUCT, TCell.class))));
12065 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
12066 new FieldValueMetaData(TType.STRUCT)));
12067 }});
12068
12069 static {
12070 FieldMetaData.addStructMetaDataMap(getVerTs_result.class, metaDataMap);
12071 }
12072
12073 public getVerTs_result() {
12074 }
12075
12076 public getVerTs_result(
12077 List<TCell> success,
12078 IOError io)
12079 {
12080 this();
12081 this.success = success;
12082 this.io = io;
12083 }
12084
12085
12086
12087
12088 public getVerTs_result(getVerTs_result other) {
12089 if (other.isSetSuccess()) {
12090 List<TCell> __this__success = new ArrayList<TCell>();
12091 for (TCell other_element : other.success) {
12092 __this__success.add(new TCell(other_element));
12093 }
12094 this.success = __this__success;
12095 }
12096 if (other.isSetIo()) {
12097 this.io = new IOError(other.io);
12098 }
12099 }
12100
12101 public getVerTs_result deepCopy() {
12102 return new getVerTs_result(this);
12103 }
12104
12105 @Deprecated
12106 public getVerTs_result clone() {
12107 return new getVerTs_result(this);
12108 }
12109
12110 public int getSuccessSize() {
12111 return (this.success == null) ? 0 : this.success.size();
12112 }
12113
12114 public java.util.Iterator<TCell> getSuccessIterator() {
12115 return (this.success == null) ? null : this.success.iterator();
12116 }
12117
12118 public void addToSuccess(TCell elem) {
12119 if (this.success == null) {
12120 this.success = new ArrayList<TCell>();
12121 }
12122 this.success.add(elem);
12123 }
12124
12125 public List<TCell> getSuccess() {
12126 return this.success;
12127 }
12128
12129 public getVerTs_result setSuccess(List<TCell> success) {
12130 this.success = success;
12131 return this;
12132 }
12133
12134 public void unsetSuccess() {
12135 this.success = null;
12136 }
12137
12138
12139 public boolean isSetSuccess() {
12140 return this.success != null;
12141 }
12142
12143 public void setSuccessIsSet(boolean value) {
12144 if (!value) {
12145 this.success = null;
12146 }
12147 }
12148
12149 public IOError getIo() {
12150 return this.io;
12151 }
12152
12153 public getVerTs_result setIo(IOError io) {
12154 this.io = io;
12155 return this;
12156 }
12157
12158 public void unsetIo() {
12159 this.io = null;
12160 }
12161
12162
12163 public boolean isSetIo() {
12164 return this.io != null;
12165 }
12166
12167 public void setIoIsSet(boolean value) {
12168 if (!value) {
12169 this.io = null;
12170 }
12171 }
12172
12173 public void setFieldValue(_Fields field, Object value) {
12174 switch (field) {
12175 case SUCCESS:
12176 if (value == null) {
12177 unsetSuccess();
12178 } else {
12179 setSuccess((List<TCell>)value);
12180 }
12181 break;
12182
12183 case IO:
12184 if (value == null) {
12185 unsetIo();
12186 } else {
12187 setIo((IOError)value);
12188 }
12189 break;
12190
12191 }
12192 }
12193
12194 public void setFieldValue(int fieldID, Object value) {
12195 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
12196 }
12197
12198 public Object getFieldValue(_Fields field) {
12199 switch (field) {
12200 case SUCCESS:
12201 return getSuccess();
12202
12203 case IO:
12204 return getIo();
12205
12206 }
12207 throw new IllegalStateException();
12208 }
12209
12210 public Object getFieldValue(int fieldId) {
12211 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12212 }
12213
12214
12215 public boolean isSet(_Fields field) {
12216 switch (field) {
12217 case SUCCESS:
12218 return isSetSuccess();
12219 case IO:
12220 return isSetIo();
12221 }
12222 throw new IllegalStateException();
12223 }
12224
12225 public boolean isSet(int fieldID) {
12226 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12227 }
12228
12229 @Override
12230 public boolean equals(Object that) {
12231 if (that == null)
12232 return false;
12233 if (that instanceof getVerTs_result)
12234 return this.equals((getVerTs_result)that);
12235 return false;
12236 }
12237
12238 public boolean equals(getVerTs_result that) {
12239 if (that == null)
12240 return false;
12241
12242 boolean this_present_success = true && this.isSetSuccess();
12243 boolean that_present_success = true && that.isSetSuccess();
12244 if (this_present_success || that_present_success) {
12245 if (!(this_present_success && that_present_success))
12246 return false;
12247 if (!this.success.equals(that.success))
12248 return false;
12249 }
12250
12251 boolean this_present_io = true && this.isSetIo();
12252 boolean that_present_io = true && that.isSetIo();
12253 if (this_present_io || that_present_io) {
12254 if (!(this_present_io && that_present_io))
12255 return false;
12256 if (!this.io.equals(that.io))
12257 return false;
12258 }
12259
12260 return true;
12261 }
12262
12263 @Override
12264 public int hashCode() {
12265 HashCodeBuilder builder = new HashCodeBuilder();
12266
12267 boolean present_success = true && (isSetSuccess());
12268 builder.append(present_success);
12269 if (present_success)
12270 builder.append(success);
12271
12272 boolean present_io = true && (isSetIo());
12273 builder.append(present_io);
12274 if (present_io)
12275 builder.append(io);
12276
12277 return builder.toHashCode();
12278 }
12279
12280 public int compareTo(getVerTs_result other) {
12281 if (!getClass().equals(other.getClass())) {
12282 return getClass().getName().compareTo(other.getClass().getName());
12283 }
12284
12285 int lastComparison = 0;
12286 getVerTs_result typedOther = (getVerTs_result)other;
12287
12288 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
12289 if (lastComparison != 0) {
12290 return lastComparison;
12291 }
12292 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
12293 if (lastComparison != 0) {
12294 return lastComparison;
12295 }
12296 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
12297 if (lastComparison != 0) {
12298 return lastComparison;
12299 }
12300 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
12301 if (lastComparison != 0) {
12302 return lastComparison;
12303 }
12304 return 0;
12305 }
12306
12307 public void read(TProtocol iprot) throws TException {
12308 TField field;
12309 iprot.readStructBegin();
12310 while (true)
12311 {
12312 field = iprot.readFieldBegin();
12313 if (field.type == TType.STOP) {
12314 break;
12315 }
12316 _Fields fieldId = _Fields.findByThriftId(field.id);
12317 if (fieldId == null) {
12318 TProtocolUtil.skip(iprot, field.type);
12319 } else {
12320 switch (fieldId) {
12321 case SUCCESS:
12322 if (field.type == TType.LIST) {
12323 {
12324 TList _list34 = iprot.readListBegin();
12325 this.success = new ArrayList<TCell>(_list34.size);
12326 for (int _i35 = 0; _i35 < _list34.size; ++_i35)
12327 {
12328 TCell _elem36;
12329 _elem36 = new TCell();
12330 _elem36.read(iprot);
12331 this.success.add(_elem36);
12332 }
12333 iprot.readListEnd();
12334 }
12335 } else {
12336 TProtocolUtil.skip(iprot, field.type);
12337 }
12338 break;
12339 case IO:
12340 if (field.type == TType.STRUCT) {
12341 this.io = new IOError();
12342 this.io.read(iprot);
12343 } else {
12344 TProtocolUtil.skip(iprot, field.type);
12345 }
12346 break;
12347 }
12348 iprot.readFieldEnd();
12349 }
12350 }
12351 iprot.readStructEnd();
12352
12353
12354 validate();
12355 }
12356
12357 public void write(TProtocol oprot) throws TException {
12358 oprot.writeStructBegin(STRUCT_DESC);
12359
12360 if (this.isSetSuccess()) {
12361 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12362 {
12363 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
12364 for (TCell _iter37 : this.success)
12365 {
12366 _iter37.write(oprot);
12367 }
12368 oprot.writeListEnd();
12369 }
12370 oprot.writeFieldEnd();
12371 } else if (this.isSetIo()) {
12372 oprot.writeFieldBegin(IO_FIELD_DESC);
12373 this.io.write(oprot);
12374 oprot.writeFieldEnd();
12375 }
12376 oprot.writeFieldStop();
12377 oprot.writeStructEnd();
12378 }
12379
12380 @Override
12381 public String toString() {
12382 StringBuilder sb = new StringBuilder("getVerTs_result(");
12383 boolean first = true;
12384
12385 sb.append("success:");
12386 if (this.success == null) {
12387 sb.append("null");
12388 } else {
12389 sb.append(this.success);
12390 }
12391 first = false;
12392 if (!first) sb.append(", ");
12393 sb.append("io:");
12394 if (this.io == null) {
12395 sb.append("null");
12396 } else {
12397 sb.append(this.io);
12398 }
12399 first = false;
12400 sb.append(")");
12401 return sb.toString();
12402 }
12403
12404 public void validate() throws TException {
12405
12406 }
12407
12408 }
12409
12410 public static class getRow_args implements TBase<getRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRow_args> {
12411 private static final TStruct STRUCT_DESC = new TStruct("getRow_args");
12412
12413 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
12414 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
12415
12416
12417
12418
12419 public byte[] tableName;
12420
12421
12422
12423 public byte[] row;
12424
12425
12426 public enum _Fields implements TFieldIdEnum {
12427
12428
12429
12430 TABLE_NAME((short)1, "tableName"),
12431
12432
12433
12434 ROW((short)2, "row");
12435
12436 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12437 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12438
12439 static {
12440 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12441 byId.put((int)field._thriftId, field);
12442 byName.put(field.getFieldName(), field);
12443 }
12444 }
12445
12446
12447
12448
12449 public static _Fields findByThriftId(int fieldId) {
12450 return byId.get(fieldId);
12451 }
12452
12453
12454
12455
12456
12457 public static _Fields findByThriftIdOrThrow(int fieldId) {
12458 _Fields fields = findByThriftId(fieldId);
12459 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12460 return fields;
12461 }
12462
12463
12464
12465
12466 public static _Fields findByName(String name) {
12467 return byName.get(name);
12468 }
12469
12470 private final short _thriftId;
12471 private final String _fieldName;
12472
12473 _Fields(short thriftId, String fieldName) {
12474 _thriftId = thriftId;
12475 _fieldName = fieldName;
12476 }
12477
12478 public short getThriftFieldId() {
12479 return _thriftId;
12480 }
12481
12482 public String getFieldName() {
12483 return _fieldName;
12484 }
12485 }
12486
12487
12488
12489 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12490 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
12491 new FieldValueMetaData(TType.STRING)));
12492 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
12493 new FieldValueMetaData(TType.STRING)));
12494 }});
12495
12496 static {
12497 FieldMetaData.addStructMetaDataMap(getRow_args.class, metaDataMap);
12498 }
12499
12500 public getRow_args() {
12501 }
12502
12503 public getRow_args(
12504 byte[] tableName,
12505 byte[] row)
12506 {
12507 this();
12508 this.tableName = tableName;
12509 this.row = row;
12510 }
12511
12512
12513
12514
12515 public getRow_args(getRow_args other) {
12516 if (other.isSetTableName()) {
12517 this.tableName = other.tableName;
12518 }
12519 if (other.isSetRow()) {
12520 this.row = other.row;
12521 }
12522 }
12523
12524 public getRow_args deepCopy() {
12525 return new getRow_args(this);
12526 }
12527
12528 @Deprecated
12529 public getRow_args clone() {
12530 return new getRow_args(this);
12531 }
12532
12533
12534
12535
12536 public byte[] getTableName() {
12537 return this.tableName;
12538 }
12539
12540
12541
12542
12543 public getRow_args setTableName(byte[] tableName) {
12544 this.tableName = tableName;
12545 return this;
12546 }
12547
12548 public void unsetTableName() {
12549 this.tableName = null;
12550 }
12551
12552
12553 public boolean isSetTableName() {
12554 return this.tableName != null;
12555 }
12556
12557 public void setTableNameIsSet(boolean value) {
12558 if (!value) {
12559 this.tableName = null;
12560 }
12561 }
12562
12563
12564
12565
12566 public byte[] getRow() {
12567 return this.row;
12568 }
12569
12570
12571
12572
12573 public getRow_args setRow(byte[] row) {
12574 this.row = row;
12575 return this;
12576 }
12577
12578 public void unsetRow() {
12579 this.row = null;
12580 }
12581
12582
12583 public boolean isSetRow() {
12584 return this.row != null;
12585 }
12586
12587 public void setRowIsSet(boolean value) {
12588 if (!value) {
12589 this.row = null;
12590 }
12591 }
12592
12593 public void setFieldValue(_Fields field, Object value) {
12594 switch (field) {
12595 case TABLE_NAME:
12596 if (value == null) {
12597 unsetTableName();
12598 } else {
12599 setTableName((byte[])value);
12600 }
12601 break;
12602
12603 case ROW:
12604 if (value == null) {
12605 unsetRow();
12606 } else {
12607 setRow((byte[])value);
12608 }
12609 break;
12610
12611 }
12612 }
12613
12614 public void setFieldValue(int fieldID, Object value) {
12615 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
12616 }
12617
12618 public Object getFieldValue(_Fields field) {
12619 switch (field) {
12620 case TABLE_NAME:
12621 return getTableName();
12622
12623 case ROW:
12624 return getRow();
12625
12626 }
12627 throw new IllegalStateException();
12628 }
12629
12630 public Object getFieldValue(int fieldId) {
12631 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12632 }
12633
12634
12635 public boolean isSet(_Fields field) {
12636 switch (field) {
12637 case TABLE_NAME:
12638 return isSetTableName();
12639 case ROW:
12640 return isSetRow();
12641 }
12642 throw new IllegalStateException();
12643 }
12644
12645 public boolean isSet(int fieldID) {
12646 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12647 }
12648
12649 @Override
12650 public boolean equals(Object that) {
12651 if (that == null)
12652 return false;
12653 if (that instanceof getRow_args)
12654 return this.equals((getRow_args)that);
12655 return false;
12656 }
12657
12658 public boolean equals(getRow_args that) {
12659 if (that == null)
12660 return false;
12661
12662 boolean this_present_tableName = true && this.isSetTableName();
12663 boolean that_present_tableName = true && that.isSetTableName();
12664 if (this_present_tableName || that_present_tableName) {
12665 if (!(this_present_tableName && that_present_tableName))
12666 return false;
12667 if (!java.util.Arrays.equals(this.tableName, that.tableName))
12668 return false;
12669 }
12670
12671 boolean this_present_row = true && this.isSetRow();
12672 boolean that_present_row = true && that.isSetRow();
12673 if (this_present_row || that_present_row) {
12674 if (!(this_present_row && that_present_row))
12675 return false;
12676 if (!java.util.Arrays.equals(this.row, that.row))
12677 return false;
12678 }
12679
12680 return true;
12681 }
12682
12683 @Override
12684 public int hashCode() {
12685 HashCodeBuilder builder = new HashCodeBuilder();
12686
12687 boolean present_tableName = true && (isSetTableName());
12688 builder.append(present_tableName);
12689 if (present_tableName)
12690 builder.append(tableName);
12691
12692 boolean present_row = true && (isSetRow());
12693 builder.append(present_row);
12694 if (present_row)
12695 builder.append(row);
12696
12697 return builder.toHashCode();
12698 }
12699
12700 public int compareTo(getRow_args other) {
12701 if (!getClass().equals(other.getClass())) {
12702 return getClass().getName().compareTo(other.getClass().getName());
12703 }
12704
12705 int lastComparison = 0;
12706 getRow_args typedOther = (getRow_args)other;
12707
12708 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
12709 if (lastComparison != 0) {
12710 return lastComparison;
12711 }
12712 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
12713 if (lastComparison != 0) {
12714 return lastComparison;
12715 }
12716 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
12717 if (lastComparison != 0) {
12718 return lastComparison;
12719 }
12720 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
12721 if (lastComparison != 0) {
12722 return lastComparison;
12723 }
12724 return 0;
12725 }
12726
12727 public void read(TProtocol iprot) throws TException {
12728 TField field;
12729 iprot.readStructBegin();
12730 while (true)
12731 {
12732 field = iprot.readFieldBegin();
12733 if (field.type == TType.STOP) {
12734 break;
12735 }
12736 _Fields fieldId = _Fields.findByThriftId(field.id);
12737 if (fieldId == null) {
12738 TProtocolUtil.skip(iprot, field.type);
12739 } else {
12740 switch (fieldId) {
12741 case TABLE_NAME:
12742 if (field.type == TType.STRING) {
12743 this.tableName = iprot.readBinary();
12744 } else {
12745 TProtocolUtil.skip(iprot, field.type);
12746 }
12747 break;
12748 case ROW:
12749 if (field.type == TType.STRING) {
12750 this.row = iprot.readBinary();
12751 } else {
12752 TProtocolUtil.skip(iprot, field.type);
12753 }
12754 break;
12755 }
12756 iprot.readFieldEnd();
12757 }
12758 }
12759 iprot.readStructEnd();
12760
12761
12762 validate();
12763 }
12764
12765 public void write(TProtocol oprot) throws TException {
12766 validate();
12767
12768 oprot.writeStructBegin(STRUCT_DESC);
12769 if (this.tableName != null) {
12770 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
12771 oprot.writeBinary(this.tableName);
12772 oprot.writeFieldEnd();
12773 }
12774 if (this.row != null) {
12775 oprot.writeFieldBegin(ROW_FIELD_DESC);
12776 oprot.writeBinary(this.row);
12777 oprot.writeFieldEnd();
12778 }
12779 oprot.writeFieldStop();
12780 oprot.writeStructEnd();
12781 }
12782
12783 @Override
12784 public String toString() {
12785 StringBuilder sb = new StringBuilder("getRow_args(");
12786 boolean first = true;
12787
12788 sb.append("tableName:");
12789 if (this.tableName == null) {
12790 sb.append("null");
12791 } else {
12792 sb.append(this.tableName);
12793 }
12794 first = false;
12795 if (!first) sb.append(", ");
12796 sb.append("row:");
12797 if (this.row == null) {
12798 sb.append("null");
12799 } else {
12800 sb.append(this.row);
12801 }
12802 first = false;
12803 sb.append(")");
12804 return sb.toString();
12805 }
12806
12807 public void validate() throws TException {
12808
12809 }
12810
12811 }
12812
12813 public static class getRow_result implements TBase<getRow_result._Fields>, java.io.Serializable, Cloneable {
12814 private static final TStruct STRUCT_DESC = new TStruct("getRow_result");
12815
12816 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
12817 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
12818
12819 public List<TRowResult> success;
12820 public IOError io;
12821
12822
12823 public enum _Fields implements TFieldIdEnum {
12824 SUCCESS((short)0, "success"),
12825 IO((short)1, "io");
12826
12827 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12828 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12829
12830 static {
12831 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12832 byId.put((int)field._thriftId, field);
12833 byName.put(field.getFieldName(), field);
12834 }
12835 }
12836
12837
12838
12839
12840 public static _Fields findByThriftId(int fieldId) {
12841 return byId.get(fieldId);
12842 }
12843
12844
12845
12846
12847
12848 public static _Fields findByThriftIdOrThrow(int fieldId) {
12849 _Fields fields = findByThriftId(fieldId);
12850 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12851 return fields;
12852 }
12853
12854
12855
12856
12857 public static _Fields findByName(String name) {
12858 return byName.get(name);
12859 }
12860
12861 private final short _thriftId;
12862 private final String _fieldName;
12863
12864 _Fields(short thriftId, String fieldName) {
12865 _thriftId = thriftId;
12866 _fieldName = fieldName;
12867 }
12868
12869 public short getThriftFieldId() {
12870 return _thriftId;
12871 }
12872
12873 public String getFieldName() {
12874 return _fieldName;
12875 }
12876 }
12877
12878
12879
12880 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12881 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
12882 new ListMetaData(TType.LIST,
12883 new StructMetaData(TType.STRUCT, TRowResult.class))));
12884 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
12885 new FieldValueMetaData(TType.STRUCT)));
12886 }});
12887
12888 static {
12889 FieldMetaData.addStructMetaDataMap(getRow_result.class, metaDataMap);
12890 }
12891
12892 public getRow_result() {
12893 }
12894
12895 public getRow_result(
12896 List<TRowResult> success,
12897 IOError io)
12898 {
12899 this();
12900 this.success = success;
12901 this.io = io;
12902 }
12903
12904
12905
12906
12907 public getRow_result(getRow_result other) {
12908 if (other.isSetSuccess()) {
12909 List<TRowResult> __this__success = new ArrayList<TRowResult>();
12910 for (TRowResult other_element : other.success) {
12911 __this__success.add(new TRowResult(other_element));
12912 }
12913 this.success = __this__success;
12914 }
12915 if (other.isSetIo()) {
12916 this.io = new IOError(other.io);
12917 }
12918 }
12919
12920 public getRow_result deepCopy() {
12921 return new getRow_result(this);
12922 }
12923
12924 @Deprecated
12925 public getRow_result clone() {
12926 return new getRow_result(this);
12927 }
12928
12929 public int getSuccessSize() {
12930 return (this.success == null) ? 0 : this.success.size();
12931 }
12932
12933 public java.util.Iterator<TRowResult> getSuccessIterator() {
12934 return (this.success == null) ? null : this.success.iterator();
12935 }
12936
12937 public void addToSuccess(TRowResult elem) {
12938 if (this.success == null) {
12939 this.success = new ArrayList<TRowResult>();
12940 }
12941 this.success.add(elem);
12942 }
12943
12944 public List<TRowResult> getSuccess() {
12945 return this.success;
12946 }
12947
12948 public getRow_result setSuccess(List<TRowResult> success) {
12949 this.success = success;
12950 return this;
12951 }
12952
12953 public void unsetSuccess() {
12954 this.success = null;
12955 }
12956
12957
12958 public boolean isSetSuccess() {
12959 return this.success != null;
12960 }
12961
12962 public void setSuccessIsSet(boolean value) {
12963 if (!value) {
12964 this.success = null;
12965 }
12966 }
12967
12968 public IOError getIo() {
12969 return this.io;
12970 }
12971
12972 public getRow_result setIo(IOError io) {
12973 this.io = io;
12974 return this;
12975 }
12976
12977 public void unsetIo() {
12978 this.io = null;
12979 }
12980
12981
12982 public boolean isSetIo() {
12983 return this.io != null;
12984 }
12985
12986 public void setIoIsSet(boolean value) {
12987 if (!value) {
12988 this.io = null;
12989 }
12990 }
12991
12992 public void setFieldValue(_Fields field, Object value) {
12993 switch (field) {
12994 case SUCCESS:
12995 if (value == null) {
12996 unsetSuccess();
12997 } else {
12998 setSuccess((List<TRowResult>)value);
12999 }
13000 break;
13001
13002 case IO:
13003 if (value == null) {
13004 unsetIo();
13005 } else {
13006 setIo((IOError)value);
13007 }
13008 break;
13009
13010 }
13011 }
13012
13013 public void setFieldValue(int fieldID, Object value) {
13014 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13015 }
13016
13017 public Object getFieldValue(_Fields field) {
13018 switch (field) {
13019 case SUCCESS:
13020 return getSuccess();
13021
13022 case IO:
13023 return getIo();
13024
13025 }
13026 throw new IllegalStateException();
13027 }
13028
13029 public Object getFieldValue(int fieldId) {
13030 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13031 }
13032
13033
13034 public boolean isSet(_Fields field) {
13035 switch (field) {
13036 case SUCCESS:
13037 return isSetSuccess();
13038 case IO:
13039 return isSetIo();
13040 }
13041 throw new IllegalStateException();
13042 }
13043
13044 public boolean isSet(int fieldID) {
13045 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13046 }
13047
13048 @Override
13049 public boolean equals(Object that) {
13050 if (that == null)
13051 return false;
13052 if (that instanceof getRow_result)
13053 return this.equals((getRow_result)that);
13054 return false;
13055 }
13056
13057 public boolean equals(getRow_result that) {
13058 if (that == null)
13059 return false;
13060
13061 boolean this_present_success = true && this.isSetSuccess();
13062 boolean that_present_success = true && that.isSetSuccess();
13063 if (this_present_success || that_present_success) {
13064 if (!(this_present_success && that_present_success))
13065 return false;
13066 if (!this.success.equals(that.success))
13067 return false;
13068 }
13069
13070 boolean this_present_io = true && this.isSetIo();
13071 boolean that_present_io = true && that.isSetIo();
13072 if (this_present_io || that_present_io) {
13073 if (!(this_present_io && that_present_io))
13074 return false;
13075 if (!this.io.equals(that.io))
13076 return false;
13077 }
13078
13079 return true;
13080 }
13081
13082 @Override
13083 public int hashCode() {
13084 HashCodeBuilder builder = new HashCodeBuilder();
13085
13086 boolean present_success = true && (isSetSuccess());
13087 builder.append(present_success);
13088 if (present_success)
13089 builder.append(success);
13090
13091 boolean present_io = true && (isSetIo());
13092 builder.append(present_io);
13093 if (present_io)
13094 builder.append(io);
13095
13096 return builder.toHashCode();
13097 }
13098
13099 public void read(TProtocol iprot) throws TException {
13100 TField field;
13101 iprot.readStructBegin();
13102 while (true)
13103 {
13104 field = iprot.readFieldBegin();
13105 if (field.type == TType.STOP) {
13106 break;
13107 }
13108 _Fields fieldId = _Fields.findByThriftId(field.id);
13109 if (fieldId == null) {
13110 TProtocolUtil.skip(iprot, field.type);
13111 } else {
13112 switch (fieldId) {
13113 case SUCCESS:
13114 if (field.type == TType.LIST) {
13115 {
13116 TList _list38 = iprot.readListBegin();
13117 this.success = new ArrayList<TRowResult>(_list38.size);
13118 for (int _i39 = 0; _i39 < _list38.size; ++_i39)
13119 {
13120 TRowResult _elem40;
13121 _elem40 = new TRowResult();
13122 _elem40.read(iprot);
13123 this.success.add(_elem40);
13124 }
13125 iprot.readListEnd();
13126 }
13127 } else {
13128 TProtocolUtil.skip(iprot, field.type);
13129 }
13130 break;
13131 case IO:
13132 if (field.type == TType.STRUCT) {
13133 this.io = new IOError();
13134 this.io.read(iprot);
13135 } else {
13136 TProtocolUtil.skip(iprot, field.type);
13137 }
13138 break;
13139 }
13140 iprot.readFieldEnd();
13141 }
13142 }
13143 iprot.readStructEnd();
13144
13145
13146 validate();
13147 }
13148
13149 public void write(TProtocol oprot) throws TException {
13150 oprot.writeStructBegin(STRUCT_DESC);
13151
13152 if (this.isSetSuccess()) {
13153 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13154 {
13155 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
13156 for (TRowResult _iter41 : this.success)
13157 {
13158 _iter41.write(oprot);
13159 }
13160 oprot.writeListEnd();
13161 }
13162 oprot.writeFieldEnd();
13163 } else if (this.isSetIo()) {
13164 oprot.writeFieldBegin(IO_FIELD_DESC);
13165 this.io.write(oprot);
13166 oprot.writeFieldEnd();
13167 }
13168 oprot.writeFieldStop();
13169 oprot.writeStructEnd();
13170 }
13171
13172 @Override
13173 public String toString() {
13174 StringBuilder sb = new StringBuilder("getRow_result(");
13175 boolean first = true;
13176
13177 sb.append("success:");
13178 if (this.success == null) {
13179 sb.append("null");
13180 } else {
13181 sb.append(this.success);
13182 }
13183 first = false;
13184 if (!first) sb.append(", ");
13185 sb.append("io:");
13186 if (this.io == null) {
13187 sb.append("null");
13188 } else {
13189 sb.append(this.io);
13190 }
13191 first = false;
13192 sb.append(")");
13193 return sb.toString();
13194 }
13195
13196 public void validate() throws TException {
13197
13198 }
13199
13200 }
13201
13202 public static class getRowWithColumns_args implements TBase<getRowWithColumns_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumns_args> {
13203 private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_args");
13204
13205 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
13206 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
13207 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
13208
13209
13210
13211
13212 public byte[] tableName;
13213
13214
13215
13216 public byte[] row;
13217
13218
13219
13220 public List<byte[]> columns;
13221
13222
13223 public enum _Fields implements TFieldIdEnum {
13224
13225
13226
13227 TABLE_NAME((short)1, "tableName"),
13228
13229
13230
13231 ROW((short)2, "row"),
13232
13233
13234
13235 COLUMNS((short)3, "columns");
13236
13237 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
13238 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13239
13240 static {
13241 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13242 byId.put((int)field._thriftId, field);
13243 byName.put(field.getFieldName(), field);
13244 }
13245 }
13246
13247
13248
13249
13250 public static _Fields findByThriftId(int fieldId) {
13251 return byId.get(fieldId);
13252 }
13253
13254
13255
13256
13257
13258 public static _Fields findByThriftIdOrThrow(int fieldId) {
13259 _Fields fields = findByThriftId(fieldId);
13260 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13261 return fields;
13262 }
13263
13264
13265
13266
13267 public static _Fields findByName(String name) {
13268 return byName.get(name);
13269 }
13270
13271 private final short _thriftId;
13272 private final String _fieldName;
13273
13274 _Fields(short thriftId, String fieldName) {
13275 _thriftId = thriftId;
13276 _fieldName = fieldName;
13277 }
13278
13279 public short getThriftFieldId() {
13280 return _thriftId;
13281 }
13282
13283 public String getFieldName() {
13284 return _fieldName;
13285 }
13286 }
13287
13288
13289
13290 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
13291 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
13292 new FieldValueMetaData(TType.STRING)));
13293 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
13294 new FieldValueMetaData(TType.STRING)));
13295 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
13296 new ListMetaData(TType.LIST,
13297 new FieldValueMetaData(TType.STRING))));
13298 }});
13299
13300 static {
13301 FieldMetaData.addStructMetaDataMap(getRowWithColumns_args.class, metaDataMap);
13302 }
13303
13304 public getRowWithColumns_args() {
13305 }
13306
13307 public getRowWithColumns_args(
13308 byte[] tableName,
13309 byte[] row,
13310 List<byte[]> columns)
13311 {
13312 this();
13313 this.tableName = tableName;
13314 this.row = row;
13315 this.columns = columns;
13316 }
13317
13318
13319
13320
13321 public getRowWithColumns_args(getRowWithColumns_args other) {
13322 if (other.isSetTableName()) {
13323 this.tableName = other.tableName;
13324 }
13325 if (other.isSetRow()) {
13326 this.row = other.row;
13327 }
13328 if (other.isSetColumns()) {
13329 List<byte[]> __this__columns = new ArrayList<byte[]>();
13330 for (byte[] other_element : other.columns) {
13331 __this__columns.add(other_element);
13332 }
13333 this.columns = __this__columns;
13334 }
13335 }
13336
13337 public getRowWithColumns_args deepCopy() {
13338 return new getRowWithColumns_args(this);
13339 }
13340
13341 @Deprecated
13342 public getRowWithColumns_args clone() {
13343 return new getRowWithColumns_args(this);
13344 }
13345
13346
13347
13348
13349 public byte[] getTableName() {
13350 return this.tableName;
13351 }
13352
13353
13354
13355
13356 public getRowWithColumns_args setTableName(byte[] tableName) {
13357 this.tableName = tableName;
13358 return this;
13359 }
13360
13361 public void unsetTableName() {
13362 this.tableName = null;
13363 }
13364
13365
13366 public boolean isSetTableName() {
13367 return this.tableName != null;
13368 }
13369
13370 public void setTableNameIsSet(boolean value) {
13371 if (!value) {
13372 this.tableName = null;
13373 }
13374 }
13375
13376
13377
13378
13379 public byte[] getRow() {
13380 return this.row;
13381 }
13382
13383
13384
13385
13386 public getRowWithColumns_args setRow(byte[] row) {
13387 this.row = row;
13388 return this;
13389 }
13390
13391 public void unsetRow() {
13392 this.row = null;
13393 }
13394
13395
13396 public boolean isSetRow() {
13397 return this.row != null;
13398 }
13399
13400 public void setRowIsSet(boolean value) {
13401 if (!value) {
13402 this.row = null;
13403 }
13404 }
13405
13406 public int getColumnsSize() {
13407 return (this.columns == null) ? 0 : this.columns.size();
13408 }
13409
13410 public java.util.Iterator<byte[]> getColumnsIterator() {
13411 return (this.columns == null) ? null : this.columns.iterator();
13412 }
13413
13414 public void addToColumns(byte[] elem) {
13415 if (this.columns == null) {
13416 this.columns = new ArrayList<byte[]>();
13417 }
13418 this.columns.add(elem);
13419 }
13420
13421
13422
13423
13424 public List<byte[]> getColumns() {
13425 return this.columns;
13426 }
13427
13428
13429
13430
13431 public getRowWithColumns_args setColumns(List<byte[]> columns) {
13432 this.columns = columns;
13433 return this;
13434 }
13435
13436 public void unsetColumns() {
13437 this.columns = null;
13438 }
13439
13440
13441 public boolean isSetColumns() {
13442 return this.columns != null;
13443 }
13444
13445 public void setColumnsIsSet(boolean value) {
13446 if (!value) {
13447 this.columns = null;
13448 }
13449 }
13450
13451 public void setFieldValue(_Fields field, Object value) {
13452 switch (field) {
13453 case TABLE_NAME:
13454 if (value == null) {
13455 unsetTableName();
13456 } else {
13457 setTableName((byte[])value);
13458 }
13459 break;
13460
13461 case ROW:
13462 if (value == null) {
13463 unsetRow();
13464 } else {
13465 setRow((byte[])value);
13466 }
13467 break;
13468
13469 case COLUMNS:
13470 if (value == null) {
13471 unsetColumns();
13472 } else {
13473 setColumns((List<byte[]>)value);
13474 }
13475 break;
13476
13477 }
13478 }
13479
13480 public void setFieldValue(int fieldID, Object value) {
13481 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13482 }
13483
13484 public Object getFieldValue(_Fields field) {
13485 switch (field) {
13486 case TABLE_NAME:
13487 return getTableName();
13488
13489 case ROW:
13490 return getRow();
13491
13492 case COLUMNS:
13493 return getColumns();
13494
13495 }
13496 throw new IllegalStateException();
13497 }
13498
13499 public Object getFieldValue(int fieldId) {
13500 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13501 }
13502
13503
13504 public boolean isSet(_Fields field) {
13505 switch (field) {
13506 case TABLE_NAME:
13507 return isSetTableName();
13508 case ROW:
13509 return isSetRow();
13510 case COLUMNS:
13511 return isSetColumns();
13512 }
13513 throw new IllegalStateException();
13514 }
13515
13516 public boolean isSet(int fieldID) {
13517 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13518 }
13519
13520 @Override
13521 public boolean equals(Object that) {
13522 if (that == null)
13523 return false;
13524 if (that instanceof getRowWithColumns_args)
13525 return this.equals((getRowWithColumns_args)that);
13526 return false;
13527 }
13528
13529 public boolean equals(getRowWithColumns_args that) {
13530 if (that == null)
13531 return false;
13532
13533 boolean this_present_tableName = true && this.isSetTableName();
13534 boolean that_present_tableName = true && that.isSetTableName();
13535 if (this_present_tableName || that_present_tableName) {
13536 if (!(this_present_tableName && that_present_tableName))
13537 return false;
13538 if (!java.util.Arrays.equals(this.tableName, that.tableName))
13539 return false;
13540 }
13541
13542 boolean this_present_row = true && this.isSetRow();
13543 boolean that_present_row = true && that.isSetRow();
13544 if (this_present_row || that_present_row) {
13545 if (!(this_present_row && that_present_row))
13546 return false;
13547 if (!java.util.Arrays.equals(this.row, that.row))
13548 return false;
13549 }
13550
13551 boolean this_present_columns = true && this.isSetColumns();
13552 boolean that_present_columns = true && that.isSetColumns();
13553 if (this_present_columns || that_present_columns) {
13554 if (!(this_present_columns && that_present_columns))
13555 return false;
13556 if (!this.columns.equals(that.columns))
13557 return false;
13558 }
13559
13560 return true;
13561 }
13562
13563 @Override
13564 public int hashCode() {
13565 HashCodeBuilder builder = new HashCodeBuilder();
13566
13567 boolean present_tableName = true && (isSetTableName());
13568 builder.append(present_tableName);
13569 if (present_tableName)
13570 builder.append(tableName);
13571
13572 boolean present_row = true && (isSetRow());
13573 builder.append(present_row);
13574 if (present_row)
13575 builder.append(row);
13576
13577 boolean present_columns = true && (isSetColumns());
13578 builder.append(present_columns);
13579 if (present_columns)
13580 builder.append(columns);
13581
13582 return builder.toHashCode();
13583 }
13584
13585 public int compareTo(getRowWithColumns_args other) {
13586 if (!getClass().equals(other.getClass())) {
13587 return getClass().getName().compareTo(other.getClass().getName());
13588 }
13589
13590 int lastComparison = 0;
13591 getRowWithColumns_args typedOther = (getRowWithColumns_args)other;
13592
13593 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
13594 if (lastComparison != 0) {
13595 return lastComparison;
13596 }
13597 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
13598 if (lastComparison != 0) {
13599 return lastComparison;
13600 }
13601 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
13602 if (lastComparison != 0) {
13603 return lastComparison;
13604 }
13605 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
13606 if (lastComparison != 0) {
13607 return lastComparison;
13608 }
13609 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
13610 if (lastComparison != 0) {
13611 return lastComparison;
13612 }
13613 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
13614 if (lastComparison != 0) {
13615 return lastComparison;
13616 }
13617 return 0;
13618 }
13619
13620 public void read(TProtocol iprot) throws TException {
13621 TField field;
13622 iprot.readStructBegin();
13623 while (true)
13624 {
13625 field = iprot.readFieldBegin();
13626 if (field.type == TType.STOP) {
13627 break;
13628 }
13629 _Fields fieldId = _Fields.findByThriftId(field.id);
13630 if (fieldId == null) {
13631 TProtocolUtil.skip(iprot, field.type);
13632 } else {
13633 switch (fieldId) {
13634 case TABLE_NAME:
13635 if (field.type == TType.STRING) {
13636 this.tableName = iprot.readBinary();
13637 } else {
13638 TProtocolUtil.skip(iprot, field.type);
13639 }
13640 break;
13641 case ROW:
13642 if (field.type == TType.STRING) {
13643 this.row = iprot.readBinary();
13644 } else {
13645 TProtocolUtil.skip(iprot, field.type);
13646 }
13647 break;
13648 case COLUMNS:
13649 if (field.type == TType.LIST) {
13650 {
13651 TList _list42 = iprot.readListBegin();
13652 this.columns = new ArrayList<byte[]>(_list42.size);
13653 for (int _i43 = 0; _i43 < _list42.size; ++_i43)
13654 {
13655 byte[] _elem44;
13656 _elem44 = iprot.readBinary();
13657 this.columns.add(_elem44);
13658 }
13659 iprot.readListEnd();
13660 }
13661 } else {
13662 TProtocolUtil.skip(iprot, field.type);
13663 }
13664 break;
13665 }
13666 iprot.readFieldEnd();
13667 }
13668 }
13669 iprot.readStructEnd();
13670
13671
13672 validate();
13673 }
13674
13675 public void write(TProtocol oprot) throws TException {
13676 validate();
13677
13678 oprot.writeStructBegin(STRUCT_DESC);
13679 if (this.tableName != null) {
13680 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
13681 oprot.writeBinary(this.tableName);
13682 oprot.writeFieldEnd();
13683 }
13684 if (this.row != null) {
13685 oprot.writeFieldBegin(ROW_FIELD_DESC);
13686 oprot.writeBinary(this.row);
13687 oprot.writeFieldEnd();
13688 }
13689 if (this.columns != null) {
13690 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
13691 {
13692 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
13693 for (byte[] _iter45 : this.columns)
13694 {
13695 oprot.writeBinary(_iter45);
13696 }
13697 oprot.writeListEnd();
13698 }
13699 oprot.writeFieldEnd();
13700 }
13701 oprot.writeFieldStop();
13702 oprot.writeStructEnd();
13703 }
13704
13705 @Override
13706 public String toString() {
13707 StringBuilder sb = new StringBuilder("getRowWithColumns_args(");
13708 boolean first = true;
13709
13710 sb.append("tableName:");
13711 if (this.tableName == null) {
13712 sb.append("null");
13713 } else {
13714 sb.append(this.tableName);
13715 }
13716 first = false;
13717 if (!first) sb.append(", ");
13718 sb.append("row:");
13719 if (this.row == null) {
13720 sb.append("null");
13721 } else {
13722 sb.append(this.row);
13723 }
13724 first = false;
13725 if (!first) sb.append(", ");
13726 sb.append("columns:");
13727 if (this.columns == null) {
13728 sb.append("null");
13729 } else {
13730 sb.append(this.columns);
13731 }
13732 first = false;
13733 sb.append(")");
13734 return sb.toString();
13735 }
13736
13737 public void validate() throws TException {
13738
13739 }
13740
13741 }
13742
13743 public static class getRowWithColumns_result implements TBase<getRowWithColumns_result._Fields>, java.io.Serializable, Cloneable {
13744 private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_result");
13745
13746 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
13747 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
13748
13749 public List<TRowResult> success;
13750 public IOError io;
13751
13752
13753 public enum _Fields implements TFieldIdEnum {
13754 SUCCESS((short)0, "success"),
13755 IO((short)1, "io");
13756
13757 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
13758 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13759
13760 static {
13761 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13762 byId.put((int)field._thriftId, field);
13763 byName.put(field.getFieldName(), field);
13764 }
13765 }
13766
13767
13768
13769
13770 public static _Fields findByThriftId(int fieldId) {
13771 return byId.get(fieldId);
13772 }
13773
13774
13775
13776
13777
13778 public static _Fields findByThriftIdOrThrow(int fieldId) {
13779 _Fields fields = findByThriftId(fieldId);
13780 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13781 return fields;
13782 }
13783
13784
13785
13786
13787 public static _Fields findByName(String name) {
13788 return byName.get(name);
13789 }
13790
13791 private final short _thriftId;
13792 private final String _fieldName;
13793
13794 _Fields(short thriftId, String fieldName) {
13795 _thriftId = thriftId;
13796 _fieldName = fieldName;
13797 }
13798
13799 public short getThriftFieldId() {
13800 return _thriftId;
13801 }
13802
13803 public String getFieldName() {
13804 return _fieldName;
13805 }
13806 }
13807
13808
13809
13810 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
13811 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
13812 new ListMetaData(TType.LIST,
13813 new StructMetaData(TType.STRUCT, TRowResult.class))));
13814 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
13815 new FieldValueMetaData(TType.STRUCT)));
13816 }});
13817
13818 static {
13819 FieldMetaData.addStructMetaDataMap(getRowWithColumns_result.class, metaDataMap);
13820 }
13821
13822 public getRowWithColumns_result() {
13823 }
13824
13825 public getRowWithColumns_result(
13826 List<TRowResult> success,
13827 IOError io)
13828 {
13829 this();
13830 this.success = success;
13831 this.io = io;
13832 }
13833
13834
13835
13836
13837 public getRowWithColumns_result(getRowWithColumns_result other) {
13838 if (other.isSetSuccess()) {
13839 List<TRowResult> __this__success = new ArrayList<TRowResult>();
13840 for (TRowResult other_element : other.success) {
13841 __this__success.add(new TRowResult(other_element));
13842 }
13843 this.success = __this__success;
13844 }
13845 if (other.isSetIo()) {
13846 this.io = new IOError(other.io);
13847 }
13848 }
13849
13850 public getRowWithColumns_result deepCopy() {
13851 return new getRowWithColumns_result(this);
13852 }
13853
13854 @Deprecated
13855 public getRowWithColumns_result clone() {
13856 return new getRowWithColumns_result(this);
13857 }
13858
13859 public int getSuccessSize() {
13860 return (this.success == null) ? 0 : this.success.size();
13861 }
13862
13863 public java.util.Iterator<TRowResult> getSuccessIterator() {
13864 return (this.success == null) ? null : this.success.iterator();
13865 }
13866
13867 public void addToSuccess(TRowResult elem) {
13868 if (this.success == null) {
13869 this.success = new ArrayList<TRowResult>();
13870 }
13871 this.success.add(elem);
13872 }
13873
13874 public List<TRowResult> getSuccess() {
13875 return this.success;
13876 }
13877
13878 public getRowWithColumns_result setSuccess(List<TRowResult> success) {
13879 this.success = success;
13880 return this;
13881 }
13882
13883 public void unsetSuccess() {
13884 this.success = null;
13885 }
13886
13887
13888 public boolean isSetSuccess() {
13889 return this.success != null;
13890 }
13891
13892 public void setSuccessIsSet(boolean value) {
13893 if (!value) {
13894 this.success = null;
13895 }
13896 }
13897
13898 public IOError getIo() {
13899 return this.io;
13900 }
13901
13902 public getRowWithColumns_result setIo(IOError io) {
13903 this.io = io;
13904 return this;
13905 }
13906
13907 public void unsetIo() {
13908 this.io = null;
13909 }
13910
13911
13912 public boolean isSetIo() {
13913 return this.io != null;
13914 }
13915
13916 public void setIoIsSet(boolean value) {
13917 if (!value) {
13918 this.io = null;
13919 }
13920 }
13921
13922 public void setFieldValue(_Fields field, Object value) {
13923 switch (field) {
13924 case SUCCESS:
13925 if (value == null) {
13926 unsetSuccess();
13927 } else {
13928 setSuccess((List<TRowResult>)value);
13929 }
13930 break;
13931
13932 case IO:
13933 if (value == null) {
13934 unsetIo();
13935 } else {
13936 setIo((IOError)value);
13937 }
13938 break;
13939
13940 }
13941 }
13942
13943 public void setFieldValue(int fieldID, Object value) {
13944 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13945 }
13946
13947 public Object getFieldValue(_Fields field) {
13948 switch (field) {
13949 case SUCCESS:
13950 return getSuccess();
13951
13952 case IO:
13953 return getIo();
13954
13955 }
13956 throw new IllegalStateException();
13957 }
13958
13959 public Object getFieldValue(int fieldId) {
13960 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13961 }
13962
13963
13964 public boolean isSet(_Fields field) {
13965 switch (field) {
13966 case SUCCESS:
13967 return isSetSuccess();
13968 case IO:
13969 return isSetIo();
13970 }
13971 throw new IllegalStateException();
13972 }
13973
13974 public boolean isSet(int fieldID) {
13975 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13976 }
13977
13978 @Override
13979 public boolean equals(Object that) {
13980 if (that == null)
13981 return false;
13982 if (that instanceof getRowWithColumns_result)
13983 return this.equals((getRowWithColumns_result)that);
13984 return false;
13985 }
13986
13987 public boolean equals(getRowWithColumns_result that) {
13988 if (that == null)
13989 return false;
13990
13991 boolean this_present_success = true && this.isSetSuccess();
13992 boolean that_present_success = true && that.isSetSuccess();
13993 if (this_present_success || that_present_success) {
13994 if (!(this_present_success && that_present_success))
13995 return false;
13996 if (!this.success.equals(that.success))
13997 return false;
13998 }
13999
14000 boolean this_present_io = true && this.isSetIo();
14001 boolean that_present_io = true && that.isSetIo();
14002 if (this_present_io || that_present_io) {
14003 if (!(this_present_io && that_present_io))
14004 return false;
14005 if (!this.io.equals(that.io))
14006 return false;
14007 }
14008
14009 return true;
14010 }
14011
14012 @Override
14013 public int hashCode() {
14014 HashCodeBuilder builder = new HashCodeBuilder();
14015
14016 boolean present_success = true && (isSetSuccess());
14017 builder.append(present_success);
14018 if (present_success)
14019 builder.append(success);
14020
14021 boolean present_io = true && (isSetIo());
14022 builder.append(present_io);
14023 if (present_io)
14024 builder.append(io);
14025
14026 return builder.toHashCode();
14027 }
14028
14029 public void read(TProtocol iprot) throws TException {
14030 TField field;
14031 iprot.readStructBegin();
14032 while (true)
14033 {
14034 field = iprot.readFieldBegin();
14035 if (field.type == TType.STOP) {
14036 break;
14037 }
14038 _Fields fieldId = _Fields.findByThriftId(field.id);
14039 if (fieldId == null) {
14040 TProtocolUtil.skip(iprot, field.type);
14041 } else {
14042 switch (fieldId) {
14043 case SUCCESS:
14044 if (field.type == TType.LIST) {
14045 {
14046 TList _list46 = iprot.readListBegin();
14047 this.success = new ArrayList<TRowResult>(_list46.size);
14048 for (int _i47 = 0; _i47 < _list46.size; ++_i47)
14049 {
14050 TRowResult _elem48;
14051 _elem48 = new TRowResult();
14052 _elem48.read(iprot);
14053 this.success.add(_elem48);
14054 }
14055 iprot.readListEnd();
14056 }
14057 } else {
14058 TProtocolUtil.skip(iprot, field.type);
14059 }
14060 break;
14061 case IO:
14062 if (field.type == TType.STRUCT) {
14063 this.io = new IOError();
14064 this.io.read(iprot);
14065 } else {
14066 TProtocolUtil.skip(iprot, field.type);
14067 }
14068 break;
14069 }
14070 iprot.readFieldEnd();
14071 }
14072 }
14073 iprot.readStructEnd();
14074
14075
14076 validate();
14077 }
14078
14079 public void write(TProtocol oprot) throws TException {
14080 oprot.writeStructBegin(STRUCT_DESC);
14081
14082 if (this.isSetSuccess()) {
14083 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
14084 {
14085 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
14086 for (TRowResult _iter49 : this.success)
14087 {
14088 _iter49.write(oprot);
14089 }
14090 oprot.writeListEnd();
14091 }
14092 oprot.writeFieldEnd();
14093 } else if (this.isSetIo()) {
14094 oprot.writeFieldBegin(IO_FIELD_DESC);
14095 this.io.write(oprot);
14096 oprot.writeFieldEnd();
14097 }
14098 oprot.writeFieldStop();
14099 oprot.writeStructEnd();
14100 }
14101
14102 @Override
14103 public String toString() {
14104 StringBuilder sb = new StringBuilder("getRowWithColumns_result(");
14105 boolean first = true;
14106
14107 sb.append("success:");
14108 if (this.success == null) {
14109 sb.append("null");
14110 } else {
14111 sb.append(this.success);
14112 }
14113 first = false;
14114 if (!first) sb.append(", ");
14115 sb.append("io:");
14116 if (this.io == null) {
14117 sb.append("null");
14118 } else {
14119 sb.append(this.io);
14120 }
14121 first = false;
14122 sb.append(")");
14123 return sb.toString();
14124 }
14125
14126 public void validate() throws TException {
14127
14128 }
14129
14130 }
14131
14132 public static class getRowTs_args implements TBase<getRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowTs_args> {
14133 private static final TStruct STRUCT_DESC = new TStruct("getRowTs_args");
14134
14135 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
14136 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
14137 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
14138
14139
14140
14141
14142 public byte[] tableName;
14143
14144
14145
14146 public byte[] row;
14147
14148
14149
14150 public long timestamp;
14151
14152
14153 public enum _Fields implements TFieldIdEnum {
14154
14155
14156
14157 TABLE_NAME((short)1, "tableName"),
14158
14159
14160
14161 ROW((short)2, "row"),
14162
14163
14164
14165 TIMESTAMP((short)3, "timestamp");
14166
14167 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14168 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14169
14170 static {
14171 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14172 byId.put((int)field._thriftId, field);
14173 byName.put(field.getFieldName(), field);
14174 }
14175 }
14176
14177
14178
14179
14180 public static _Fields findByThriftId(int fieldId) {
14181 return byId.get(fieldId);
14182 }
14183
14184
14185
14186
14187
14188 public static _Fields findByThriftIdOrThrow(int fieldId) {
14189 _Fields fields = findByThriftId(fieldId);
14190 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14191 return fields;
14192 }
14193
14194
14195
14196
14197 public static _Fields findByName(String name) {
14198 return byName.get(name);
14199 }
14200
14201 private final short _thriftId;
14202 private final String _fieldName;
14203
14204 _Fields(short thriftId, String fieldName) {
14205 _thriftId = thriftId;
14206 _fieldName = fieldName;
14207 }
14208
14209 public short getThriftFieldId() {
14210 return _thriftId;
14211 }
14212
14213 public String getFieldName() {
14214 return _fieldName;
14215 }
14216 }
14217
14218
14219 private static final int __TIMESTAMP_ISSET_ID = 0;
14220 private BitSet __isset_bit_vector = new BitSet(1);
14221
14222 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
14223 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
14224 new FieldValueMetaData(TType.STRING)));
14225 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
14226 new FieldValueMetaData(TType.STRING)));
14227 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
14228 new FieldValueMetaData(TType.I64)));
14229 }});
14230
14231 static {
14232 FieldMetaData.addStructMetaDataMap(getRowTs_args.class, metaDataMap);
14233 }
14234
14235 public getRowTs_args() {
14236 }
14237
14238 public getRowTs_args(
14239 byte[] tableName,
14240 byte[] row,
14241 long timestamp)
14242 {
14243 this();
14244 this.tableName = tableName;
14245 this.row = row;
14246 this.timestamp = timestamp;
14247 setTimestampIsSet(true);
14248 }
14249
14250
14251
14252
14253 public getRowTs_args(getRowTs_args other) {
14254 __isset_bit_vector.clear();
14255 __isset_bit_vector.or(other.__isset_bit_vector);
14256 if (other.isSetTableName()) {
14257 this.tableName = other.tableName;
14258 }
14259 if (other.isSetRow()) {
14260 this.row = other.row;
14261 }
14262 this.timestamp = other.timestamp;
14263 }
14264
14265 public getRowTs_args deepCopy() {
14266 return new getRowTs_args(this);
14267 }
14268
14269 @Deprecated
14270 public getRowTs_args clone() {
14271 return new getRowTs_args(this);
14272 }
14273
14274
14275
14276
14277 public byte[] getTableName() {
14278 return this.tableName;
14279 }
14280
14281
14282
14283
14284 public getRowTs_args setTableName(byte[] tableName) {
14285 this.tableName = tableName;
14286 return this;
14287 }
14288
14289 public void unsetTableName() {
14290 this.tableName = null;
14291 }
14292
14293
14294 public boolean isSetTableName() {
14295 return this.tableName != null;
14296 }
14297
14298 public void setTableNameIsSet(boolean value) {
14299 if (!value) {
14300 this.tableName = null;
14301 }
14302 }
14303
14304
14305
14306
14307 public byte[] getRow() {
14308 return this.row;
14309 }
14310
14311
14312
14313
14314 public getRowTs_args setRow(byte[] row) {
14315 this.row = row;
14316 return this;
14317 }
14318
14319 public void unsetRow() {
14320 this.row = null;
14321 }
14322
14323
14324 public boolean isSetRow() {
14325 return this.row != null;
14326 }
14327
14328 public void setRowIsSet(boolean value) {
14329 if (!value) {
14330 this.row = null;
14331 }
14332 }
14333
14334
14335
14336
14337 public long getTimestamp() {
14338 return this.timestamp;
14339 }
14340
14341
14342
14343
14344 public getRowTs_args setTimestamp(long timestamp) {
14345 this.timestamp = timestamp;
14346 setTimestampIsSet(true);
14347 return this;
14348 }
14349
14350 public void unsetTimestamp() {
14351 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
14352 }
14353
14354
14355 public boolean isSetTimestamp() {
14356 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
14357 }
14358
14359 public void setTimestampIsSet(boolean value) {
14360 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
14361 }
14362
14363 public void setFieldValue(_Fields field, Object value) {
14364 switch (field) {
14365 case TABLE_NAME:
14366 if (value == null) {
14367 unsetTableName();
14368 } else {
14369 setTableName((byte[])value);
14370 }
14371 break;
14372
14373 case ROW:
14374 if (value == null) {
14375 unsetRow();
14376 } else {
14377 setRow((byte[])value);
14378 }
14379 break;
14380
14381 case TIMESTAMP:
14382 if (value == null) {
14383 unsetTimestamp();
14384 } else {
14385 setTimestamp((Long)value);
14386 }
14387 break;
14388
14389 }
14390 }
14391
14392 public void setFieldValue(int fieldID, Object value) {
14393 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
14394 }
14395
14396 public Object getFieldValue(_Fields field) {
14397 switch (field) {
14398 case TABLE_NAME:
14399 return getTableName();
14400
14401 case ROW:
14402 return getRow();
14403
14404 case TIMESTAMP:
14405 return new Long(getTimestamp());
14406
14407 }
14408 throw new IllegalStateException();
14409 }
14410
14411 public Object getFieldValue(int fieldId) {
14412 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
14413 }
14414
14415
14416 public boolean isSet(_Fields field) {
14417 switch (field) {
14418 case TABLE_NAME:
14419 return isSetTableName();
14420 case ROW:
14421 return isSetRow();
14422 case TIMESTAMP:
14423 return isSetTimestamp();
14424 }
14425 throw new IllegalStateException();
14426 }
14427
14428 public boolean isSet(int fieldID) {
14429 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
14430 }
14431
14432 @Override
14433 public boolean equals(Object that) {
14434 if (that == null)
14435 return false;
14436 if (that instanceof getRowTs_args)
14437 return this.equals((getRowTs_args)that);
14438 return false;
14439 }
14440
14441 public boolean equals(getRowTs_args that) {
14442 if (that == null)
14443 return false;
14444
14445 boolean this_present_tableName = true && this.isSetTableName();
14446 boolean that_present_tableName = true && that.isSetTableName();
14447 if (this_present_tableName || that_present_tableName) {
14448 if (!(this_present_tableName && that_present_tableName))
14449 return false;
14450 if (!java.util.Arrays.equals(this.tableName, that.tableName))
14451 return false;
14452 }
14453
14454 boolean this_present_row = true && this.isSetRow();
14455 boolean that_present_row = true && that.isSetRow();
14456 if (this_present_row || that_present_row) {
14457 if (!(this_present_row && that_present_row))
14458 return false;
14459 if (!java.util.Arrays.equals(this.row, that.row))
14460 return false;
14461 }
14462
14463 boolean this_present_timestamp = true;
14464 boolean that_present_timestamp = true;
14465 if (this_present_timestamp || that_present_timestamp) {
14466 if (!(this_present_timestamp && that_present_timestamp))
14467 return false;
14468 if (this.timestamp != that.timestamp)
14469 return false;
14470 }
14471
14472 return true;
14473 }
14474
14475 @Override
14476 public int hashCode() {
14477 HashCodeBuilder builder = new HashCodeBuilder();
14478
14479 boolean present_tableName = true && (isSetTableName());
14480 builder.append(present_tableName);
14481 if (present_tableName)
14482 builder.append(tableName);
14483
14484 boolean present_row = true && (isSetRow());
14485 builder.append(present_row);
14486 if (present_row)
14487 builder.append(row);
14488
14489 boolean present_timestamp = true;
14490 builder.append(present_timestamp);
14491 if (present_timestamp)
14492 builder.append(timestamp);
14493
14494 return builder.toHashCode();
14495 }
14496
14497 public int compareTo(getRowTs_args other) {
14498 if (!getClass().equals(other.getClass())) {
14499 return getClass().getName().compareTo(other.getClass().getName());
14500 }
14501
14502 int lastComparison = 0;
14503 getRowTs_args typedOther = (getRowTs_args)other;
14504
14505 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
14506 if (lastComparison != 0) {
14507 return lastComparison;
14508 }
14509 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
14510 if (lastComparison != 0) {
14511 return lastComparison;
14512 }
14513 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
14514 if (lastComparison != 0) {
14515 return lastComparison;
14516 }
14517 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
14518 if (lastComparison != 0) {
14519 return lastComparison;
14520 }
14521 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
14522 if (lastComparison != 0) {
14523 return lastComparison;
14524 }
14525 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
14526 if (lastComparison != 0) {
14527 return lastComparison;
14528 }
14529 return 0;
14530 }
14531
14532 public void read(TProtocol iprot) throws TException {
14533 TField field;
14534 iprot.readStructBegin();
14535 while (true)
14536 {
14537 field = iprot.readFieldBegin();
14538 if (field.type == TType.STOP) {
14539 break;
14540 }
14541 _Fields fieldId = _Fields.findByThriftId(field.id);
14542 if (fieldId == null) {
14543 TProtocolUtil.skip(iprot, field.type);
14544 } else {
14545 switch (fieldId) {
14546 case TABLE_NAME:
14547 if (field.type == TType.STRING) {
14548 this.tableName = iprot.readBinary();
14549 } else {
14550 TProtocolUtil.skip(iprot, field.type);
14551 }
14552 break;
14553 case ROW:
14554 if (field.type == TType.STRING) {
14555 this.row = iprot.readBinary();
14556 } else {
14557 TProtocolUtil.skip(iprot, field.type);
14558 }
14559 break;
14560 case TIMESTAMP:
14561 if (field.type == TType.I64) {
14562 this.timestamp = iprot.readI64();
14563 setTimestampIsSet(true);
14564 } else {
14565 TProtocolUtil.skip(iprot, field.type);
14566 }
14567 break;
14568 }
14569 iprot.readFieldEnd();
14570 }
14571 }
14572 iprot.readStructEnd();
14573
14574
14575 validate();
14576 }
14577
14578 public void write(TProtocol oprot) throws TException {
14579 validate();
14580
14581 oprot.writeStructBegin(STRUCT_DESC);
14582 if (this.tableName != null) {
14583 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
14584 oprot.writeBinary(this.tableName);
14585 oprot.writeFieldEnd();
14586 }
14587 if (this.row != null) {
14588 oprot.writeFieldBegin(ROW_FIELD_DESC);
14589 oprot.writeBinary(this.row);
14590 oprot.writeFieldEnd();
14591 }
14592 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
14593 oprot.writeI64(this.timestamp);
14594 oprot.writeFieldEnd();
14595 oprot.writeFieldStop();
14596 oprot.writeStructEnd();
14597 }
14598
14599 @Override
14600 public String toString() {
14601 StringBuilder sb = new StringBuilder("getRowTs_args(");
14602 boolean first = true;
14603
14604 sb.append("tableName:");
14605 if (this.tableName == null) {
14606 sb.append("null");
14607 } else {
14608 sb.append(this.tableName);
14609 }
14610 first = false;
14611 if (!first) sb.append(", ");
14612 sb.append("row:");
14613 if (this.row == null) {
14614 sb.append("null");
14615 } else {
14616 sb.append(this.row);
14617 }
14618 first = false;
14619 if (!first) sb.append(", ");
14620 sb.append("timestamp:");
14621 sb.append(this.timestamp);
14622 first = false;
14623 sb.append(")");
14624 return sb.toString();
14625 }
14626
14627 public void validate() throws TException {
14628
14629 }
14630
14631 }
14632
14633 public static class getRowTs_result implements TBase<getRowTs_result._Fields>, java.io.Serializable, Cloneable {
14634 private static final TStruct STRUCT_DESC = new TStruct("getRowTs_result");
14635
14636 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
14637 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
14638
14639 public List<TRowResult> success;
14640 public IOError io;
14641
14642
14643 public enum _Fields implements TFieldIdEnum {
14644 SUCCESS((short)0, "success"),
14645 IO((short)1, "io");
14646
14647 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14648 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14649
14650 static {
14651 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14652 byId.put((int)field._thriftId, field);
14653 byName.put(field.getFieldName(), field);
14654 }
14655 }
14656
14657
14658
14659
14660 public static _Fields findByThriftId(int fieldId) {
14661 return byId.get(fieldId);
14662 }
14663
14664
14665
14666
14667
14668 public static _Fields findByThriftIdOrThrow(int fieldId) {
14669 _Fields fields = findByThriftId(fieldId);
14670 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14671 return fields;
14672 }
14673
14674
14675
14676
14677 public static _Fields findByName(String name) {
14678 return byName.get(name);
14679 }
14680
14681 private final short _thriftId;
14682 private final String _fieldName;
14683
14684 _Fields(short thriftId, String fieldName) {
14685 _thriftId = thriftId;
14686 _fieldName = fieldName;
14687 }
14688
14689 public short getThriftFieldId() {
14690 return _thriftId;
14691 }
14692
14693 public String getFieldName() {
14694 return _fieldName;
14695 }
14696 }
14697
14698
14699
14700 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
14701 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
14702 new ListMetaData(TType.LIST,
14703 new StructMetaData(TType.STRUCT, TRowResult.class))));
14704 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
14705 new FieldValueMetaData(TType.STRUCT)));
14706 }});
14707
14708 static {
14709 FieldMetaData.addStructMetaDataMap(getRowTs_result.class, metaDataMap);
14710 }
14711
14712 public getRowTs_result() {
14713 }
14714
14715 public getRowTs_result(
14716 List<TRowResult> success,
14717 IOError io)
14718 {
14719 this();
14720 this.success = success;
14721 this.io = io;
14722 }
14723
14724
14725
14726
14727 public getRowTs_result(getRowTs_result other) {
14728 if (other.isSetSuccess()) {
14729 List<TRowResult> __this__success = new ArrayList<TRowResult>();
14730 for (TRowResult other_element : other.success) {
14731 __this__success.add(new TRowResult(other_element));
14732 }
14733 this.success = __this__success;
14734 }
14735 if (other.isSetIo()) {
14736 this.io = new IOError(other.io);
14737 }
14738 }
14739
14740 public getRowTs_result deepCopy() {
14741 return new getRowTs_result(this);
14742 }
14743
14744 @Deprecated
14745 public getRowTs_result clone() {
14746 return new getRowTs_result(this);
14747 }
14748
14749 public int getSuccessSize() {
14750 return (this.success == null) ? 0 : this.success.size();
14751 }
14752
14753 public java.util.Iterator<TRowResult> getSuccessIterator() {
14754 return (this.success == null) ? null : this.success.iterator();
14755 }
14756
14757 public void addToSuccess(TRowResult elem) {
14758 if (this.success == null) {
14759 this.success = new ArrayList<TRowResult>();
14760 }
14761 this.success.add(elem);
14762 }
14763
14764 public List<TRowResult> getSuccess() {
14765 return this.success;
14766 }
14767
14768 public getRowTs_result setSuccess(List<TRowResult> success) {
14769 this.success = success;
14770 return this;
14771 }
14772
14773 public void unsetSuccess() {
14774 this.success = null;
14775 }
14776
14777
14778 public boolean isSetSuccess() {
14779 return this.success != null;
14780 }
14781
14782 public void setSuccessIsSet(boolean value) {
14783 if (!value) {
14784 this.success = null;
14785 }
14786 }
14787
14788 public IOError getIo() {
14789 return this.io;
14790 }
14791
14792 public getRowTs_result setIo(IOError io) {
14793 this.io = io;
14794 return this;
14795 }
14796
14797 public void unsetIo() {
14798 this.io = null;
14799 }
14800
14801
14802 public boolean isSetIo() {
14803 return this.io != null;
14804 }
14805
14806 public void setIoIsSet(boolean value) {
14807 if (!value) {
14808 this.io = null;
14809 }
14810 }
14811
14812 public void setFieldValue(_Fields field, Object value) {
14813 switch (field) {
14814 case SUCCESS:
14815 if (value == null) {
14816 unsetSuccess();
14817 } else {
14818 setSuccess((List<TRowResult>)value);
14819 }
14820 break;
14821
14822 case IO:
14823 if (value == null) {
14824 unsetIo();
14825 } else {
14826 setIo((IOError)value);
14827 }
14828 break;
14829
14830 }
14831 }
14832
14833 public void setFieldValue(int fieldID, Object value) {
14834 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
14835 }
14836
14837 public Object getFieldValue(_Fields field) {
14838 switch (field) {
14839 case SUCCESS:
14840 return getSuccess();
14841
14842 case IO:
14843 return getIo();
14844
14845 }
14846 throw new IllegalStateException();
14847 }
14848
14849 public Object getFieldValue(int fieldId) {
14850 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
14851 }
14852
14853
14854 public boolean isSet(_Fields field) {
14855 switch (field) {
14856 case SUCCESS:
14857 return isSetSuccess();
14858 case IO:
14859 return isSetIo();
14860 }
14861 throw new IllegalStateException();
14862 }
14863
14864 public boolean isSet(int fieldID) {
14865 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
14866 }
14867
14868 @Override
14869 public boolean equals(Object that) {
14870 if (that == null)
14871 return false;
14872 if (that instanceof getRowTs_result)
14873 return this.equals((getRowTs_result)that);
14874 return false;
14875 }
14876
14877 public boolean equals(getRowTs_result that) {
14878 if (that == null)
14879 return false;
14880
14881 boolean this_present_success = true && this.isSetSuccess();
14882 boolean that_present_success = true && that.isSetSuccess();
14883 if (this_present_success || that_present_success) {
14884 if (!(this_present_success && that_present_success))
14885 return false;
14886 if (!this.success.equals(that.success))
14887 return false;
14888 }
14889
14890 boolean this_present_io = true && this.isSetIo();
14891 boolean that_present_io = true && that.isSetIo();
14892 if (this_present_io || that_present_io) {
14893 if (!(this_present_io && that_present_io))
14894 return false;
14895 if (!this.io.equals(that.io))
14896 return false;
14897 }
14898
14899 return true;
14900 }
14901
14902 @Override
14903 public int hashCode() {
14904 HashCodeBuilder builder = new HashCodeBuilder();
14905
14906 boolean present_success = true && (isSetSuccess());
14907 builder.append(present_success);
14908 if (present_success)
14909 builder.append(success);
14910
14911 boolean present_io = true && (isSetIo());
14912 builder.append(present_io);
14913 if (present_io)
14914 builder.append(io);
14915
14916 return builder.toHashCode();
14917 }
14918
14919 public void read(TProtocol iprot) throws TException {
14920 TField field;
14921 iprot.readStructBegin();
14922 while (true)
14923 {
14924 field = iprot.readFieldBegin();
14925 if (field.type == TType.STOP) {
14926 break;
14927 }
14928 _Fields fieldId = _Fields.findByThriftId(field.id);
14929 if (fieldId == null) {
14930 TProtocolUtil.skip(iprot, field.type);
14931 } else {
14932 switch (fieldId) {
14933 case SUCCESS:
14934 if (field.type == TType.LIST) {
14935 {
14936 TList _list50 = iprot.readListBegin();
14937 this.success = new ArrayList<TRowResult>(_list50.size);
14938 for (int _i51 = 0; _i51 < _list50.size; ++_i51)
14939 {
14940 TRowResult _elem52;
14941 _elem52 = new TRowResult();
14942 _elem52.read(iprot);
14943 this.success.add(_elem52);
14944 }
14945 iprot.readListEnd();
14946 }
14947 } else {
14948 TProtocolUtil.skip(iprot, field.type);
14949 }
14950 break;
14951 case IO:
14952 if (field.type == TType.STRUCT) {
14953 this.io = new IOError();
14954 this.io.read(iprot);
14955 } else {
14956 TProtocolUtil.skip(iprot, field.type);
14957 }
14958 break;
14959 }
14960 iprot.readFieldEnd();
14961 }
14962 }
14963 iprot.readStructEnd();
14964
14965
14966 validate();
14967 }
14968
14969 public void write(TProtocol oprot) throws TException {
14970 oprot.writeStructBegin(STRUCT_DESC);
14971
14972 if (this.isSetSuccess()) {
14973 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
14974 {
14975 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
14976 for (TRowResult _iter53 : this.success)
14977 {
14978 _iter53.write(oprot);
14979 }
14980 oprot.writeListEnd();
14981 }
14982 oprot.writeFieldEnd();
14983 } else if (this.isSetIo()) {
14984 oprot.writeFieldBegin(IO_FIELD_DESC);
14985 this.io.write(oprot);
14986 oprot.writeFieldEnd();
14987 }
14988 oprot.writeFieldStop();
14989 oprot.writeStructEnd();
14990 }
14991
14992 @Override
14993 public String toString() {
14994 StringBuilder sb = new StringBuilder("getRowTs_result(");
14995 boolean first = true;
14996
14997 sb.append("success:");
14998 if (this.success == null) {
14999 sb.append("null");
15000 } else {
15001 sb.append(this.success);
15002 }
15003 first = false;
15004 if (!first) sb.append(", ");
15005 sb.append("io:");
15006 if (this.io == null) {
15007 sb.append("null");
15008 } else {
15009 sb.append(this.io);
15010 }
15011 first = false;
15012 sb.append(")");
15013 return sb.toString();
15014 }
15015
15016 public void validate() throws TException {
15017
15018 }
15019
15020 }
15021
15022 public static class getRowWithColumnsTs_args implements TBase<getRowWithColumnsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumnsTs_args> {
15023 private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_args");
15024
15025 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
15026 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
15027 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
15028 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
15029
15030
15031
15032
15033 public byte[] tableName;
15034
15035
15036
15037 public byte[] row;
15038
15039
15040
15041 public List<byte[]> columns;
15042 public long timestamp;
15043
15044
15045 public enum _Fields implements TFieldIdEnum {
15046
15047
15048
15049 TABLE_NAME((short)1, "tableName"),
15050
15051
15052
15053 ROW((short)2, "row"),
15054
15055
15056
15057 COLUMNS((short)3, "columns"),
15058 TIMESTAMP((short)4, "timestamp");
15059
15060 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
15061 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15062
15063 static {
15064 for (_Fields field : EnumSet.allOf(_Fields.class)) {
15065 byId.put((int)field._thriftId, field);
15066 byName.put(field.getFieldName(), field);
15067 }
15068 }
15069
15070
15071
15072
15073 public static _Fields findByThriftId(int fieldId) {
15074 return byId.get(fieldId);
15075 }
15076
15077
15078
15079
15080
15081 public static _Fields findByThriftIdOrThrow(int fieldId) {
15082 _Fields fields = findByThriftId(fieldId);
15083 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15084 return fields;
15085 }
15086
15087
15088
15089
15090 public static _Fields findByName(String name) {
15091 return byName.get(name);
15092 }
15093
15094 private final short _thriftId;
15095 private final String _fieldName;
15096
15097 _Fields(short thriftId, String fieldName) {
15098 _thriftId = thriftId;
15099 _fieldName = fieldName;
15100 }
15101
15102 public short getThriftFieldId() {
15103 return _thriftId;
15104 }
15105
15106 public String getFieldName() {
15107 return _fieldName;
15108 }
15109 }
15110
15111
15112 private static final int __TIMESTAMP_ISSET_ID = 0;
15113 private BitSet __isset_bit_vector = new BitSet(1);
15114
15115 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
15116 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
15117 new FieldValueMetaData(TType.STRING)));
15118 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
15119 new FieldValueMetaData(TType.STRING)));
15120 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
15121 new ListMetaData(TType.LIST,
15122 new FieldValueMetaData(TType.STRING))));
15123 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
15124 new FieldValueMetaData(TType.I64)));
15125 }});
15126
15127 static {
15128 FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_args.class, metaDataMap);
15129 }
15130
15131 public getRowWithColumnsTs_args() {
15132 }
15133
15134 public getRowWithColumnsTs_args(
15135 byte[] tableName,
15136 byte[] row,
15137 List<byte[]> columns,
15138 long timestamp)
15139 {
15140 this();
15141 this.tableName = tableName;
15142 this.row = row;
15143 this.columns = columns;
15144 this.timestamp = timestamp;
15145 setTimestampIsSet(true);
15146 }
15147
15148
15149
15150
15151 public getRowWithColumnsTs_args(getRowWithColumnsTs_args other) {
15152 __isset_bit_vector.clear();
15153 __isset_bit_vector.or(other.__isset_bit_vector);
15154 if (other.isSetTableName()) {
15155 this.tableName = other.tableName;
15156 }
15157 if (other.isSetRow()) {
15158 this.row = other.row;
15159 }
15160 if (other.isSetColumns()) {
15161 List<byte[]> __this__columns = new ArrayList<byte[]>();
15162 for (byte[] other_element : other.columns) {
15163 __this__columns.add(other_element);
15164 }
15165 this.columns = __this__columns;
15166 }
15167 this.timestamp = other.timestamp;
15168 }
15169
15170 public getRowWithColumnsTs_args deepCopy() {
15171 return new getRowWithColumnsTs_args(this);
15172 }
15173
15174 @Deprecated
15175 public getRowWithColumnsTs_args clone() {
15176 return new getRowWithColumnsTs_args(this);
15177 }
15178
15179
15180
15181
15182 public byte[] getTableName() {
15183 return this.tableName;
15184 }
15185
15186
15187
15188
15189 public getRowWithColumnsTs_args setTableName(byte[] tableName) {
15190 this.tableName = tableName;
15191 return this;
15192 }
15193
15194 public void unsetTableName() {
15195 this.tableName = null;
15196 }
15197
15198
15199 public boolean isSetTableName() {
15200 return this.tableName != null;
15201 }
15202
15203 public void setTableNameIsSet(boolean value) {
15204 if (!value) {
15205 this.tableName = null;
15206 }
15207 }
15208
15209
15210
15211
15212 public byte[] getRow() {
15213 return this.row;
15214 }
15215
15216
15217
15218
15219 public getRowWithColumnsTs_args setRow(byte[] row) {
15220 this.row = row;
15221 return this;
15222 }
15223
15224 public void unsetRow() {
15225 this.row = null;
15226 }
15227
15228
15229 public boolean isSetRow() {
15230 return this.row != null;
15231 }
15232
15233 public void setRowIsSet(boolean value) {
15234 if (!value) {
15235 this.row = null;
15236 }
15237 }
15238
15239 public int getColumnsSize() {
15240 return (this.columns == null) ? 0 : this.columns.size();
15241 }
15242
15243 public java.util.Iterator<byte[]> getColumnsIterator() {
15244 return (this.columns == null) ? null : this.columns.iterator();
15245 }
15246
15247 public void addToColumns(byte[] elem) {
15248 if (this.columns == null) {
15249 this.columns = new ArrayList<byte[]>();
15250 }
15251 this.columns.add(elem);
15252 }
15253
15254
15255
15256
15257 public List<byte[]> getColumns() {
15258 return this.columns;
15259 }
15260
15261
15262
15263
15264 public getRowWithColumnsTs_args setColumns(List<byte[]> columns) {
15265 this.columns = columns;
15266 return this;
15267 }
15268
15269 public void unsetColumns() {
15270 this.columns = null;
15271 }
15272
15273
15274 public boolean isSetColumns() {
15275 return this.columns != null;
15276 }
15277
15278 public void setColumnsIsSet(boolean value) {
15279 if (!value) {
15280 this.columns = null;
15281 }
15282 }
15283
15284 public long getTimestamp() {
15285 return this.timestamp;
15286 }
15287
15288 public getRowWithColumnsTs_args setTimestamp(long timestamp) {
15289 this.timestamp = timestamp;
15290 setTimestampIsSet(true);
15291 return this;
15292 }
15293
15294 public void unsetTimestamp() {
15295 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
15296 }
15297
15298
15299 public boolean isSetTimestamp() {
15300 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
15301 }
15302
15303 public void setTimestampIsSet(boolean value) {
15304 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
15305 }
15306
15307 public void setFieldValue(_Fields field, Object value) {
15308 switch (field) {
15309 case TABLE_NAME:
15310 if (value == null) {
15311 unsetTableName();
15312 } else {
15313 setTableName((byte[])value);
15314 }
15315 break;
15316
15317 case ROW:
15318 if (value == null) {
15319 unsetRow();
15320 } else {
15321 setRow((byte[])value);
15322 }
15323 break;
15324
15325 case COLUMNS:
15326 if (value == null) {
15327 unsetColumns();
15328 } else {
15329 setColumns((List<byte[]>)value);
15330 }
15331 break;
15332
15333 case TIMESTAMP:
15334 if (value == null) {
15335 unsetTimestamp();
15336 } else {
15337 setTimestamp((Long)value);
15338 }
15339 break;
15340
15341 }
15342 }
15343
15344 public void setFieldValue(int fieldID, Object value) {
15345 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
15346 }
15347
15348 public Object getFieldValue(_Fields field) {
15349 switch (field) {
15350 case TABLE_NAME:
15351 return getTableName();
15352
15353 case ROW:
15354 return getRow();
15355
15356 case COLUMNS:
15357 return getColumns();
15358
15359 case TIMESTAMP:
15360 return new Long(getTimestamp());
15361
15362 }
15363 throw new IllegalStateException();
15364 }
15365
15366 public Object getFieldValue(int fieldId) {
15367 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
15368 }
15369
15370
15371 public boolean isSet(_Fields field) {
15372 switch (field) {
15373 case TABLE_NAME:
15374 return isSetTableName();
15375 case ROW:
15376 return isSetRow();
15377 case COLUMNS:
15378 return isSetColumns();
15379 case TIMESTAMP:
15380 return isSetTimestamp();
15381 }
15382 throw new IllegalStateException();
15383 }
15384
15385 public boolean isSet(int fieldID) {
15386 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
15387 }
15388
15389 @Override
15390 public boolean equals(Object that) {
15391 if (that == null)
15392 return false;
15393 if (that instanceof getRowWithColumnsTs_args)
15394 return this.equals((getRowWithColumnsTs_args)that);
15395 return false;
15396 }
15397
15398 public boolean equals(getRowWithColumnsTs_args that) {
15399 if (that == null)
15400 return false;
15401
15402 boolean this_present_tableName = true && this.isSetTableName();
15403 boolean that_present_tableName = true && that.isSetTableName();
15404 if (this_present_tableName || that_present_tableName) {
15405 if (!(this_present_tableName && that_present_tableName))
15406 return false;
15407 if (!java.util.Arrays.equals(this.tableName, that.tableName))
15408 return false;
15409 }
15410
15411 boolean this_present_row = true && this.isSetRow();
15412 boolean that_present_row = true && that.isSetRow();
15413 if (this_present_row || that_present_row) {
15414 if (!(this_present_row && that_present_row))
15415 return false;
15416 if (!java.util.Arrays.equals(this.row, that.row))
15417 return false;
15418 }
15419
15420 boolean this_present_columns = true && this.isSetColumns();
15421 boolean that_present_columns = true && that.isSetColumns();
15422 if (this_present_columns || that_present_columns) {
15423 if (!(this_present_columns && that_present_columns))
15424 return false;
15425 if (!this.columns.equals(that.columns))
15426 return false;
15427 }
15428
15429 boolean this_present_timestamp = true;
15430 boolean that_present_timestamp = true;
15431 if (this_present_timestamp || that_present_timestamp) {
15432 if (!(this_present_timestamp && that_present_timestamp))
15433 return false;
15434 if (this.timestamp != that.timestamp)
15435 return false;
15436 }
15437
15438 return true;
15439 }
15440
15441 @Override
15442 public int hashCode() {
15443 HashCodeBuilder builder = new HashCodeBuilder();
15444
15445 boolean present_tableName = true && (isSetTableName());
15446 builder.append(present_tableName);
15447 if (present_tableName)
15448 builder.append(tableName);
15449
15450 boolean present_row = true && (isSetRow());
15451 builder.append(present_row);
15452 if (present_row)
15453 builder.append(row);
15454
15455 boolean present_columns = true && (isSetColumns());
15456 builder.append(present_columns);
15457 if (present_columns)
15458 builder.append(columns);
15459
15460 boolean present_timestamp = true;
15461 builder.append(present_timestamp);
15462 if (present_timestamp)
15463 builder.append(timestamp);
15464
15465 return builder.toHashCode();
15466 }
15467
15468 public int compareTo(getRowWithColumnsTs_args other) {
15469 if (!getClass().equals(other.getClass())) {
15470 return getClass().getName().compareTo(other.getClass().getName());
15471 }
15472
15473 int lastComparison = 0;
15474 getRowWithColumnsTs_args typedOther = (getRowWithColumnsTs_args)other;
15475
15476 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
15477 if (lastComparison != 0) {
15478 return lastComparison;
15479 }
15480 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
15481 if (lastComparison != 0) {
15482 return lastComparison;
15483 }
15484 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
15485 if (lastComparison != 0) {
15486 return lastComparison;
15487 }
15488 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
15489 if (lastComparison != 0) {
15490 return lastComparison;
15491 }
15492 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
15493 if (lastComparison != 0) {
15494 return lastComparison;
15495 }
15496 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
15497 if (lastComparison != 0) {
15498 return lastComparison;
15499 }
15500 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
15501 if (lastComparison != 0) {
15502 return lastComparison;
15503 }
15504 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
15505 if (lastComparison != 0) {
15506 return lastComparison;
15507 }
15508 return 0;
15509 }
15510
15511 public void read(TProtocol iprot) throws TException {
15512 TField field;
15513 iprot.readStructBegin();
15514 while (true)
15515 {
15516 field = iprot.readFieldBegin();
15517 if (field.type == TType.STOP) {
15518 break;
15519 }
15520 _Fields fieldId = _Fields.findByThriftId(field.id);
15521 if (fieldId == null) {
15522 TProtocolUtil.skip(iprot, field.type);
15523 } else {
15524 switch (fieldId) {
15525 case TABLE_NAME:
15526 if (field.type == TType.STRING) {
15527 this.tableName = iprot.readBinary();
15528 } else {
15529 TProtocolUtil.skip(iprot, field.type);
15530 }
15531 break;
15532 case ROW:
15533 if (field.type == TType.STRING) {
15534 this.row = iprot.readBinary();
15535 } else {
15536 TProtocolUtil.skip(iprot, field.type);
15537 }
15538 break;
15539 case COLUMNS:
15540 if (field.type == TType.LIST) {
15541 {
15542 TList _list54 = iprot.readListBegin();
15543 this.columns = new ArrayList<byte[]>(_list54.size);
15544 for (int _i55 = 0; _i55 < _list54.size; ++_i55)
15545 {
15546 byte[] _elem56;
15547 _elem56 = iprot.readBinary();
15548 this.columns.add(_elem56);
15549 }
15550 iprot.readListEnd();
15551 }
15552 } else {
15553 TProtocolUtil.skip(iprot, field.type);
15554 }
15555 break;
15556 case TIMESTAMP:
15557 if (field.type == TType.I64) {
15558 this.timestamp = iprot.readI64();
15559 setTimestampIsSet(true);
15560 } else {
15561 TProtocolUtil.skip(iprot, field.type);
15562 }
15563 break;
15564 }
15565 iprot.readFieldEnd();
15566 }
15567 }
15568 iprot.readStructEnd();
15569
15570
15571 validate();
15572 }
15573
15574 public void write(TProtocol oprot) throws TException {
15575 validate();
15576
15577 oprot.writeStructBegin(STRUCT_DESC);
15578 if (this.tableName != null) {
15579 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
15580 oprot.writeBinary(this.tableName);
15581 oprot.writeFieldEnd();
15582 }
15583 if (this.row != null) {
15584 oprot.writeFieldBegin(ROW_FIELD_DESC);
15585 oprot.writeBinary(this.row);
15586 oprot.writeFieldEnd();
15587 }
15588 if (this.columns != null) {
15589 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
15590 {
15591 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
15592 for (byte[] _iter57 : this.columns)
15593 {
15594 oprot.writeBinary(_iter57);
15595 }
15596 oprot.writeListEnd();
15597 }
15598 oprot.writeFieldEnd();
15599 }
15600 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
15601 oprot.writeI64(this.timestamp);
15602 oprot.writeFieldEnd();
15603 oprot.writeFieldStop();
15604 oprot.writeStructEnd();
15605 }
15606
15607 @Override
15608 public String toString() {
15609 StringBuilder sb = new StringBuilder("getRowWithColumnsTs_args(");
15610 boolean first = true;
15611
15612 sb.append("tableName:");
15613 if (this.tableName == null) {
15614 sb.append("null");
15615 } else {
15616 sb.append(this.tableName);
15617 }
15618 first = false;
15619 if (!first) sb.append(", ");
15620 sb.append("row:");
15621 if (this.row == null) {
15622 sb.append("null");
15623 } else {
15624 sb.append(this.row);
15625 }
15626 first = false;
15627 if (!first) sb.append(", ");
15628 sb.append("columns:");
15629 if (this.columns == null) {
15630 sb.append("null");
15631 } else {
15632 sb.append(this.columns);
15633 }
15634 first = false;
15635 if (!first) sb.append(", ");
15636 sb.append("timestamp:");
15637 sb.append(this.timestamp);
15638 first = false;
15639 sb.append(")");
15640 return sb.toString();
15641 }
15642
15643 public void validate() throws TException {
15644
15645 }
15646
15647 }
15648
15649 public static class getRowWithColumnsTs_result implements TBase<getRowWithColumnsTs_result._Fields>, java.io.Serializable, Cloneable {
15650 private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_result");
15651
15652 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
15653 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
15654
15655 public List<TRowResult> success;
15656 public IOError io;
15657
15658
15659 public enum _Fields implements TFieldIdEnum {
15660 SUCCESS((short)0, "success"),
15661 IO((short)1, "io");
15662
15663 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
15664 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15665
15666 static {
15667 for (_Fields field : EnumSet.allOf(_Fields.class)) {
15668 byId.put((int)field._thriftId, field);
15669 byName.put(field.getFieldName(), field);
15670 }
15671 }
15672
15673
15674
15675
15676 public static _Fields findByThriftId(int fieldId) {
15677 return byId.get(fieldId);
15678 }
15679
15680
15681
15682
15683
15684 public static _Fields findByThriftIdOrThrow(int fieldId) {
15685 _Fields fields = findByThriftId(fieldId);
15686 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15687 return fields;
15688 }
15689
15690
15691
15692
15693 public static _Fields findByName(String name) {
15694 return byName.get(name);
15695 }
15696
15697 private final short _thriftId;
15698 private final String _fieldName;
15699
15700 _Fields(short thriftId, String fieldName) {
15701 _thriftId = thriftId;
15702 _fieldName = fieldName;
15703 }
15704
15705 public short getThriftFieldId() {
15706 return _thriftId;
15707 }
15708
15709 public String getFieldName() {
15710 return _fieldName;
15711 }
15712 }
15713
15714
15715
15716 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
15717 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
15718 new ListMetaData(TType.LIST,
15719 new StructMetaData(TType.STRUCT, TRowResult.class))));
15720 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
15721 new FieldValueMetaData(TType.STRUCT)));
15722 }});
15723
15724 static {
15725 FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_result.class, metaDataMap);
15726 }
15727
15728 public getRowWithColumnsTs_result() {
15729 }
15730
15731 public getRowWithColumnsTs_result(
15732 List<TRowResult> success,
15733 IOError io)
15734 {
15735 this();
15736 this.success = success;
15737 this.io = io;
15738 }
15739
15740
15741
15742
15743 public getRowWithColumnsTs_result(getRowWithColumnsTs_result other) {
15744 if (other.isSetSuccess()) {
15745 List<TRowResult> __this__success = new ArrayList<TRowResult>();
15746 for (TRowResult other_element : other.success) {
15747 __this__success.add(new TRowResult(other_element));
15748 }
15749 this.success = __this__success;
15750 }
15751 if (other.isSetIo()) {
15752 this.io = new IOError(other.io);
15753 }
15754 }
15755
15756 public getRowWithColumnsTs_result deepCopy() {
15757 return new getRowWithColumnsTs_result(this);
15758 }
15759
15760 @Deprecated
15761 public getRowWithColumnsTs_result clone() {
15762 return new getRowWithColumnsTs_result(this);
15763 }
15764
15765 public int getSuccessSize() {
15766 return (this.success == null) ? 0 : this.success.size();
15767 }
15768
15769 public java.util.Iterator<TRowResult> getSuccessIterator() {
15770 return (this.success == null) ? null : this.success.iterator();
15771 }
15772
15773 public void addToSuccess(TRowResult elem) {
15774 if (this.success == null) {
15775 this.success = new ArrayList<TRowResult>();
15776 }
15777 this.success.add(elem);
15778 }
15779
15780 public List<TRowResult> getSuccess() {
15781 return this.success;
15782 }
15783
15784 public getRowWithColumnsTs_result setSuccess(List<TRowResult> success) {
15785 this.success = success;
15786 return this;
15787 }
15788
15789 public void unsetSuccess() {
15790 this.success = null;
15791 }
15792
15793
15794 public boolean isSetSuccess() {
15795 return this.success != null;
15796 }
15797
15798 public void setSuccessIsSet(boolean value) {
15799 if (!value) {
15800 this.success = null;
15801 }
15802 }
15803
15804 public IOError getIo() {
15805 return this.io;
15806 }
15807
15808 public getRowWithColumnsTs_result setIo(IOError io) {
15809 this.io = io;
15810 return this;
15811 }
15812
15813 public void unsetIo() {
15814 this.io = null;
15815 }
15816
15817
15818 public boolean isSetIo() {
15819 return this.io != null;
15820 }
15821
15822 public void setIoIsSet(boolean value) {
15823 if (!value) {
15824 this.io = null;
15825 }
15826 }
15827
15828 public void setFieldValue(_Fields field, Object value) {
15829 switch (field) {
15830 case SUCCESS:
15831 if (value == null) {
15832 unsetSuccess();
15833 } else {
15834 setSuccess((List<TRowResult>)value);
15835 }
15836 break;
15837
15838 case IO:
15839 if (value == null) {
15840 unsetIo();
15841 } else {
15842 setIo((IOError)value);
15843 }
15844 break;
15845
15846 }
15847 }
15848
15849 public void setFieldValue(int fieldID, Object value) {
15850 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
15851 }
15852
15853 public Object getFieldValue(_Fields field) {
15854 switch (field) {
15855 case SUCCESS:
15856 return getSuccess();
15857
15858 case IO:
15859 return getIo();
15860
15861 }
15862 throw new IllegalStateException();
15863 }
15864
15865 public Object getFieldValue(int fieldId) {
15866 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
15867 }
15868
15869
15870 public boolean isSet(_Fields field) {
15871 switch (field) {
15872 case SUCCESS:
15873 return isSetSuccess();
15874 case IO:
15875 return isSetIo();
15876 }
15877 throw new IllegalStateException();
15878 }
15879
15880 public boolean isSet(int fieldID) {
15881 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
15882 }
15883
15884 @Override
15885 public boolean equals(Object that) {
15886 if (that == null)
15887 return false;
15888 if (that instanceof getRowWithColumnsTs_result)
15889 return this.equals((getRowWithColumnsTs_result)that);
15890 return false;
15891 }
15892
15893 public boolean equals(getRowWithColumnsTs_result that) {
15894 if (that == null)
15895 return false;
15896
15897 boolean this_present_success = true && this.isSetSuccess();
15898 boolean that_present_success = true && that.isSetSuccess();
15899 if (this_present_success || that_present_success) {
15900 if (!(this_present_success && that_present_success))
15901 return false;
15902 if (!this.success.equals(that.success))
15903 return false;
15904 }
15905
15906 boolean this_present_io = true && this.isSetIo();
15907 boolean that_present_io = true && that.isSetIo();
15908 if (this_present_io || that_present_io) {
15909 if (!(this_present_io && that_present_io))
15910 return false;
15911 if (!this.io.equals(that.io))
15912 return false;
15913 }
15914
15915 return true;
15916 }
15917
15918 @Override
15919 public int hashCode() {
15920 HashCodeBuilder builder = new HashCodeBuilder();
15921
15922 boolean present_success = true && (isSetSuccess());
15923 builder.append(present_success);
15924 if (present_success)
15925 builder.append(success);
15926
15927 boolean present_io = true && (isSetIo());
15928 builder.append(present_io);
15929 if (present_io)
15930 builder.append(io);
15931
15932 return builder.toHashCode();
15933 }
15934
15935 public void read(TProtocol iprot) throws TException {
15936 TField field;
15937 iprot.readStructBegin();
15938 while (true)
15939 {
15940 field = iprot.readFieldBegin();
15941 if (field.type == TType.STOP) {
15942 break;
15943 }
15944 _Fields fieldId = _Fields.findByThriftId(field.id);
15945 if (fieldId == null) {
15946 TProtocolUtil.skip(iprot, field.type);
15947 } else {
15948 switch (fieldId) {
15949 case SUCCESS:
15950 if (field.type == TType.LIST) {
15951 {
15952 TList _list58 = iprot.readListBegin();
15953 this.success = new ArrayList<TRowResult>(_list58.size);
15954 for (int _i59 = 0; _i59 < _list58.size; ++_i59)
15955 {
15956 TRowResult _elem60;
15957 _elem60 = new TRowResult();
15958 _elem60.read(iprot);
15959 this.success.add(_elem60);
15960 }
15961 iprot.readListEnd();
15962 }
15963 } else {
15964 TProtocolUtil.skip(iprot, field.type);
15965 }
15966 break;
15967 case IO:
15968 if (field.type == TType.STRUCT) {
15969 this.io = new IOError();
15970 this.io.read(iprot);
15971 } else {
15972 TProtocolUtil.skip(iprot, field.type);
15973 }
15974 break;
15975 }
15976 iprot.readFieldEnd();
15977 }
15978 }
15979 iprot.readStructEnd();
15980
15981
15982 validate();
15983 }
15984
15985 public void write(TProtocol oprot) throws TException {
15986 oprot.writeStructBegin(STRUCT_DESC);
15987
15988 if (this.isSetSuccess()) {
15989 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
15990 {
15991 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
15992 for (TRowResult _iter61 : this.success)
15993 {
15994 _iter61.write(oprot);
15995 }
15996 oprot.writeListEnd();
15997 }
15998 oprot.writeFieldEnd();
15999 } else if (this.isSetIo()) {
16000 oprot.writeFieldBegin(IO_FIELD_DESC);
16001 this.io.write(oprot);
16002 oprot.writeFieldEnd();
16003 }
16004 oprot.writeFieldStop();
16005 oprot.writeStructEnd();
16006 }
16007
16008 @Override
16009 public String toString() {
16010 StringBuilder sb = new StringBuilder("getRowWithColumnsTs_result(");
16011 boolean first = true;
16012
16013 sb.append("success:");
16014 if (this.success == null) {
16015 sb.append("null");
16016 } else {
16017 sb.append(this.success);
16018 }
16019 first = false;
16020 if (!first) sb.append(", ");
16021 sb.append("io:");
16022 if (this.io == null) {
16023 sb.append("null");
16024 } else {
16025 sb.append(this.io);
16026 }
16027 first = false;
16028 sb.append(")");
16029 return sb.toString();
16030 }
16031
16032 public void validate() throws TException {
16033
16034 }
16035
16036 }
16037
16038 public static class mutateRow_args implements TBase<mutateRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_args> {
16039 private static final TStruct STRUCT_DESC = new TStruct("mutateRow_args");
16040
16041 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
16042 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
16043 private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3);
16044
16045
16046
16047
16048 public byte[] tableName;
16049
16050
16051
16052 public byte[] row;
16053
16054
16055
16056 public List<Mutation> mutations;
16057
16058
16059 public enum _Fields implements TFieldIdEnum {
16060
16061
16062
16063 TABLE_NAME((short)1, "tableName"),
16064
16065
16066
16067 ROW((short)2, "row"),
16068
16069
16070
16071 MUTATIONS((short)3, "mutations");
16072
16073 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
16074 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16075
16076 static {
16077 for (_Fields field : EnumSet.allOf(_Fields.class)) {
16078 byId.put((int)field._thriftId, field);
16079 byName.put(field.getFieldName(), field);
16080 }
16081 }
16082
16083
16084
16085
16086 public static _Fields findByThriftId(int fieldId) {
16087 return byId.get(fieldId);
16088 }
16089
16090
16091
16092
16093
16094 public static _Fields findByThriftIdOrThrow(int fieldId) {
16095 _Fields fields = findByThriftId(fieldId);
16096 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16097 return fields;
16098 }
16099
16100
16101
16102
16103 public static _Fields findByName(String name) {
16104 return byName.get(name);
16105 }
16106
16107 private final short _thriftId;
16108 private final String _fieldName;
16109
16110 _Fields(short thriftId, String fieldName) {
16111 _thriftId = thriftId;
16112 _fieldName = fieldName;
16113 }
16114
16115 public short getThriftFieldId() {
16116 return _thriftId;
16117 }
16118
16119 public String getFieldName() {
16120 return _fieldName;
16121 }
16122 }
16123
16124
16125
16126 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16127 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
16128 new FieldValueMetaData(TType.STRING)));
16129 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
16130 new FieldValueMetaData(TType.STRING)));
16131 put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT,
16132 new ListMetaData(TType.LIST,
16133 new StructMetaData(TType.STRUCT, Mutation.class))));
16134 }});
16135
16136 static {
16137 FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
16138 }
16139
16140 public mutateRow_args() {
16141 }
16142
16143 public mutateRow_args(
16144 byte[] tableName,
16145 byte[] row,
16146 List<Mutation> mutations)
16147 {
16148 this();
16149 this.tableName = tableName;
16150 this.row = row;
16151 this.mutations = mutations;
16152 }
16153
16154
16155
16156
16157 public mutateRow_args(mutateRow_args other) {
16158 if (other.isSetTableName()) {
16159 this.tableName = other.tableName;
16160 }
16161 if (other.isSetRow()) {
16162 this.row = other.row;
16163 }
16164 if (other.isSetMutations()) {
16165 List<Mutation> __this__mutations = new ArrayList<Mutation>();
16166 for (Mutation other_element : other.mutations) {
16167 __this__mutations.add(new Mutation(other_element));
16168 }
16169 this.mutations = __this__mutations;
16170 }
16171 }
16172
16173 public mutateRow_args deepCopy() {
16174 return new mutateRow_args(this);
16175 }
16176
16177 @Deprecated
16178 public mutateRow_args clone() {
16179 return new mutateRow_args(this);
16180 }
16181
16182
16183
16184
16185 public byte[] getTableName() {
16186 return this.tableName;
16187 }
16188
16189
16190
16191
16192 public mutateRow_args setTableName(byte[] tableName) {
16193 this.tableName = tableName;
16194 return this;
16195 }
16196
16197 public void unsetTableName() {
16198 this.tableName = null;
16199 }
16200
16201
16202 public boolean isSetTableName() {
16203 return this.tableName != null;
16204 }
16205
16206 public void setTableNameIsSet(boolean value) {
16207 if (!value) {
16208 this.tableName = null;
16209 }
16210 }
16211
16212
16213
16214
16215 public byte[] getRow() {
16216 return this.row;
16217 }
16218
16219
16220
16221
16222 public mutateRow_args setRow(byte[] row) {
16223 this.row = row;
16224 return this;
16225 }
16226
16227 public void unsetRow() {
16228 this.row = null;
16229 }
16230
16231
16232 public boolean isSetRow() {
16233 return this.row != null;
16234 }
16235
16236 public void setRowIsSet(boolean value) {
16237 if (!value) {
16238 this.row = null;
16239 }
16240 }
16241
16242 public int getMutationsSize() {
16243 return (this.mutations == null) ? 0 : this.mutations.size();
16244 }
16245
16246 public java.util.Iterator<Mutation> getMutationsIterator() {
16247 return (this.mutations == null) ? null : this.mutations.iterator();
16248 }
16249
16250 public void addToMutations(Mutation elem) {
16251 if (this.mutations == null) {
16252 this.mutations = new ArrayList<Mutation>();
16253 }
16254 this.mutations.add(elem);
16255 }
16256
16257
16258
16259
16260 public List<Mutation> getMutations() {
16261 return this.mutations;
16262 }
16263
16264
16265
16266
16267 public mutateRow_args setMutations(List<Mutation> mutations) {
16268 this.mutations = mutations;
16269 return this;
16270 }
16271
16272 public void unsetMutations() {
16273 this.mutations = null;
16274 }
16275
16276
16277 public boolean isSetMutations() {
16278 return this.mutations != null;
16279 }
16280
16281 public void setMutationsIsSet(boolean value) {
16282 if (!value) {
16283 this.mutations = null;
16284 }
16285 }
16286
16287 public void setFieldValue(_Fields field, Object value) {
16288 switch (field) {
16289 case TABLE_NAME:
16290 if (value == null) {
16291 unsetTableName();
16292 } else {
16293 setTableName((byte[])value);
16294 }
16295 break;
16296
16297 case ROW:
16298 if (value == null) {
16299 unsetRow();
16300 } else {
16301 setRow((byte[])value);
16302 }
16303 break;
16304
16305 case MUTATIONS:
16306 if (value == null) {
16307 unsetMutations();
16308 } else {
16309 setMutations((List<Mutation>)value);
16310 }
16311 break;
16312
16313 }
16314 }
16315
16316 public void setFieldValue(int fieldID, Object value) {
16317 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
16318 }
16319
16320 public Object getFieldValue(_Fields field) {
16321 switch (field) {
16322 case TABLE_NAME:
16323 return getTableName();
16324
16325 case ROW:
16326 return getRow();
16327
16328 case MUTATIONS:
16329 return getMutations();
16330
16331 }
16332 throw new IllegalStateException();
16333 }
16334
16335 public Object getFieldValue(int fieldId) {
16336 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
16337 }
16338
16339
16340 public boolean isSet(_Fields field) {
16341 switch (field) {
16342 case TABLE_NAME:
16343 return isSetTableName();
16344 case ROW:
16345 return isSetRow();
16346 case MUTATIONS:
16347 return isSetMutations();
16348 }
16349 throw new IllegalStateException();
16350 }
16351
16352 public boolean isSet(int fieldID) {
16353 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
16354 }
16355
16356 @Override
16357 public boolean equals(Object that) {
16358 if (that == null)
16359 return false;
16360 if (that instanceof mutateRow_args)
16361 return this.equals((mutateRow_args)that);
16362 return false;
16363 }
16364
16365 public boolean equals(mutateRow_args that) {
16366 if (that == null)
16367 return false;
16368
16369 boolean this_present_tableName = true && this.isSetTableName();
16370 boolean that_present_tableName = true && that.isSetTableName();
16371 if (this_present_tableName || that_present_tableName) {
16372 if (!(this_present_tableName && that_present_tableName))
16373 return false;
16374 if (!java.util.Arrays.equals(this.tableName, that.tableName))
16375 return false;
16376 }
16377
16378 boolean this_present_row = true && this.isSetRow();
16379 boolean that_present_row = true && that.isSetRow();
16380 if (this_present_row || that_present_row) {
16381 if (!(this_present_row && that_present_row))
16382 return false;
16383 if (!java.util.Arrays.equals(this.row, that.row))
16384 return false;
16385 }
16386
16387 boolean this_present_mutations = true && this.isSetMutations();
16388 boolean that_present_mutations = true && that.isSetMutations();
16389 if (this_present_mutations || that_present_mutations) {
16390 if (!(this_present_mutations && that_present_mutations))
16391 return false;
16392 if (!this.mutations.equals(that.mutations))
16393 return false;
16394 }
16395
16396 return true;
16397 }
16398
16399 @Override
16400 public int hashCode() {
16401 HashCodeBuilder builder = new HashCodeBuilder();
16402
16403 boolean present_tableName = true && (isSetTableName());
16404 builder.append(present_tableName);
16405 if (present_tableName)
16406 builder.append(tableName);
16407
16408 boolean present_row = true && (isSetRow());
16409 builder.append(present_row);
16410 if (present_row)
16411 builder.append(row);
16412
16413 boolean present_mutations = true && (isSetMutations());
16414 builder.append(present_mutations);
16415 if (present_mutations)
16416 builder.append(mutations);
16417
16418 return builder.toHashCode();
16419 }
16420
16421 public int compareTo(mutateRow_args other) {
16422 if (!getClass().equals(other.getClass())) {
16423 return getClass().getName().compareTo(other.getClass().getName());
16424 }
16425
16426 int lastComparison = 0;
16427 mutateRow_args typedOther = (mutateRow_args)other;
16428
16429 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
16430 if (lastComparison != 0) {
16431 return lastComparison;
16432 }
16433 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
16434 if (lastComparison != 0) {
16435 return lastComparison;
16436 }
16437 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
16438 if (lastComparison != 0) {
16439 return lastComparison;
16440 }
16441 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
16442 if (lastComparison != 0) {
16443 return lastComparison;
16444 }
16445 lastComparison = Boolean.valueOf(isSetMutations()).compareTo(isSetMutations());
16446 if (lastComparison != 0) {
16447 return lastComparison;
16448 }
16449 lastComparison = TBaseHelper.compareTo(mutations, typedOther.mutations);
16450 if (lastComparison != 0) {
16451 return lastComparison;
16452 }
16453 return 0;
16454 }
16455
16456 public void read(TProtocol iprot) throws TException {
16457 TField field;
16458 iprot.readStructBegin();
16459 while (true)
16460 {
16461 field = iprot.readFieldBegin();
16462 if (field.type == TType.STOP) {
16463 break;
16464 }
16465 _Fields fieldId = _Fields.findByThriftId(field.id);
16466 if (fieldId == null) {
16467 TProtocolUtil.skip(iprot, field.type);
16468 } else {
16469 switch (fieldId) {
16470 case TABLE_NAME:
16471 if (field.type == TType.STRING) {
16472 this.tableName = iprot.readBinary();
16473 } else {
16474 TProtocolUtil.skip(iprot, field.type);
16475 }
16476 break;
16477 case ROW:
16478 if (field.type == TType.STRING) {
16479 this.row = iprot.readBinary();
16480 } else {
16481 TProtocolUtil.skip(iprot, field.type);
16482 }
16483 break;
16484 case MUTATIONS:
16485 if (field.type == TType.LIST) {
16486 {
16487 TList _list62 = iprot.readListBegin();
16488 this.mutations = new ArrayList<Mutation>(_list62.size);
16489 for (int _i63 = 0; _i63 < _list62.size; ++_i63)
16490 {
16491 Mutation _elem64;
16492 _elem64 = new Mutation();
16493 _elem64.read(iprot);
16494 this.mutations.add(_elem64);
16495 }
16496 iprot.readListEnd();
16497 }
16498 } else {
16499 TProtocolUtil.skip(iprot, field.type);
16500 }
16501 break;
16502 }
16503 iprot.readFieldEnd();
16504 }
16505 }
16506 iprot.readStructEnd();
16507
16508
16509 validate();
16510 }
16511
16512 public void write(TProtocol oprot) throws TException {
16513 validate();
16514
16515 oprot.writeStructBegin(STRUCT_DESC);
16516 if (this.tableName != null) {
16517 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
16518 oprot.writeBinary(this.tableName);
16519 oprot.writeFieldEnd();
16520 }
16521 if (this.row != null) {
16522 oprot.writeFieldBegin(ROW_FIELD_DESC);
16523 oprot.writeBinary(this.row);
16524 oprot.writeFieldEnd();
16525 }
16526 if (this.mutations != null) {
16527 oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
16528 {
16529 oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size()));
16530 for (Mutation _iter65 : this.mutations)
16531 {
16532 _iter65.write(oprot);
16533 }
16534 oprot.writeListEnd();
16535 }
16536 oprot.writeFieldEnd();
16537 }
16538 oprot.writeFieldStop();
16539 oprot.writeStructEnd();
16540 }
16541
16542 @Override
16543 public String toString() {
16544 StringBuilder sb = new StringBuilder("mutateRow_args(");
16545 boolean first = true;
16546
16547 sb.append("tableName:");
16548 if (this.tableName == null) {
16549 sb.append("null");
16550 } else {
16551 sb.append(this.tableName);
16552 }
16553 first = false;
16554 if (!first) sb.append(", ");
16555 sb.append("row:");
16556 if (this.row == null) {
16557 sb.append("null");
16558 } else {
16559 sb.append(this.row);
16560 }
16561 first = false;
16562 if (!first) sb.append(", ");
16563 sb.append("mutations:");
16564 if (this.mutations == null) {
16565 sb.append("null");
16566 } else {
16567 sb.append(this.mutations);
16568 }
16569 first = false;
16570 sb.append(")");
16571 return sb.toString();
16572 }
16573
16574 public void validate() throws TException {
16575
16576 }
16577
16578 }
16579
16580 public static class mutateRow_result implements TBase<mutateRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_result> {
16581 private static final TStruct STRUCT_DESC = new TStruct("mutateRow_result");
16582
16583 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
16584 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
16585
16586 public IOError io;
16587 public IllegalArgument ia;
16588
16589
16590 public enum _Fields implements TFieldIdEnum {
16591 IO((short)1, "io"),
16592 IA((short)2, "ia");
16593
16594 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
16595 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16596
16597 static {
16598 for (_Fields field : EnumSet.allOf(_Fields.class)) {
16599 byId.put((int)field._thriftId, field);
16600 byName.put(field.getFieldName(), field);
16601 }
16602 }
16603
16604
16605
16606
16607 public static _Fields findByThriftId(int fieldId) {
16608 return byId.get(fieldId);
16609 }
16610
16611
16612
16613
16614
16615 public static _Fields findByThriftIdOrThrow(int fieldId) {
16616 _Fields fields = findByThriftId(fieldId);
16617 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16618 return fields;
16619 }
16620
16621
16622
16623
16624 public static _Fields findByName(String name) {
16625 return byName.get(name);
16626 }
16627
16628 private final short _thriftId;
16629 private final String _fieldName;
16630
16631 _Fields(short thriftId, String fieldName) {
16632 _thriftId = thriftId;
16633 _fieldName = fieldName;
16634 }
16635
16636 public short getThriftFieldId() {
16637 return _thriftId;
16638 }
16639
16640 public String getFieldName() {
16641 return _fieldName;
16642 }
16643 }
16644
16645
16646
16647 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16648 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
16649 new FieldValueMetaData(TType.STRUCT)));
16650 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
16651 new FieldValueMetaData(TType.STRUCT)));
16652 }});
16653
16654 static {
16655 FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap);
16656 }
16657
16658 public mutateRow_result() {
16659 }
16660
16661 public mutateRow_result(
16662 IOError io,
16663 IllegalArgument ia)
16664 {
16665 this();
16666 this.io = io;
16667 this.ia = ia;
16668 }
16669
16670
16671
16672
16673 public mutateRow_result(mutateRow_result other) {
16674 if (other.isSetIo()) {
16675 this.io = new IOError(other.io);
16676 }
16677 if (other.isSetIa()) {
16678 this.ia = new IllegalArgument(other.ia);
16679 }
16680 }
16681
16682 public mutateRow_result deepCopy() {
16683 return new mutateRow_result(this);
16684 }
16685
16686 @Deprecated
16687 public mutateRow_result clone() {
16688 return new mutateRow_result(this);
16689 }
16690
16691 public IOError getIo() {
16692 return this.io;
16693 }
16694
16695 public mutateRow_result setIo(IOError io) {
16696 this.io = io;
16697 return this;
16698 }
16699
16700 public void unsetIo() {
16701 this.io = null;
16702 }
16703
16704
16705 public boolean isSetIo() {
16706 return this.io != null;
16707 }
16708
16709 public void setIoIsSet(boolean value) {
16710 if (!value) {
16711 this.io = null;
16712 }
16713 }
16714
16715 public IllegalArgument getIa() {
16716 return this.ia;
16717 }
16718
16719 public mutateRow_result setIa(IllegalArgument ia) {
16720 this.ia = ia;
16721 return this;
16722 }
16723
16724 public void unsetIa() {
16725 this.ia = null;
16726 }
16727
16728
16729 public boolean isSetIa() {
16730 return this.ia != null;
16731 }
16732
16733 public void setIaIsSet(boolean value) {
16734 if (!value) {
16735 this.ia = null;
16736 }
16737 }
16738
16739 public void setFieldValue(_Fields field, Object value) {
16740 switch (field) {
16741 case IO:
16742 if (value == null) {
16743 unsetIo();
16744 } else {
16745 setIo((IOError)value);
16746 }
16747 break;
16748
16749 case IA:
16750 if (value == null) {
16751 unsetIa();
16752 } else {
16753 setIa((IllegalArgument)value);
16754 }
16755 break;
16756
16757 }
16758 }
16759
16760 public void setFieldValue(int fieldID, Object value) {
16761 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
16762 }
16763
16764 public Object getFieldValue(_Fields field) {
16765 switch (field) {
16766 case IO:
16767 return getIo();
16768
16769 case IA:
16770 return getIa();
16771
16772 }
16773 throw new IllegalStateException();
16774 }
16775
16776 public Object getFieldValue(int fieldId) {
16777 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
16778 }
16779
16780
16781 public boolean isSet(_Fields field) {
16782 switch (field) {
16783 case IO:
16784 return isSetIo();
16785 case IA:
16786 return isSetIa();
16787 }
16788 throw new IllegalStateException();
16789 }
16790
16791 public boolean isSet(int fieldID) {
16792 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
16793 }
16794
16795 @Override
16796 public boolean equals(Object that) {
16797 if (that == null)
16798 return false;
16799 if (that instanceof mutateRow_result)
16800 return this.equals((mutateRow_result)that);
16801 return false;
16802 }
16803
16804 public boolean equals(mutateRow_result that) {
16805 if (that == null)
16806 return false;
16807
16808 boolean this_present_io = true && this.isSetIo();
16809 boolean that_present_io = true && that.isSetIo();
16810 if (this_present_io || that_present_io) {
16811 if (!(this_present_io && that_present_io))
16812 return false;
16813 if (!this.io.equals(that.io))
16814 return false;
16815 }
16816
16817 boolean this_present_ia = true && this.isSetIa();
16818 boolean that_present_ia = true && that.isSetIa();
16819 if (this_present_ia || that_present_ia) {
16820 if (!(this_present_ia && that_present_ia))
16821 return false;
16822 if (!this.ia.equals(that.ia))
16823 return false;
16824 }
16825
16826 return true;
16827 }
16828
16829 @Override
16830 public int hashCode() {
16831 HashCodeBuilder builder = new HashCodeBuilder();
16832
16833 boolean present_io = true && (isSetIo());
16834 builder.append(present_io);
16835 if (present_io)
16836 builder.append(io);
16837
16838 boolean present_ia = true && (isSetIa());
16839 builder.append(present_ia);
16840 if (present_ia)
16841 builder.append(ia);
16842
16843 return builder.toHashCode();
16844 }
16845
16846 public int compareTo(mutateRow_result other) {
16847 if (!getClass().equals(other.getClass())) {
16848 return getClass().getName().compareTo(other.getClass().getName());
16849 }
16850
16851 int lastComparison = 0;
16852 mutateRow_result typedOther = (mutateRow_result)other;
16853
16854 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
16855 if (lastComparison != 0) {
16856 return lastComparison;
16857 }
16858 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
16859 if (lastComparison != 0) {
16860 return lastComparison;
16861 }
16862 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
16863 if (lastComparison != 0) {
16864 return lastComparison;
16865 }
16866 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
16867 if (lastComparison != 0) {
16868 return lastComparison;
16869 }
16870 return 0;
16871 }
16872
16873 public void read(TProtocol iprot) throws TException {
16874 TField field;
16875 iprot.readStructBegin();
16876 while (true)
16877 {
16878 field = iprot.readFieldBegin();
16879 if (field.type == TType.STOP) {
16880 break;
16881 }
16882 _Fields fieldId = _Fields.findByThriftId(field.id);
16883 if (fieldId == null) {
16884 TProtocolUtil.skip(iprot, field.type);
16885 } else {
16886 switch (fieldId) {
16887 case IO:
16888 if (field.type == TType.STRUCT) {
16889 this.io = new IOError();
16890 this.io.read(iprot);
16891 } else {
16892 TProtocolUtil.skip(iprot, field.type);
16893 }
16894 break;
16895 case IA:
16896 if (field.type == TType.STRUCT) {
16897 this.ia = new IllegalArgument();
16898 this.ia.read(iprot);
16899 } else {
16900 TProtocolUtil.skip(iprot, field.type);
16901 }
16902 break;
16903 }
16904 iprot.readFieldEnd();
16905 }
16906 }
16907 iprot.readStructEnd();
16908
16909
16910 validate();
16911 }
16912
16913 public void write(TProtocol oprot) throws TException {
16914 oprot.writeStructBegin(STRUCT_DESC);
16915
16916 if (this.isSetIo()) {
16917 oprot.writeFieldBegin(IO_FIELD_DESC);
16918 this.io.write(oprot);
16919 oprot.writeFieldEnd();
16920 } else if (this.isSetIa()) {
16921 oprot.writeFieldBegin(IA_FIELD_DESC);
16922 this.ia.write(oprot);
16923 oprot.writeFieldEnd();
16924 }
16925 oprot.writeFieldStop();
16926 oprot.writeStructEnd();
16927 }
16928
16929 @Override
16930 public String toString() {
16931 StringBuilder sb = new StringBuilder("mutateRow_result(");
16932 boolean first = true;
16933
16934 sb.append("io:");
16935 if (this.io == null) {
16936 sb.append("null");
16937 } else {
16938 sb.append(this.io);
16939 }
16940 first = false;
16941 if (!first) sb.append(", ");
16942 sb.append("ia:");
16943 if (this.ia == null) {
16944 sb.append("null");
16945 } else {
16946 sb.append(this.ia);
16947 }
16948 first = false;
16949 sb.append(")");
16950 return sb.toString();
16951 }
16952
16953 public void validate() throws TException {
16954
16955 }
16956
16957 }
16958
16959 public static class mutateRowTs_args implements TBase<mutateRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_args> {
16960 private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_args");
16961
16962 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
16963 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
16964 private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3);
16965 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
16966
16967
16968
16969
16970 public byte[] tableName;
16971
16972
16973
16974 public byte[] row;
16975
16976
16977
16978 public List<Mutation> mutations;
16979
16980
16981
16982 public long timestamp;
16983
16984
16985 public enum _Fields implements TFieldIdEnum {
16986
16987
16988
16989 TABLE_NAME((short)1, "tableName"),
16990
16991
16992
16993 ROW((short)2, "row"),
16994
16995
16996
16997 MUTATIONS((short)3, "mutations"),
16998
16999
17000
17001 TIMESTAMP((short)4, "timestamp");
17002
17003 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
17004 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
17005
17006 static {
17007 for (_Fields field : EnumSet.allOf(_Fields.class)) {
17008 byId.put((int)field._thriftId, field);
17009 byName.put(field.getFieldName(), field);
17010 }
17011 }
17012
17013
17014
17015
17016 public static _Fields findByThriftId(int fieldId) {
17017 return byId.get(fieldId);
17018 }
17019
17020
17021
17022
17023
17024 public static _Fields findByThriftIdOrThrow(int fieldId) {
17025 _Fields fields = findByThriftId(fieldId);
17026 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
17027 return fields;
17028 }
17029
17030
17031
17032
17033 public static _Fields findByName(String name) {
17034 return byName.get(name);
17035 }
17036
17037 private final short _thriftId;
17038 private final String _fieldName;
17039
17040 _Fields(short thriftId, String fieldName) {
17041 _thriftId = thriftId;
17042 _fieldName = fieldName;
17043 }
17044
17045 public short getThriftFieldId() {
17046 return _thriftId;
17047 }
17048
17049 public String getFieldName() {
17050 return _fieldName;
17051 }
17052 }
17053
17054
17055 private static final int __TIMESTAMP_ISSET_ID = 0;
17056 private BitSet __isset_bit_vector = new BitSet(1);
17057
17058 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
17059 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
17060 new FieldValueMetaData(TType.STRING)));
17061 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
17062 new FieldValueMetaData(TType.STRING)));
17063 put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT,
17064 new ListMetaData(TType.LIST,
17065 new StructMetaData(TType.STRUCT, Mutation.class))));
17066 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
17067 new FieldValueMetaData(TType.I64)));
17068 }});
17069
17070 static {
17071 FieldMetaData.addStructMetaDataMap(mutateRowTs_args.class, metaDataMap);
17072 }
17073
17074 public mutateRowTs_args() {
17075 }
17076
17077 public mutateRowTs_args(
17078 byte[] tableName,
17079 byte[] row,
17080 List<Mutation> mutations,
17081 long timestamp)
17082 {
17083 this();
17084 this.tableName = tableName;
17085 this.row = row;
17086 this.mutations = mutations;
17087 this.timestamp = timestamp;
17088 setTimestampIsSet(true);
17089 }
17090
17091
17092
17093
17094 public mutateRowTs_args(mutateRowTs_args other) {
17095 __isset_bit_vector.clear();
17096 __isset_bit_vector.or(other.__isset_bit_vector);
17097 if (other.isSetTableName()) {
17098 this.tableName = other.tableName;
17099 }
17100 if (other.isSetRow()) {
17101 this.row = other.row;
17102 }
17103 if (other.isSetMutations()) {
17104 List<Mutation> __this__mutations = new ArrayList<Mutation>();
17105 for (Mutation other_element : other.mutations) {
17106 __this__mutations.add(new Mutation(other_element));
17107 }
17108 this.mutations = __this__mutations;
17109 }
17110 this.timestamp = other.timestamp;
17111 }
17112
17113 public mutateRowTs_args deepCopy() {
17114 return new mutateRowTs_args(this);
17115 }
17116
17117 @Deprecated
17118 public mutateRowTs_args clone() {
17119 return new mutateRowTs_args(this);
17120 }
17121
17122
17123
17124
17125 public byte[] getTableName() {
17126 return this.tableName;
17127 }
17128
17129
17130
17131
17132 public mutateRowTs_args setTableName(byte[] tableName) {
17133 this.tableName = tableName;
17134 return this;
17135 }
17136
17137 public void unsetTableName() {
17138 this.tableName = null;
17139 }
17140
17141
17142 public boolean isSetTableName() {
17143 return this.tableName != null;
17144 }
17145
17146 public void setTableNameIsSet(boolean value) {
17147 if (!value) {
17148 this.tableName = null;
17149 }
17150 }
17151
17152
17153
17154
17155 public byte[] getRow() {
17156 return this.row;
17157 }
17158
17159
17160
17161
17162 public mutateRowTs_args setRow(byte[] row) {
17163 this.row = row;
17164 return this;
17165 }
17166
17167 public void unsetRow() {
17168 this.row = null;
17169 }
17170
17171
17172 public boolean isSetRow() {
17173 return this.row != null;
17174 }
17175
17176 public void setRowIsSet(boolean value) {
17177 if (!value) {
17178 this.row = null;
17179 }
17180 }
17181
17182 public int getMutationsSize() {
17183 return (this.mutations == null) ? 0 : this.mutations.size();
17184 }
17185
17186 public java.util.Iterator<Mutation> getMutationsIterator() {
17187 return (this.mutations == null) ? null : this.mutations.iterator();
17188 }
17189
17190 public void addToMutations(Mutation elem) {
17191 if (this.mutations == null) {
17192 this.mutations = new ArrayList<Mutation>();
17193 }
17194 this.mutations.add(elem);
17195 }
17196
17197
17198
17199
17200 public List<Mutation> getMutations() {
17201 return this.mutations;
17202 }
17203
17204
17205
17206
17207 public mutateRowTs_args setMutations(List<Mutation> mutations) {
17208 this.mutations = mutations;
17209 return this;
17210 }
17211
17212 public void unsetMutations() {
17213 this.mutations = null;
17214 }
17215
17216
17217 public boolean isSetMutations() {
17218 return this.mutations != null;
17219 }
17220
17221 public void setMutationsIsSet(boolean value) {
17222 if (!value) {
17223 this.mutations = null;
17224 }
17225 }
17226
17227
17228
17229
17230 public long getTimestamp() {
17231 return this.timestamp;
17232 }
17233
17234
17235
17236
17237 public mutateRowTs_args setTimestamp(long timestamp) {
17238 this.timestamp = timestamp;
17239 setTimestampIsSet(true);
17240 return this;
17241 }
17242
17243 public void unsetTimestamp() {
17244 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
17245 }
17246
17247
17248 public boolean isSetTimestamp() {
17249 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
17250 }
17251
17252 public void setTimestampIsSet(boolean value) {
17253 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
17254 }
17255
17256 public void setFieldValue(_Fields field, Object value) {
17257 switch (field) {
17258 case TABLE_NAME:
17259 if (value == null) {
17260 unsetTableName();
17261 } else {
17262 setTableName((byte[])value);
17263 }
17264 break;
17265
17266 case ROW:
17267 if (value == null) {
17268 unsetRow();
17269 } else {
17270 setRow((byte[])value);
17271 }
17272 break;
17273
17274 case MUTATIONS:
17275 if (value == null) {
17276 unsetMutations();
17277 } else {
17278 setMutations((List<Mutation>)value);
17279 }
17280 break;
17281
17282 case TIMESTAMP:
17283 if (value == null) {
17284 unsetTimestamp();
17285 } else {
17286 setTimestamp((Long)value);
17287 }
17288 break;
17289
17290 }
17291 }
17292
17293 public void setFieldValue(int fieldID, Object value) {
17294 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17295 }
17296
17297 public Object getFieldValue(_Fields field) {
17298 switch (field) {
17299 case TABLE_NAME:
17300 return getTableName();
17301
17302 case ROW:
17303 return getRow();
17304
17305 case MUTATIONS:
17306 return getMutations();
17307
17308 case TIMESTAMP:
17309 return new Long(getTimestamp());
17310
17311 }
17312 throw new IllegalStateException();
17313 }
17314
17315 public Object getFieldValue(int fieldId) {
17316 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17317 }
17318
17319
17320 public boolean isSet(_Fields field) {
17321 switch (field) {
17322 case TABLE_NAME:
17323 return isSetTableName();
17324 case ROW:
17325 return isSetRow();
17326 case MUTATIONS:
17327 return isSetMutations();
17328 case TIMESTAMP:
17329 return isSetTimestamp();
17330 }
17331 throw new IllegalStateException();
17332 }
17333
17334 public boolean isSet(int fieldID) {
17335 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
17336 }
17337
17338 @Override
17339 public boolean equals(Object that) {
17340 if (that == null)
17341 return false;
17342 if (that instanceof mutateRowTs_args)
17343 return this.equals((mutateRowTs_args)that);
17344 return false;
17345 }
17346
17347 public boolean equals(mutateRowTs_args that) {
17348 if (that == null)
17349 return false;
17350
17351 boolean this_present_tableName = true && this.isSetTableName();
17352 boolean that_present_tableName = true && that.isSetTableName();
17353 if (this_present_tableName || that_present_tableName) {
17354 if (!(this_present_tableName && that_present_tableName))
17355 return false;
17356 if (!java.util.Arrays.equals(this.tableName, that.tableName))
17357 return false;
17358 }
17359
17360 boolean this_present_row = true && this.isSetRow();
17361 boolean that_present_row = true && that.isSetRow();
17362 if (this_present_row || that_present_row) {
17363 if (!(this_present_row && that_present_row))
17364 return false;
17365 if (!java.util.Arrays.equals(this.row, that.row))
17366 return false;
17367 }
17368
17369 boolean this_present_mutations = true && this.isSetMutations();
17370 boolean that_present_mutations = true && that.isSetMutations();
17371 if (this_present_mutations || that_present_mutations) {
17372 if (!(this_present_mutations && that_present_mutations))
17373 return false;
17374 if (!this.mutations.equals(that.mutations))
17375 return false;
17376 }
17377
17378 boolean this_present_timestamp = true;
17379 boolean that_present_timestamp = true;
17380 if (this_present_timestamp || that_present_timestamp) {
17381 if (!(this_present_timestamp && that_present_timestamp))
17382 return false;
17383 if (this.timestamp != that.timestamp)
17384 return false;
17385 }
17386
17387 return true;
17388 }
17389
17390 @Override
17391 public int hashCode() {
17392 HashCodeBuilder builder = new HashCodeBuilder();
17393
17394 boolean present_tableName = true && (isSetTableName());
17395 builder.append(present_tableName);
17396 if (present_tableName)
17397 builder.append(tableName);
17398
17399 boolean present_row = true && (isSetRow());
17400 builder.append(present_row);
17401 if (present_row)
17402 builder.append(row);
17403
17404 boolean present_mutations = true && (isSetMutations());
17405 builder.append(present_mutations);
17406 if (present_mutations)
17407 builder.append(mutations);
17408
17409 boolean present_timestamp = true;
17410 builder.append(present_timestamp);
17411 if (present_timestamp)
17412 builder.append(timestamp);
17413
17414 return builder.toHashCode();
17415 }
17416
17417 public int compareTo(mutateRowTs_args other) {
17418 if (!getClass().equals(other.getClass())) {
17419 return getClass().getName().compareTo(other.getClass().getName());
17420 }
17421
17422 int lastComparison = 0;
17423 mutateRowTs_args typedOther = (mutateRowTs_args)other;
17424
17425 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
17426 if (lastComparison != 0) {
17427 return lastComparison;
17428 }
17429 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
17430 if (lastComparison != 0) {
17431 return lastComparison;
17432 }
17433 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
17434 if (lastComparison != 0) {
17435 return lastComparison;
17436 }
17437 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
17438 if (lastComparison != 0) {
17439 return lastComparison;
17440 }
17441 lastComparison = Boolean.valueOf(isSetMutations()).compareTo(isSetMutations());
17442 if (lastComparison != 0) {
17443 return lastComparison;
17444 }
17445 lastComparison = TBaseHelper.compareTo(mutations, typedOther.mutations);
17446 if (lastComparison != 0) {
17447 return lastComparison;
17448 }
17449 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
17450 if (lastComparison != 0) {
17451 return lastComparison;
17452 }
17453 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
17454 if (lastComparison != 0) {
17455 return lastComparison;
17456 }
17457 return 0;
17458 }
17459
17460 public void read(TProtocol iprot) throws TException {
17461 TField field;
17462 iprot.readStructBegin();
17463 while (true)
17464 {
17465 field = iprot.readFieldBegin();
17466 if (field.type == TType.STOP) {
17467 break;
17468 }
17469 _Fields fieldId = _Fields.findByThriftId(field.id);
17470 if (fieldId == null) {
17471 TProtocolUtil.skip(iprot, field.type);
17472 } else {
17473 switch (fieldId) {
17474 case TABLE_NAME:
17475 if (field.type == TType.STRING) {
17476 this.tableName = iprot.readBinary();
17477 } else {
17478 TProtocolUtil.skip(iprot, field.type);
17479 }
17480 break;
17481 case ROW:
17482 if (field.type == TType.STRING) {
17483 this.row = iprot.readBinary();
17484 } else {
17485 TProtocolUtil.skip(iprot, field.type);
17486 }
17487 break;
17488 case MUTATIONS:
17489 if (field.type == TType.LIST) {
17490 {
17491 TList _list66 = iprot.readListBegin();
17492 this.mutations = new ArrayList<Mutation>(_list66.size);
17493 for (int _i67 = 0; _i67 < _list66.size; ++_i67)
17494 {
17495 Mutation _elem68;
17496 _elem68 = new Mutation();
17497 _elem68.read(iprot);
17498 this.mutations.add(_elem68);
17499 }
17500 iprot.readListEnd();
17501 }
17502 } else {
17503 TProtocolUtil.skip(iprot, field.type);
17504 }
17505 break;
17506 case TIMESTAMP:
17507 if (field.type == TType.I64) {
17508 this.timestamp = iprot.readI64();
17509 setTimestampIsSet(true);
17510 } else {
17511 TProtocolUtil.skip(iprot, field.type);
17512 }
17513 break;
17514 }
17515 iprot.readFieldEnd();
17516 }
17517 }
17518 iprot.readStructEnd();
17519
17520
17521 validate();
17522 }
17523
17524 public void write(TProtocol oprot) throws TException {
17525 validate();
17526
17527 oprot.writeStructBegin(STRUCT_DESC);
17528 if (this.tableName != null) {
17529 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
17530 oprot.writeBinary(this.tableName);
17531 oprot.writeFieldEnd();
17532 }
17533 if (this.row != null) {
17534 oprot.writeFieldBegin(ROW_FIELD_DESC);
17535 oprot.writeBinary(this.row);
17536 oprot.writeFieldEnd();
17537 }
17538 if (this.mutations != null) {
17539 oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
17540 {
17541 oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size()));
17542 for (Mutation _iter69 : this.mutations)
17543 {
17544 _iter69.write(oprot);
17545 }
17546 oprot.writeListEnd();
17547 }
17548 oprot.writeFieldEnd();
17549 }
17550 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
17551 oprot.writeI64(this.timestamp);
17552 oprot.writeFieldEnd();
17553 oprot.writeFieldStop();
17554 oprot.writeStructEnd();
17555 }
17556
17557 @Override
17558 public String toString() {
17559 StringBuilder sb = new StringBuilder("mutateRowTs_args(");
17560 boolean first = true;
17561
17562 sb.append("tableName:");
17563 if (this.tableName == null) {
17564 sb.append("null");
17565 } else {
17566 sb.append(this.tableName);
17567 }
17568 first = false;
17569 if (!first) sb.append(", ");
17570 sb.append("row:");
17571 if (this.row == null) {
17572 sb.append("null");
17573 } else {
17574 sb.append(this.row);
17575 }
17576 first = false;
17577 if (!first) sb.append(", ");
17578 sb.append("mutations:");
17579 if (this.mutations == null) {
17580 sb.append("null");
17581 } else {
17582 sb.append(this.mutations);
17583 }
17584 first = false;
17585 if (!first) sb.append(", ");
17586 sb.append("timestamp:");
17587 sb.append(this.timestamp);
17588 first = false;
17589 sb.append(")");
17590 return sb.toString();
17591 }
17592
17593 public void validate() throws TException {
17594
17595 }
17596
17597 }
17598
17599 public static class mutateRowTs_result implements TBase<mutateRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_result> {
17600 private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_result");
17601
17602 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
17603 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
17604
17605 public IOError io;
17606 public IllegalArgument ia;
17607
17608
17609 public enum _Fields implements TFieldIdEnum {
17610 IO((short)1, "io"),
17611 IA((short)2, "ia");
17612
17613 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
17614 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
17615
17616 static {
17617 for (_Fields field : EnumSet.allOf(_Fields.class)) {
17618 byId.put((int)field._thriftId, field);
17619 byName.put(field.getFieldName(), field);
17620 }
17621 }
17622
17623
17624
17625
17626 public static _Fields findByThriftId(int fieldId) {
17627 return byId.get(fieldId);
17628 }
17629
17630
17631
17632
17633
17634 public static _Fields findByThriftIdOrThrow(int fieldId) {
17635 _Fields fields = findByThriftId(fieldId);
17636 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
17637 return fields;
17638 }
17639
17640
17641
17642
17643 public static _Fields findByName(String name) {
17644 return byName.get(name);
17645 }
17646
17647 private final short _thriftId;
17648 private final String _fieldName;
17649
17650 _Fields(short thriftId, String fieldName) {
17651 _thriftId = thriftId;
17652 _fieldName = fieldName;
17653 }
17654
17655 public short getThriftFieldId() {
17656 return _thriftId;
17657 }
17658
17659 public String getFieldName() {
17660 return _fieldName;
17661 }
17662 }
17663
17664
17665
17666 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
17667 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
17668 new FieldValueMetaData(TType.STRUCT)));
17669 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
17670 new FieldValueMetaData(TType.STRUCT)));
17671 }});
17672
17673 static {
17674 FieldMetaData.addStructMetaDataMap(mutateRowTs_result.class, metaDataMap);
17675 }
17676
17677 public mutateRowTs_result() {
17678 }
17679
17680 public mutateRowTs_result(
17681 IOError io,
17682 IllegalArgument ia)
17683 {
17684 this();
17685 this.io = io;
17686 this.ia = ia;
17687 }
17688
17689
17690
17691
17692 public mutateRowTs_result(mutateRowTs_result other) {
17693 if (other.isSetIo()) {
17694 this.io = new IOError(other.io);
17695 }
17696 if (other.isSetIa()) {
17697 this.ia = new IllegalArgument(other.ia);
17698 }
17699 }
17700
17701 public mutateRowTs_result deepCopy() {
17702 return new mutateRowTs_result(this);
17703 }
17704
17705 @Deprecated
17706 public mutateRowTs_result clone() {
17707 return new mutateRowTs_result(this);
17708 }
17709
17710 public IOError getIo() {
17711 return this.io;
17712 }
17713
17714 public mutateRowTs_result setIo(IOError io) {
17715 this.io = io;
17716 return this;
17717 }
17718
17719 public void unsetIo() {
17720 this.io = null;
17721 }
17722
17723
17724 public boolean isSetIo() {
17725 return this.io != null;
17726 }
17727
17728 public void setIoIsSet(boolean value) {
17729 if (!value) {
17730 this.io = null;
17731 }
17732 }
17733
17734 public IllegalArgument getIa() {
17735 return this.ia;
17736 }
17737
17738 public mutateRowTs_result setIa(IllegalArgument ia) {
17739 this.ia = ia;
17740 return this;
17741 }
17742
17743 public void unsetIa() {
17744 this.ia = null;
17745 }
17746
17747
17748 public boolean isSetIa() {
17749 return this.ia != null;
17750 }
17751
17752 public void setIaIsSet(boolean value) {
17753 if (!value) {
17754 this.ia = null;
17755 }
17756 }
17757
17758 public void setFieldValue(_Fields field, Object value) {
17759 switch (field) {
17760 case IO:
17761 if (value == null) {
17762 unsetIo();
17763 } else {
17764 setIo((IOError)value);
17765 }
17766 break;
17767
17768 case IA:
17769 if (value == null) {
17770 unsetIa();
17771 } else {
17772 setIa((IllegalArgument)value);
17773 }
17774 break;
17775
17776 }
17777 }
17778
17779 public void setFieldValue(int fieldID, Object value) {
17780 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17781 }
17782
17783 public Object getFieldValue(_Fields field) {
17784 switch (field) {
17785 case IO:
17786 return getIo();
17787
17788 case IA:
17789 return getIa();
17790
17791 }
17792 throw new IllegalStateException();
17793 }
17794
17795 public Object getFieldValue(int fieldId) {
17796 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17797 }
17798
17799
17800 public boolean isSet(_Fields field) {
17801 switch (field) {
17802 case IO:
17803 return isSetIo();
17804 case IA:
17805 return isSetIa();
17806 }
17807 throw new IllegalStateException();
17808 }
17809
17810 public boolean isSet(int fieldID) {
17811 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
17812 }
17813
17814 @Override
17815 public boolean equals(Object that) {
17816 if (that == null)
17817 return false;
17818 if (that instanceof mutateRowTs_result)
17819 return this.equals((mutateRowTs_result)that);
17820 return false;
17821 }
17822
17823 public boolean equals(mutateRowTs_result that) {
17824 if (that == null)
17825 return false;
17826
17827 boolean this_present_io = true && this.isSetIo();
17828 boolean that_present_io = true && that.isSetIo();
17829 if (this_present_io || that_present_io) {
17830 if (!(this_present_io && that_present_io))
17831 return false;
17832 if (!this.io.equals(that.io))
17833 return false;
17834 }
17835
17836 boolean this_present_ia = true && this.isSetIa();
17837 boolean that_present_ia = true && that.isSetIa();
17838 if (this_present_ia || that_present_ia) {
17839 if (!(this_present_ia && that_present_ia))
17840 return false;
17841 if (!this.ia.equals(that.ia))
17842 return false;
17843 }
17844
17845 return true;
17846 }
17847
17848 @Override
17849 public int hashCode() {
17850 HashCodeBuilder builder = new HashCodeBuilder();
17851
17852 boolean present_io = true && (isSetIo());
17853 builder.append(present_io);
17854 if (present_io)
17855 builder.append(io);
17856
17857 boolean present_ia = true && (isSetIa());
17858 builder.append(present_ia);
17859 if (present_ia)
17860 builder.append(ia);
17861
17862 return builder.toHashCode();
17863 }
17864
17865 public int compareTo(mutateRowTs_result other) {
17866 if (!getClass().equals(other.getClass())) {
17867 return getClass().getName().compareTo(other.getClass().getName());
17868 }
17869
17870 int lastComparison = 0;
17871 mutateRowTs_result typedOther = (mutateRowTs_result)other;
17872
17873 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
17874 if (lastComparison != 0) {
17875 return lastComparison;
17876 }
17877 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
17878 if (lastComparison != 0) {
17879 return lastComparison;
17880 }
17881 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
17882 if (lastComparison != 0) {
17883 return lastComparison;
17884 }
17885 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
17886 if (lastComparison != 0) {
17887 return lastComparison;
17888 }
17889 return 0;
17890 }
17891
17892 public void read(TProtocol iprot) throws TException {
17893 TField field;
17894 iprot.readStructBegin();
17895 while (true)
17896 {
17897 field = iprot.readFieldBegin();
17898 if (field.type == TType.STOP) {
17899 break;
17900 }
17901 _Fields fieldId = _Fields.findByThriftId(field.id);
17902 if (fieldId == null) {
17903 TProtocolUtil.skip(iprot, field.type);
17904 } else {
17905 switch (fieldId) {
17906 case IO:
17907 if (field.type == TType.STRUCT) {
17908 this.io = new IOError();
17909 this.io.read(iprot);
17910 } else {
17911 TProtocolUtil.skip(iprot, field.type);
17912 }
17913 break;
17914 case IA:
17915 if (field.type == TType.STRUCT) {
17916 this.ia = new IllegalArgument();
17917 this.ia.read(iprot);
17918 } else {
17919 TProtocolUtil.skip(iprot, field.type);
17920 }
17921 break;
17922 }
17923 iprot.readFieldEnd();
17924 }
17925 }
17926 iprot.readStructEnd();
17927
17928
17929 validate();
17930 }
17931
17932 public void write(TProtocol oprot) throws TException {
17933 oprot.writeStructBegin(STRUCT_DESC);
17934
17935 if (this.isSetIo()) {
17936 oprot.writeFieldBegin(IO_FIELD_DESC);
17937 this.io.write(oprot);
17938 oprot.writeFieldEnd();
17939 } else if (this.isSetIa()) {
17940 oprot.writeFieldBegin(IA_FIELD_DESC);
17941 this.ia.write(oprot);
17942 oprot.writeFieldEnd();
17943 }
17944 oprot.writeFieldStop();
17945 oprot.writeStructEnd();
17946 }
17947
17948 @Override
17949 public String toString() {
17950 StringBuilder sb = new StringBuilder("mutateRowTs_result(");
17951 boolean first = true;
17952
17953 sb.append("io:");
17954 if (this.io == null) {
17955 sb.append("null");
17956 } else {
17957 sb.append(this.io);
17958 }
17959 first = false;
17960 if (!first) sb.append(", ");
17961 sb.append("ia:");
17962 if (this.ia == null) {
17963 sb.append("null");
17964 } else {
17965 sb.append(this.ia);
17966 }
17967 first = false;
17968 sb.append(")");
17969 return sb.toString();
17970 }
17971
17972 public void validate() throws TException {
17973
17974 }
17975
17976 }
17977
17978 public static class mutateRows_args implements TBase<mutateRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_args> {
17979 private static final TStruct STRUCT_DESC = new TStruct("mutateRows_args");
17980
17981 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
17982 private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2);
17983
17984
17985
17986
17987 public byte[] tableName;
17988
17989
17990
17991 public List<BatchMutation> rowBatches;
17992
17993
17994 public enum _Fields implements TFieldIdEnum {
17995
17996
17997
17998 TABLE_NAME((short)1, "tableName"),
17999
18000
18001
18002 ROW_BATCHES((short)2, "rowBatches");
18003
18004 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18005 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18006
18007 static {
18008 for (_Fields field : EnumSet.allOf(_Fields.class)) {
18009 byId.put((int)field._thriftId, field);
18010 byName.put(field.getFieldName(), field);
18011 }
18012 }
18013
18014
18015
18016
18017 public static _Fields findByThriftId(int fieldId) {
18018 return byId.get(fieldId);
18019 }
18020
18021
18022
18023
18024
18025 public static _Fields findByThriftIdOrThrow(int fieldId) {
18026 _Fields fields = findByThriftId(fieldId);
18027 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18028 return fields;
18029 }
18030
18031
18032
18033
18034 public static _Fields findByName(String name) {
18035 return byName.get(name);
18036 }
18037
18038 private final short _thriftId;
18039 private final String _fieldName;
18040
18041 _Fields(short thriftId, String fieldName) {
18042 _thriftId = thriftId;
18043 _fieldName = fieldName;
18044 }
18045
18046 public short getThriftFieldId() {
18047 return _thriftId;
18048 }
18049
18050 public String getFieldName() {
18051 return _fieldName;
18052 }
18053 }
18054
18055
18056
18057 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18058 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
18059 new FieldValueMetaData(TType.STRING)));
18060 put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT,
18061 new ListMetaData(TType.LIST,
18062 new StructMetaData(TType.STRUCT, BatchMutation.class))));
18063 }});
18064
18065 static {
18066 FieldMetaData.addStructMetaDataMap(mutateRows_args.class, metaDataMap);
18067 }
18068
18069 public mutateRows_args() {
18070 }
18071
18072 public mutateRows_args(
18073 byte[] tableName,
18074 List<BatchMutation> rowBatches)
18075 {
18076 this();
18077 this.tableName = tableName;
18078 this.rowBatches = rowBatches;
18079 }
18080
18081
18082
18083
18084 public mutateRows_args(mutateRows_args other) {
18085 if (other.isSetTableName()) {
18086 this.tableName = other.tableName;
18087 }
18088 if (other.isSetRowBatches()) {
18089 List<BatchMutation> __this__rowBatches = new ArrayList<BatchMutation>();
18090 for (BatchMutation other_element : other.rowBatches) {
18091 __this__rowBatches.add(new BatchMutation(other_element));
18092 }
18093 this.rowBatches = __this__rowBatches;
18094 }
18095 }
18096
18097 public mutateRows_args deepCopy() {
18098 return new mutateRows_args(this);
18099 }
18100
18101 @Deprecated
18102 public mutateRows_args clone() {
18103 return new mutateRows_args(this);
18104 }
18105
18106
18107
18108
18109 public byte[] getTableName() {
18110 return this.tableName;
18111 }
18112
18113
18114
18115
18116 public mutateRows_args setTableName(byte[] tableName) {
18117 this.tableName = tableName;
18118 return this;
18119 }
18120
18121 public void unsetTableName() {
18122 this.tableName = null;
18123 }
18124
18125
18126 public boolean isSetTableName() {
18127 return this.tableName != null;
18128 }
18129
18130 public void setTableNameIsSet(boolean value) {
18131 if (!value) {
18132 this.tableName = null;
18133 }
18134 }
18135
18136 public int getRowBatchesSize() {
18137 return (this.rowBatches == null) ? 0 : this.rowBatches.size();
18138 }
18139
18140 public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
18141 return (this.rowBatches == null) ? null : this.rowBatches.iterator();
18142 }
18143
18144 public void addToRowBatches(BatchMutation elem) {
18145 if (this.rowBatches == null) {
18146 this.rowBatches = new ArrayList<BatchMutation>();
18147 }
18148 this.rowBatches.add(elem);
18149 }
18150
18151
18152
18153
18154 public List<BatchMutation> getRowBatches() {
18155 return this.rowBatches;
18156 }
18157
18158
18159
18160
18161 public mutateRows_args setRowBatches(List<BatchMutation> rowBatches) {
18162 this.rowBatches = rowBatches;
18163 return this;
18164 }
18165
18166 public void unsetRowBatches() {
18167 this.rowBatches = null;
18168 }
18169
18170
18171 public boolean isSetRowBatches() {
18172 return this.rowBatches != null;
18173 }
18174
18175 public void setRowBatchesIsSet(boolean value) {
18176 if (!value) {
18177 this.rowBatches = null;
18178 }
18179 }
18180
18181 public void setFieldValue(_Fields field, Object value) {
18182 switch (field) {
18183 case TABLE_NAME:
18184 if (value == null) {
18185 unsetTableName();
18186 } else {
18187 setTableName((byte[])value);
18188 }
18189 break;
18190
18191 case ROW_BATCHES:
18192 if (value == null) {
18193 unsetRowBatches();
18194 } else {
18195 setRowBatches((List<BatchMutation>)value);
18196 }
18197 break;
18198
18199 }
18200 }
18201
18202 public void setFieldValue(int fieldID, Object value) {
18203 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
18204 }
18205
18206 public Object getFieldValue(_Fields field) {
18207 switch (field) {
18208 case TABLE_NAME:
18209 return getTableName();
18210
18211 case ROW_BATCHES:
18212 return getRowBatches();
18213
18214 }
18215 throw new IllegalStateException();
18216 }
18217
18218 public Object getFieldValue(int fieldId) {
18219 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
18220 }
18221
18222
18223 public boolean isSet(_Fields field) {
18224 switch (field) {
18225 case TABLE_NAME:
18226 return isSetTableName();
18227 case ROW_BATCHES:
18228 return isSetRowBatches();
18229 }
18230 throw new IllegalStateException();
18231 }
18232
18233 public boolean isSet(int fieldID) {
18234 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18235 }
18236
18237 @Override
18238 public boolean equals(Object that) {
18239 if (that == null)
18240 return false;
18241 if (that instanceof mutateRows_args)
18242 return this.equals((mutateRows_args)that);
18243 return false;
18244 }
18245
18246 public boolean equals(mutateRows_args that) {
18247 if (that == null)
18248 return false;
18249
18250 boolean this_present_tableName = true && this.isSetTableName();
18251 boolean that_present_tableName = true && that.isSetTableName();
18252 if (this_present_tableName || that_present_tableName) {
18253 if (!(this_present_tableName && that_present_tableName))
18254 return false;
18255 if (!java.util.Arrays.equals(this.tableName, that.tableName))
18256 return false;
18257 }
18258
18259 boolean this_present_rowBatches = true && this.isSetRowBatches();
18260 boolean that_present_rowBatches = true && that.isSetRowBatches();
18261 if (this_present_rowBatches || that_present_rowBatches) {
18262 if (!(this_present_rowBatches && that_present_rowBatches))
18263 return false;
18264 if (!this.rowBatches.equals(that.rowBatches))
18265 return false;
18266 }
18267
18268 return true;
18269 }
18270
18271 @Override
18272 public int hashCode() {
18273 HashCodeBuilder builder = new HashCodeBuilder();
18274
18275 boolean present_tableName = true && (isSetTableName());
18276 builder.append(present_tableName);
18277 if (present_tableName)
18278 builder.append(tableName);
18279
18280 boolean present_rowBatches = true && (isSetRowBatches());
18281 builder.append(present_rowBatches);
18282 if (present_rowBatches)
18283 builder.append(rowBatches);
18284
18285 return builder.toHashCode();
18286 }
18287
18288 public int compareTo(mutateRows_args other) {
18289 if (!getClass().equals(other.getClass())) {
18290 return getClass().getName().compareTo(other.getClass().getName());
18291 }
18292
18293 int lastComparison = 0;
18294 mutateRows_args typedOther = (mutateRows_args)other;
18295
18296 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
18297 if (lastComparison != 0) {
18298 return lastComparison;
18299 }
18300 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
18301 if (lastComparison != 0) {
18302 return lastComparison;
18303 }
18304 lastComparison = Boolean.valueOf(isSetRowBatches()).compareTo(isSetRowBatches());
18305 if (lastComparison != 0) {
18306 return lastComparison;
18307 }
18308 lastComparison = TBaseHelper.compareTo(rowBatches, typedOther.rowBatches);
18309 if (lastComparison != 0) {
18310 return lastComparison;
18311 }
18312 return 0;
18313 }
18314
18315 public void read(TProtocol iprot) throws TException {
18316 TField field;
18317 iprot.readStructBegin();
18318 while (true)
18319 {
18320 field = iprot.readFieldBegin();
18321 if (field.type == TType.STOP) {
18322 break;
18323 }
18324 _Fields fieldId = _Fields.findByThriftId(field.id);
18325 if (fieldId == null) {
18326 TProtocolUtil.skip(iprot, field.type);
18327 } else {
18328 switch (fieldId) {
18329 case TABLE_NAME:
18330 if (field.type == TType.STRING) {
18331 this.tableName = iprot.readBinary();
18332 } else {
18333 TProtocolUtil.skip(iprot, field.type);
18334 }
18335 break;
18336 case ROW_BATCHES:
18337 if (field.type == TType.LIST) {
18338 {
18339 TList _list70 = iprot.readListBegin();
18340 this.rowBatches = new ArrayList<BatchMutation>(_list70.size);
18341 for (int _i71 = 0; _i71 < _list70.size; ++_i71)
18342 {
18343 BatchMutation _elem72;
18344 _elem72 = new BatchMutation();
18345 _elem72.read(iprot);
18346 this.rowBatches.add(_elem72);
18347 }
18348 iprot.readListEnd();
18349 }
18350 } else {
18351 TProtocolUtil.skip(iprot, field.type);
18352 }
18353 break;
18354 }
18355 iprot.readFieldEnd();
18356 }
18357 }
18358 iprot.readStructEnd();
18359
18360
18361 validate();
18362 }
18363
18364 public void write(TProtocol oprot) throws TException {
18365 validate();
18366
18367 oprot.writeStructBegin(STRUCT_DESC);
18368 if (this.tableName != null) {
18369 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
18370 oprot.writeBinary(this.tableName);
18371 oprot.writeFieldEnd();
18372 }
18373 if (this.rowBatches != null) {
18374 oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
18375 {
18376 oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size()));
18377 for (BatchMutation _iter73 : this.rowBatches)
18378 {
18379 _iter73.write(oprot);
18380 }
18381 oprot.writeListEnd();
18382 }
18383 oprot.writeFieldEnd();
18384 }
18385 oprot.writeFieldStop();
18386 oprot.writeStructEnd();
18387 }
18388
18389 @Override
18390 public String toString() {
18391 StringBuilder sb = new StringBuilder("mutateRows_args(");
18392 boolean first = true;
18393
18394 sb.append("tableName:");
18395 if (this.tableName == null) {
18396 sb.append("null");
18397 } else {
18398 sb.append(this.tableName);
18399 }
18400 first = false;
18401 if (!first) sb.append(", ");
18402 sb.append("rowBatches:");
18403 if (this.rowBatches == null) {
18404 sb.append("null");
18405 } else {
18406 sb.append(this.rowBatches);
18407 }
18408 first = false;
18409 sb.append(")");
18410 return sb.toString();
18411 }
18412
18413 public void validate() throws TException {
18414
18415 }
18416
18417 }
18418
18419 public static class mutateRows_result implements TBase<mutateRows_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_result> {
18420 private static final TStruct STRUCT_DESC = new TStruct("mutateRows_result");
18421
18422 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
18423 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
18424
18425 public IOError io;
18426 public IllegalArgument ia;
18427
18428
18429 public enum _Fields implements TFieldIdEnum {
18430 IO((short)1, "io"),
18431 IA((short)2, "ia");
18432
18433 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18434 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18435
18436 static {
18437 for (_Fields field : EnumSet.allOf(_Fields.class)) {
18438 byId.put((int)field._thriftId, field);
18439 byName.put(field.getFieldName(), field);
18440 }
18441 }
18442
18443
18444
18445
18446 public static _Fields findByThriftId(int fieldId) {
18447 return byId.get(fieldId);
18448 }
18449
18450
18451
18452
18453
18454 public static _Fields findByThriftIdOrThrow(int fieldId) {
18455 _Fields fields = findByThriftId(fieldId);
18456 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18457 return fields;
18458 }
18459
18460
18461
18462
18463 public static _Fields findByName(String name) {
18464 return byName.get(name);
18465 }
18466
18467 private final short _thriftId;
18468 private final String _fieldName;
18469
18470 _Fields(short thriftId, String fieldName) {
18471 _thriftId = thriftId;
18472 _fieldName = fieldName;
18473 }
18474
18475 public short getThriftFieldId() {
18476 return _thriftId;
18477 }
18478
18479 public String getFieldName() {
18480 return _fieldName;
18481 }
18482 }
18483
18484
18485
18486 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18487 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
18488 new FieldValueMetaData(TType.STRUCT)));
18489 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
18490 new FieldValueMetaData(TType.STRUCT)));
18491 }});
18492
18493 static {
18494 FieldMetaData.addStructMetaDataMap(mutateRows_result.class, metaDataMap);
18495 }
18496
18497 public mutateRows_result() {
18498 }
18499
18500 public mutateRows_result(
18501 IOError io,
18502 IllegalArgument ia)
18503 {
18504 this();
18505 this.io = io;
18506 this.ia = ia;
18507 }
18508
18509
18510
18511
18512 public mutateRows_result(mutateRows_result other) {
18513 if (other.isSetIo()) {
18514 this.io = new IOError(other.io);
18515 }
18516 if (other.isSetIa()) {
18517 this.ia = new IllegalArgument(other.ia);
18518 }
18519 }
18520
18521 public mutateRows_result deepCopy() {
18522 return new mutateRows_result(this);
18523 }
18524
18525 @Deprecated
18526 public mutateRows_result clone() {
18527 return new mutateRows_result(this);
18528 }
18529
18530 public IOError getIo() {
18531 return this.io;
18532 }
18533
18534 public mutateRows_result setIo(IOError io) {
18535 this.io = io;
18536 return this;
18537 }
18538
18539 public void unsetIo() {
18540 this.io = null;
18541 }
18542
18543
18544 public boolean isSetIo() {
18545 return this.io != null;
18546 }
18547
18548 public void setIoIsSet(boolean value) {
18549 if (!value) {
18550 this.io = null;
18551 }
18552 }
18553
18554 public IllegalArgument getIa() {
18555 return this.ia;
18556 }
18557
18558 public mutateRows_result setIa(IllegalArgument ia) {
18559 this.ia = ia;
18560 return this;
18561 }
18562
18563 public void unsetIa() {
18564 this.ia = null;
18565 }
18566
18567
18568 public boolean isSetIa() {
18569 return this.ia != null;
18570 }
18571
18572 public void setIaIsSet(boolean value) {
18573 if (!value) {
18574 this.ia = null;
18575 }
18576 }
18577
18578 public void setFieldValue(_Fields field, Object value) {
18579 switch (field) {
18580 case IO:
18581 if (value == null) {
18582 unsetIo();
18583 } else {
18584 setIo((IOError)value);
18585 }
18586 break;
18587
18588 case IA:
18589 if (value == null) {
18590 unsetIa();
18591 } else {
18592 setIa((IllegalArgument)value);
18593 }
18594 break;
18595
18596 }
18597 }
18598
18599 public void setFieldValue(int fieldID, Object value) {
18600 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
18601 }
18602
18603 public Object getFieldValue(_Fields field) {
18604 switch (field) {
18605 case IO:
18606 return getIo();
18607
18608 case IA:
18609 return getIa();
18610
18611 }
18612 throw new IllegalStateException();
18613 }
18614
18615 public Object getFieldValue(int fieldId) {
18616 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
18617 }
18618
18619
18620 public boolean isSet(_Fields field) {
18621 switch (field) {
18622 case IO:
18623 return isSetIo();
18624 case IA:
18625 return isSetIa();
18626 }
18627 throw new IllegalStateException();
18628 }
18629
18630 public boolean isSet(int fieldID) {
18631 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18632 }
18633
18634 @Override
18635 public boolean equals(Object that) {
18636 if (that == null)
18637 return false;
18638 if (that instanceof mutateRows_result)
18639 return this.equals((mutateRows_result)that);
18640 return false;
18641 }
18642
18643 public boolean equals(mutateRows_result that) {
18644 if (that == null)
18645 return false;
18646
18647 boolean this_present_io = true && this.isSetIo();
18648 boolean that_present_io = true && that.isSetIo();
18649 if (this_present_io || that_present_io) {
18650 if (!(this_present_io && that_present_io))
18651 return false;
18652 if (!this.io.equals(that.io))
18653 return false;
18654 }
18655
18656 boolean this_present_ia = true && this.isSetIa();
18657 boolean that_present_ia = true && that.isSetIa();
18658 if (this_present_ia || that_present_ia) {
18659 if (!(this_present_ia && that_present_ia))
18660 return false;
18661 if (!this.ia.equals(that.ia))
18662 return false;
18663 }
18664
18665 return true;
18666 }
18667
18668 @Override
18669 public int hashCode() {
18670 HashCodeBuilder builder = new HashCodeBuilder();
18671
18672 boolean present_io = true && (isSetIo());
18673 builder.append(present_io);
18674 if (present_io)
18675 builder.append(io);
18676
18677 boolean present_ia = true && (isSetIa());
18678 builder.append(present_ia);
18679 if (present_ia)
18680 builder.append(ia);
18681
18682 return builder.toHashCode();
18683 }
18684
18685 public int compareTo(mutateRows_result other) {
18686 if (!getClass().equals(other.getClass())) {
18687 return getClass().getName().compareTo(other.getClass().getName());
18688 }
18689
18690 int lastComparison = 0;
18691 mutateRows_result typedOther = (mutateRows_result)other;
18692
18693 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
18694 if (lastComparison != 0) {
18695 return lastComparison;
18696 }
18697 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
18698 if (lastComparison != 0) {
18699 return lastComparison;
18700 }
18701 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
18702 if (lastComparison != 0) {
18703 return lastComparison;
18704 }
18705 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
18706 if (lastComparison != 0) {
18707 return lastComparison;
18708 }
18709 return 0;
18710 }
18711
18712 public void read(TProtocol iprot) throws TException {
18713 TField field;
18714 iprot.readStructBegin();
18715 while (true)
18716 {
18717 field = iprot.readFieldBegin();
18718 if (field.type == TType.STOP) {
18719 break;
18720 }
18721 _Fields fieldId = _Fields.findByThriftId(field.id);
18722 if (fieldId == null) {
18723 TProtocolUtil.skip(iprot, field.type);
18724 } else {
18725 switch (fieldId) {
18726 case IO:
18727 if (field.type == TType.STRUCT) {
18728 this.io = new IOError();
18729 this.io.read(iprot);
18730 } else {
18731 TProtocolUtil.skip(iprot, field.type);
18732 }
18733 break;
18734 case IA:
18735 if (field.type == TType.STRUCT) {
18736 this.ia = new IllegalArgument();
18737 this.ia.read(iprot);
18738 } else {
18739 TProtocolUtil.skip(iprot, field.type);
18740 }
18741 break;
18742 }
18743 iprot.readFieldEnd();
18744 }
18745 }
18746 iprot.readStructEnd();
18747
18748
18749 validate();
18750 }
18751
18752 public void write(TProtocol oprot) throws TException {
18753 oprot.writeStructBegin(STRUCT_DESC);
18754
18755 if (this.isSetIo()) {
18756 oprot.writeFieldBegin(IO_FIELD_DESC);
18757 this.io.write(oprot);
18758 oprot.writeFieldEnd();
18759 } else if (this.isSetIa()) {
18760 oprot.writeFieldBegin(IA_FIELD_DESC);
18761 this.ia.write(oprot);
18762 oprot.writeFieldEnd();
18763 }
18764 oprot.writeFieldStop();
18765 oprot.writeStructEnd();
18766 }
18767
18768 @Override
18769 public String toString() {
18770 StringBuilder sb = new StringBuilder("mutateRows_result(");
18771 boolean first = true;
18772
18773 sb.append("io:");
18774 if (this.io == null) {
18775 sb.append("null");
18776 } else {
18777 sb.append(this.io);
18778 }
18779 first = false;
18780 if (!first) sb.append(", ");
18781 sb.append("ia:");
18782 if (this.ia == null) {
18783 sb.append("null");
18784 } else {
18785 sb.append(this.ia);
18786 }
18787 first = false;
18788 sb.append(")");
18789 return sb.toString();
18790 }
18791
18792 public void validate() throws TException {
18793
18794 }
18795
18796 }
18797
18798 public static class mutateRowsTs_args implements TBase<mutateRowsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_args> {
18799 private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_args");
18800
18801 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
18802 private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2);
18803 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
18804
18805
18806
18807
18808 public byte[] tableName;
18809
18810
18811
18812 public List<BatchMutation> rowBatches;
18813
18814
18815
18816 public long timestamp;
18817
18818
18819 public enum _Fields implements TFieldIdEnum {
18820
18821
18822
18823 TABLE_NAME((short)1, "tableName"),
18824
18825
18826
18827 ROW_BATCHES((short)2, "rowBatches"),
18828
18829
18830
18831 TIMESTAMP((short)3, "timestamp");
18832
18833 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18834 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18835
18836 static {
18837 for (_Fields field : EnumSet.allOf(_Fields.class)) {
18838 byId.put((int)field._thriftId, field);
18839 byName.put(field.getFieldName(), field);
18840 }
18841 }
18842
18843
18844
18845
18846 public static _Fields findByThriftId(int fieldId) {
18847 return byId.get(fieldId);
18848 }
18849
18850
18851
18852
18853
18854 public static _Fields findByThriftIdOrThrow(int fieldId) {
18855 _Fields fields = findByThriftId(fieldId);
18856 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18857 return fields;
18858 }
18859
18860
18861
18862
18863 public static _Fields findByName(String name) {
18864 return byName.get(name);
18865 }
18866
18867 private final short _thriftId;
18868 private final String _fieldName;
18869
18870 _Fields(short thriftId, String fieldName) {
18871 _thriftId = thriftId;
18872 _fieldName = fieldName;
18873 }
18874
18875 public short getThriftFieldId() {
18876 return _thriftId;
18877 }
18878
18879 public String getFieldName() {
18880 return _fieldName;
18881 }
18882 }
18883
18884
18885 private static final int __TIMESTAMP_ISSET_ID = 0;
18886 private BitSet __isset_bit_vector = new BitSet(1);
18887
18888 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18889 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
18890 new FieldValueMetaData(TType.STRING)));
18891 put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT,
18892 new ListMetaData(TType.LIST,
18893 new StructMetaData(TType.STRUCT, BatchMutation.class))));
18894 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
18895 new FieldValueMetaData(TType.I64)));
18896 }});
18897
18898 static {
18899 FieldMetaData.addStructMetaDataMap(mutateRowsTs_args.class, metaDataMap);
18900 }
18901
18902 public mutateRowsTs_args() {
18903 }
18904
18905 public mutateRowsTs_args(
18906 byte[] tableName,
18907 List<BatchMutation> rowBatches,
18908 long timestamp)
18909 {
18910 this();
18911 this.tableName = tableName;
18912 this.rowBatches = rowBatches;
18913 this.timestamp = timestamp;
18914 setTimestampIsSet(true);
18915 }
18916
18917
18918
18919
18920 public mutateRowsTs_args(mutateRowsTs_args other) {
18921 __isset_bit_vector.clear();
18922 __isset_bit_vector.or(other.__isset_bit_vector);
18923 if (other.isSetTableName()) {
18924 this.tableName = other.tableName;
18925 }
18926 if (other.isSetRowBatches()) {
18927 List<BatchMutation> __this__rowBatches = new ArrayList<BatchMutation>();
18928 for (BatchMutation other_element : other.rowBatches) {
18929 __this__rowBatches.add(new BatchMutation(other_element));
18930 }
18931 this.rowBatches = __this__rowBatches;
18932 }
18933 this.timestamp = other.timestamp;
18934 }
18935
18936 public mutateRowsTs_args deepCopy() {
18937 return new mutateRowsTs_args(this);
18938 }
18939
18940 @Deprecated
18941 public mutateRowsTs_args clone() {
18942 return new mutateRowsTs_args(this);
18943 }
18944
18945
18946
18947
18948 public byte[] getTableName() {
18949 return this.tableName;
18950 }
18951
18952
18953
18954
18955 public mutateRowsTs_args setTableName(byte[] tableName) {
18956 this.tableName = tableName;
18957 return this;
18958 }
18959
18960 public void unsetTableName() {
18961 this.tableName = null;
18962 }
18963
18964
18965 public boolean isSetTableName() {
18966 return this.tableName != null;
18967 }
18968
18969 public void setTableNameIsSet(boolean value) {
18970 if (!value) {
18971 this.tableName = null;
18972 }
18973 }
18974
18975 public int getRowBatchesSize() {
18976 return (this.rowBatches == null) ? 0 : this.rowBatches.size();
18977 }
18978
18979 public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
18980 return (this.rowBatches == null) ? null : this.rowBatches.iterator();
18981 }
18982
18983 public void addToRowBatches(BatchMutation elem) {
18984 if (this.rowBatches == null) {
18985 this.rowBatches = new ArrayList<BatchMutation>();
18986 }
18987 this.rowBatches.add(elem);
18988 }
18989
18990
18991
18992
18993 public List<BatchMutation> getRowBatches() {
18994 return this.rowBatches;
18995 }
18996
18997
18998
18999
19000 public mutateRowsTs_args setRowBatches(List<BatchMutation> rowBatches) {
19001 this.rowBatches = rowBatches;
19002 return this;
19003 }
19004
19005 public void unsetRowBatches() {
19006 this.rowBatches = null;
19007 }
19008
19009
19010 public boolean isSetRowBatches() {
19011 return this.rowBatches != null;
19012 }
19013
19014 public void setRowBatchesIsSet(boolean value) {
19015 if (!value) {
19016 this.rowBatches = null;
19017 }
19018 }
19019
19020
19021
19022
19023 public long getTimestamp() {
19024 return this.timestamp;
19025 }
19026
19027
19028
19029
19030 public mutateRowsTs_args setTimestamp(long timestamp) {
19031 this.timestamp = timestamp;
19032 setTimestampIsSet(true);
19033 return this;
19034 }
19035
19036 public void unsetTimestamp() {
19037 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
19038 }
19039
19040
19041 public boolean isSetTimestamp() {
19042 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
19043 }
19044
19045 public void setTimestampIsSet(boolean value) {
19046 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
19047 }
19048
19049 public void setFieldValue(_Fields field, Object value) {
19050 switch (field) {
19051 case TABLE_NAME:
19052 if (value == null) {
19053 unsetTableName();
19054 } else {
19055 setTableName((byte[])value);
19056 }
19057 break;
19058
19059 case ROW_BATCHES:
19060 if (value == null) {
19061 unsetRowBatches();
19062 } else {
19063 setRowBatches((List<BatchMutation>)value);
19064 }
19065 break;
19066
19067 case TIMESTAMP:
19068 if (value == null) {
19069 unsetTimestamp();
19070 } else {
19071 setTimestamp((Long)value);
19072 }
19073 break;
19074
19075 }
19076 }
19077
19078 public void setFieldValue(int fieldID, Object value) {
19079 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
19080 }
19081
19082 public Object getFieldValue(_Fields field) {
19083 switch (field) {
19084 case TABLE_NAME:
19085 return getTableName();
19086
19087 case ROW_BATCHES:
19088 return getRowBatches();
19089
19090 case TIMESTAMP:
19091 return new Long(getTimestamp());
19092
19093 }
19094 throw new IllegalStateException();
19095 }
19096
19097 public Object getFieldValue(int fieldId) {
19098 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
19099 }
19100
19101
19102 public boolean isSet(_Fields field) {
19103 switch (field) {
19104 case TABLE_NAME:
19105 return isSetTableName();
19106 case ROW_BATCHES:
19107 return isSetRowBatches();
19108 case TIMESTAMP:
19109 return isSetTimestamp();
19110 }
19111 throw new IllegalStateException();
19112 }
19113
19114 public boolean isSet(int fieldID) {
19115 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
19116 }
19117
19118 @Override
19119 public boolean equals(Object that) {
19120 if (that == null)
19121 return false;
19122 if (that instanceof mutateRowsTs_args)
19123 return this.equals((mutateRowsTs_args)that);
19124 return false;
19125 }
19126
19127 public boolean equals(mutateRowsTs_args that) {
19128 if (that == null)
19129 return false;
19130
19131 boolean this_present_tableName = true && this.isSetTableName();
19132 boolean that_present_tableName = true && that.isSetTableName();
19133 if (this_present_tableName || that_present_tableName) {
19134 if (!(this_present_tableName && that_present_tableName))
19135 return false;
19136 if (!java.util.Arrays.equals(this.tableName, that.tableName))
19137 return false;
19138 }
19139
19140 boolean this_present_rowBatches = true && this.isSetRowBatches();
19141 boolean that_present_rowBatches = true && that.isSetRowBatches();
19142 if (this_present_rowBatches || that_present_rowBatches) {
19143 if (!(this_present_rowBatches && that_present_rowBatches))
19144 return false;
19145 if (!this.rowBatches.equals(that.rowBatches))
19146 return false;
19147 }
19148
19149 boolean this_present_timestamp = true;
19150 boolean that_present_timestamp = true;
19151 if (this_present_timestamp || that_present_timestamp) {
19152 if (!(this_present_timestamp && that_present_timestamp))
19153 return false;
19154 if (this.timestamp != that.timestamp)
19155 return false;
19156 }
19157
19158 return true;
19159 }
19160
19161 @Override
19162 public int hashCode() {
19163 HashCodeBuilder builder = new HashCodeBuilder();
19164
19165 boolean present_tableName = true && (isSetTableName());
19166 builder.append(present_tableName);
19167 if (present_tableName)
19168 builder.append(tableName);
19169
19170 boolean present_rowBatches = true && (isSetRowBatches());
19171 builder.append(present_rowBatches);
19172 if (present_rowBatches)
19173 builder.append(rowBatches);
19174
19175 boolean present_timestamp = true;
19176 builder.append(present_timestamp);
19177 if (present_timestamp)
19178 builder.append(timestamp);
19179
19180 return builder.toHashCode();
19181 }
19182
19183 public int compareTo(mutateRowsTs_args other) {
19184 if (!getClass().equals(other.getClass())) {
19185 return getClass().getName().compareTo(other.getClass().getName());
19186 }
19187
19188 int lastComparison = 0;
19189 mutateRowsTs_args typedOther = (mutateRowsTs_args)other;
19190
19191 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
19192 if (lastComparison != 0) {
19193 return lastComparison;
19194 }
19195 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
19196 if (lastComparison != 0) {
19197 return lastComparison;
19198 }
19199 lastComparison = Boolean.valueOf(isSetRowBatches()).compareTo(isSetRowBatches());
19200 if (lastComparison != 0) {
19201 return lastComparison;
19202 }
19203 lastComparison = TBaseHelper.compareTo(rowBatches, typedOther.rowBatches);
19204 if (lastComparison != 0) {
19205 return lastComparison;
19206 }
19207 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
19208 if (lastComparison != 0) {
19209 return lastComparison;
19210 }
19211 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
19212 if (lastComparison != 0) {
19213 return lastComparison;
19214 }
19215 return 0;
19216 }
19217
19218 public void read(TProtocol iprot) throws TException {
19219 TField field;
19220 iprot.readStructBegin();
19221 while (true)
19222 {
19223 field = iprot.readFieldBegin();
19224 if (field.type == TType.STOP) {
19225 break;
19226 }
19227 _Fields fieldId = _Fields.findByThriftId(field.id);
19228 if (fieldId == null) {
19229 TProtocolUtil.skip(iprot, field.type);
19230 } else {
19231 switch (fieldId) {
19232 case TABLE_NAME:
19233 if (field.type == TType.STRING) {
19234 this.tableName = iprot.readBinary();
19235 } else {
19236 TProtocolUtil.skip(iprot, field.type);
19237 }
19238 break;
19239 case ROW_BATCHES:
19240 if (field.type == TType.LIST) {
19241 {
19242 TList _list74 = iprot.readListBegin();
19243 this.rowBatches = new ArrayList<BatchMutation>(_list74.size);
19244 for (int _i75 = 0; _i75 < _list74.size; ++_i75)
19245 {
19246 BatchMutation _elem76;
19247 _elem76 = new BatchMutation();
19248 _elem76.read(iprot);
19249 this.rowBatches.add(_elem76);
19250 }
19251 iprot.readListEnd();
19252 }
19253 } else {
19254 TProtocolUtil.skip(iprot, field.type);
19255 }
19256 break;
19257 case TIMESTAMP:
19258 if (field.type == TType.I64) {
19259 this.timestamp = iprot.readI64();
19260 setTimestampIsSet(true);
19261 } else {
19262 TProtocolUtil.skip(iprot, field.type);
19263 }
19264 break;
19265 }
19266 iprot.readFieldEnd();
19267 }
19268 }
19269 iprot.readStructEnd();
19270
19271
19272 validate();
19273 }
19274
19275 public void write(TProtocol oprot) throws TException {
19276 validate();
19277
19278 oprot.writeStructBegin(STRUCT_DESC);
19279 if (this.tableName != null) {
19280 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
19281 oprot.writeBinary(this.tableName);
19282 oprot.writeFieldEnd();
19283 }
19284 if (this.rowBatches != null) {
19285 oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
19286 {
19287 oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size()));
19288 for (BatchMutation _iter77 : this.rowBatches)
19289 {
19290 _iter77.write(oprot);
19291 }
19292 oprot.writeListEnd();
19293 }
19294 oprot.writeFieldEnd();
19295 }
19296 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
19297 oprot.writeI64(this.timestamp);
19298 oprot.writeFieldEnd();
19299 oprot.writeFieldStop();
19300 oprot.writeStructEnd();
19301 }
19302
19303 @Override
19304 public String toString() {
19305 StringBuilder sb = new StringBuilder("mutateRowsTs_args(");
19306 boolean first = true;
19307
19308 sb.append("tableName:");
19309 if (this.tableName == null) {
19310 sb.append("null");
19311 } else {
19312 sb.append(this.tableName);
19313 }
19314 first = false;
19315 if (!first) sb.append(", ");
19316 sb.append("rowBatches:");
19317 if (this.rowBatches == null) {
19318 sb.append("null");
19319 } else {
19320 sb.append(this.rowBatches);
19321 }
19322 first = false;
19323 if (!first) sb.append(", ");
19324 sb.append("timestamp:");
19325 sb.append(this.timestamp);
19326 first = false;
19327 sb.append(")");
19328 return sb.toString();
19329 }
19330
19331 public void validate() throws TException {
19332
19333 }
19334
19335 }
19336
19337 public static class mutateRowsTs_result implements TBase<mutateRowsTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_result> {
19338 private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_result");
19339
19340 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
19341 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
19342
19343 public IOError io;
19344 public IllegalArgument ia;
19345
19346
19347 public enum _Fields implements TFieldIdEnum {
19348 IO((short)1, "io"),
19349 IA((short)2, "ia");
19350
19351 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
19352 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
19353
19354 static {
19355 for (_Fields field : EnumSet.allOf(_Fields.class)) {
19356 byId.put((int)field._thriftId, field);
19357 byName.put(field.getFieldName(), field);
19358 }
19359 }
19360
19361
19362
19363
19364 public static _Fields findByThriftId(int fieldId) {
19365 return byId.get(fieldId);
19366 }
19367
19368
19369
19370
19371
19372 public static _Fields findByThriftIdOrThrow(int fieldId) {
19373 _Fields fields = findByThriftId(fieldId);
19374 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
19375 return fields;
19376 }
19377
19378
19379
19380
19381 public static _Fields findByName(String name) {
19382 return byName.get(name);
19383 }
19384
19385 private final short _thriftId;
19386 private final String _fieldName;
19387
19388 _Fields(short thriftId, String fieldName) {
19389 _thriftId = thriftId;
19390 _fieldName = fieldName;
19391 }
19392
19393 public short getThriftFieldId() {
19394 return _thriftId;
19395 }
19396
19397 public String getFieldName() {
19398 return _fieldName;
19399 }
19400 }
19401
19402
19403
19404 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
19405 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
19406 new FieldValueMetaData(TType.STRUCT)));
19407 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
19408 new FieldValueMetaData(TType.STRUCT)));
19409 }});
19410
19411 static {
19412 FieldMetaData.addStructMetaDataMap(mutateRowsTs_result.class, metaDataMap);
19413 }
19414
19415 public mutateRowsTs_result() {
19416 }
19417
19418 public mutateRowsTs_result(
19419 IOError io,
19420 IllegalArgument ia)
19421 {
19422 this();
19423 this.io = io;
19424 this.ia = ia;
19425 }
19426
19427
19428
19429
19430 public mutateRowsTs_result(mutateRowsTs_result other) {
19431 if (other.isSetIo()) {
19432 this.io = new IOError(other.io);
19433 }
19434 if (other.isSetIa()) {
19435 this.ia = new IllegalArgument(other.ia);
19436 }
19437 }
19438
19439 public mutateRowsTs_result deepCopy() {
19440 return new mutateRowsTs_result(this);
19441 }
19442
19443 @Deprecated
19444 public mutateRowsTs_result clone() {
19445 return new mutateRowsTs_result(this);
19446 }
19447
19448 public IOError getIo() {
19449 return this.io;
19450 }
19451
19452 public mutateRowsTs_result setIo(IOError io) {
19453 this.io = io;
19454 return this;
19455 }
19456
19457 public void unsetIo() {
19458 this.io = null;
19459 }
19460
19461
19462 public boolean isSetIo() {
19463 return this.io != null;
19464 }
19465
19466 public void setIoIsSet(boolean value) {
19467 if (!value) {
19468 this.io = null;
19469 }
19470 }
19471
19472 public IllegalArgument getIa() {
19473 return this.ia;
19474 }
19475
19476 public mutateRowsTs_result setIa(IllegalArgument ia) {
19477 this.ia = ia;
19478 return this;
19479 }
19480
19481 public void unsetIa() {
19482 this.ia = null;
19483 }
19484
19485
19486 public boolean isSetIa() {
19487 return this.ia != null;
19488 }
19489
19490 public void setIaIsSet(boolean value) {
19491 if (!value) {
19492 this.ia = null;
19493 }
19494 }
19495
19496 public void setFieldValue(_Fields field, Object value) {
19497 switch (field) {
19498 case IO:
19499 if (value == null) {
19500 unsetIo();
19501 } else {
19502 setIo((IOError)value);
19503 }
19504 break;
19505
19506 case IA:
19507 if (value == null) {
19508 unsetIa();
19509 } else {
19510 setIa((IllegalArgument)value);
19511 }
19512 break;
19513
19514 }
19515 }
19516
19517 public void setFieldValue(int fieldID, Object value) {
19518 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
19519 }
19520
19521 public Object getFieldValue(_Fields field) {
19522 switch (field) {
19523 case IO:
19524 return getIo();
19525
19526 case IA:
19527 return getIa();
19528
19529 }
19530 throw new IllegalStateException();
19531 }
19532
19533 public Object getFieldValue(int fieldId) {
19534 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
19535 }
19536
19537
19538 public boolean isSet(_Fields field) {
19539 switch (field) {
19540 case IO:
19541 return isSetIo();
19542 case IA:
19543 return isSetIa();
19544 }
19545 throw new IllegalStateException();
19546 }
19547
19548 public boolean isSet(int fieldID) {
19549 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
19550 }
19551
19552 @Override
19553 public boolean equals(Object that) {
19554 if (that == null)
19555 return false;
19556 if (that instanceof mutateRowsTs_result)
19557 return this.equals((mutateRowsTs_result)that);
19558 return false;
19559 }
19560
19561 public boolean equals(mutateRowsTs_result that) {
19562 if (that == null)
19563 return false;
19564
19565 boolean this_present_io = true && this.isSetIo();
19566 boolean that_present_io = true && that.isSetIo();
19567 if (this_present_io || that_present_io) {
19568 if (!(this_present_io && that_present_io))
19569 return false;
19570 if (!this.io.equals(that.io))
19571 return false;
19572 }
19573
19574 boolean this_present_ia = true && this.isSetIa();
19575 boolean that_present_ia = true && that.isSetIa();
19576 if (this_present_ia || that_present_ia) {
19577 if (!(this_present_ia && that_present_ia))
19578 return false;
19579 if (!this.ia.equals(that.ia))
19580 return false;
19581 }
19582
19583 return true;
19584 }
19585
19586 @Override
19587 public int hashCode() {
19588 HashCodeBuilder builder = new HashCodeBuilder();
19589
19590 boolean present_io = true && (isSetIo());
19591 builder.append(present_io);
19592 if (present_io)
19593 builder.append(io);
19594
19595 boolean present_ia = true && (isSetIa());
19596 builder.append(present_ia);
19597 if (present_ia)
19598 builder.append(ia);
19599
19600 return builder.toHashCode();
19601 }
19602
19603 public int compareTo(mutateRowsTs_result other) {
19604 if (!getClass().equals(other.getClass())) {
19605 return getClass().getName().compareTo(other.getClass().getName());
19606 }
19607
19608 int lastComparison = 0;
19609 mutateRowsTs_result typedOther = (mutateRowsTs_result)other;
19610
19611 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
19612 if (lastComparison != 0) {
19613 return lastComparison;
19614 }
19615 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
19616 if (lastComparison != 0) {
19617 return lastComparison;
19618 }
19619 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
19620 if (lastComparison != 0) {
19621 return lastComparison;
19622 }
19623 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
19624 if (lastComparison != 0) {
19625 return lastComparison;
19626 }
19627 return 0;
19628 }
19629
19630 public void read(TProtocol iprot) throws TException {
19631 TField field;
19632 iprot.readStructBegin();
19633 while (true)
19634 {
19635 field = iprot.readFieldBegin();
19636 if (field.type == TType.STOP) {
19637 break;
19638 }
19639 _Fields fieldId = _Fields.findByThriftId(field.id);
19640 if (fieldId == null) {
19641 TProtocolUtil.skip(iprot, field.type);
19642 } else {
19643 switch (fieldId) {
19644 case IO:
19645 if (field.type == TType.STRUCT) {
19646 this.io = new IOError();
19647 this.io.read(iprot);
19648 } else {
19649 TProtocolUtil.skip(iprot, field.type);
19650 }
19651 break;
19652 case IA:
19653 if (field.type == TType.STRUCT) {
19654 this.ia = new IllegalArgument();
19655 this.ia.read(iprot);
19656 } else {
19657 TProtocolUtil.skip(iprot, field.type);
19658 }
19659 break;
19660 }
19661 iprot.readFieldEnd();
19662 }
19663 }
19664 iprot.readStructEnd();
19665
19666
19667 validate();
19668 }
19669
19670 public void write(TProtocol oprot) throws TException {
19671 oprot.writeStructBegin(STRUCT_DESC);
19672
19673 if (this.isSetIo()) {
19674 oprot.writeFieldBegin(IO_FIELD_DESC);
19675 this.io.write(oprot);
19676 oprot.writeFieldEnd();
19677 } else if (this.isSetIa()) {
19678 oprot.writeFieldBegin(IA_FIELD_DESC);
19679 this.ia.write(oprot);
19680 oprot.writeFieldEnd();
19681 }
19682 oprot.writeFieldStop();
19683 oprot.writeStructEnd();
19684 }
19685
19686 @Override
19687 public String toString() {
19688 StringBuilder sb = new StringBuilder("mutateRowsTs_result(");
19689 boolean first = true;
19690
19691 sb.append("io:");
19692 if (this.io == null) {
19693 sb.append("null");
19694 } else {
19695 sb.append(this.io);
19696 }
19697 first = false;
19698 if (!first) sb.append(", ");
19699 sb.append("ia:");
19700 if (this.ia == null) {
19701 sb.append("null");
19702 } else {
19703 sb.append(this.ia);
19704 }
19705 first = false;
19706 sb.append(")");
19707 return sb.toString();
19708 }
19709
19710 public void validate() throws TException {
19711
19712 }
19713
19714 }
19715
19716 public static class atomicIncrement_args implements TBase<atomicIncrement_args._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_args> {
19717 private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_args");
19718
19719 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
19720 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
19721 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
19722 private static final TField VALUE_FIELD_DESC = new TField("value", TType.I64, (short)4);
19723
19724
19725
19726
19727 public byte[] tableName;
19728
19729
19730
19731 public byte[] row;
19732
19733
19734
19735 public byte[] column;
19736
19737
19738
19739 public long value;
19740
19741
19742 public enum _Fields implements TFieldIdEnum {
19743
19744
19745
19746 TABLE_NAME((short)1, "tableName"),
19747
19748
19749
19750 ROW((short)2, "row"),
19751
19752
19753
19754 COLUMN((short)3, "column"),
19755
19756
19757
19758 VALUE((short)4, "value");
19759
19760 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
19761 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
19762
19763 static {
19764 for (_Fields field : EnumSet.allOf(_Fields.class)) {
19765 byId.put((int)field._thriftId, field);
19766 byName.put(field.getFieldName(), field);
19767 }
19768 }
19769
19770
19771
19772
19773 public static _Fields findByThriftId(int fieldId) {
19774 return byId.get(fieldId);
19775 }
19776
19777
19778
19779
19780
19781 public static _Fields findByThriftIdOrThrow(int fieldId) {
19782 _Fields fields = findByThriftId(fieldId);
19783 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
19784 return fields;
19785 }
19786
19787
19788
19789
19790 public static _Fields findByName(String name) {
19791 return byName.get(name);
19792 }
19793
19794 private final short _thriftId;
19795 private final String _fieldName;
19796
19797 _Fields(short thriftId, String fieldName) {
19798 _thriftId = thriftId;
19799 _fieldName = fieldName;
19800 }
19801
19802 public short getThriftFieldId() {
19803 return _thriftId;
19804 }
19805
19806 public String getFieldName() {
19807 return _fieldName;
19808 }
19809 }
19810
19811
19812 private static final int __VALUE_ISSET_ID = 0;
19813 private BitSet __isset_bit_vector = new BitSet(1);
19814
19815 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
19816 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
19817 new FieldValueMetaData(TType.STRING)));
19818 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
19819 new FieldValueMetaData(TType.STRING)));
19820 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
19821 new FieldValueMetaData(TType.STRING)));
19822 put(_Fields.VALUE, new FieldMetaData("value", TFieldRequirementType.DEFAULT,
19823 new FieldValueMetaData(TType.I64)));
19824 }});
19825
19826 static {
19827 FieldMetaData.addStructMetaDataMap(atomicIncrement_args.class, metaDataMap);
19828 }
19829
19830 public atomicIncrement_args() {
19831 }
19832
19833 public atomicIncrement_args(
19834 byte[] tableName,
19835 byte[] row,
19836 byte[] column,
19837 long value)
19838 {
19839 this();
19840 this.tableName = tableName;
19841 this.row = row;
19842 this.column = column;
19843 this.value = value;
19844 setValueIsSet(true);
19845 }
19846
19847
19848
19849
19850 public atomicIncrement_args(atomicIncrement_args other) {
19851 __isset_bit_vector.clear();
19852 __isset_bit_vector.or(other.__isset_bit_vector);
19853 if (other.isSetTableName()) {
19854 this.tableName = other.tableName;
19855 }
19856 if (other.isSetRow()) {
19857 this.row = other.row;
19858 }
19859 if (other.isSetColumn()) {
19860 this.column = other.column;
19861 }
19862 this.value = other.value;
19863 }
19864
19865 public atomicIncrement_args deepCopy() {
19866 return new atomicIncrement_args(this);
19867 }
19868
19869 @Deprecated
19870 public atomicIncrement_args clone() {
19871 return new atomicIncrement_args(this);
19872 }
19873
19874
19875
19876
19877 public byte[] getTableName() {
19878 return this.tableName;
19879 }
19880
19881
19882
19883
19884 public atomicIncrement_args setTableName(byte[] tableName) {
19885 this.tableName = tableName;
19886 return this;
19887 }
19888
19889 public void unsetTableName() {
19890 this.tableName = null;
19891 }
19892
19893
19894 public boolean isSetTableName() {
19895 return this.tableName != null;
19896 }
19897
19898 public void setTableNameIsSet(boolean value) {
19899 if (!value) {
19900 this.tableName = null;
19901 }
19902 }
19903
19904
19905
19906
19907 public byte[] getRow() {
19908 return this.row;
19909 }
19910
19911
19912
19913
19914 public atomicIncrement_args setRow(byte[] row) {
19915 this.row = row;
19916 return this;
19917 }
19918
19919 public void unsetRow() {
19920 this.row = null;
19921 }
19922
19923
19924 public boolean isSetRow() {
19925 return this.row != null;
19926 }
19927
19928 public void setRowIsSet(boolean value) {
19929 if (!value) {
19930 this.row = null;
19931 }
19932 }
19933
19934
19935
19936
19937 public byte[] getColumn() {
19938 return this.column;
19939 }
19940
19941
19942
19943
19944 public atomicIncrement_args setColumn(byte[] column) {
19945 this.column = column;
19946 return this;
19947 }
19948
19949 public void unsetColumn() {
19950 this.column = null;
19951 }
19952
19953
19954 public boolean isSetColumn() {
19955 return this.column != null;
19956 }
19957
19958 public void setColumnIsSet(boolean value) {
19959 if (!value) {
19960 this.column = null;
19961 }
19962 }
19963
19964
19965
19966
19967 public long getValue() {
19968 return this.value;
19969 }
19970
19971
19972
19973
19974 public atomicIncrement_args setValue(long value) {
19975 this.value = value;
19976 setValueIsSet(true);
19977 return this;
19978 }
19979
19980 public void unsetValue() {
19981 __isset_bit_vector.clear(__VALUE_ISSET_ID);
19982 }
19983
19984
19985 public boolean isSetValue() {
19986 return __isset_bit_vector.get(__VALUE_ISSET_ID);
19987 }
19988
19989 public void setValueIsSet(boolean value) {
19990 __isset_bit_vector.set(__VALUE_ISSET_ID, value);
19991 }
19992
19993 public void setFieldValue(_Fields field, Object value) {
19994 switch (field) {
19995 case TABLE_NAME:
19996 if (value == null) {
19997 unsetTableName();
19998 } else {
19999 setTableName((byte[])value);
20000 }
20001 break;
20002
20003 case ROW:
20004 if (value == null) {
20005 unsetRow();
20006 } else {
20007 setRow((byte[])value);
20008 }
20009 break;
20010
20011 case COLUMN:
20012 if (value == null) {
20013 unsetColumn();
20014 } else {
20015 setColumn((byte[])value);
20016 }
20017 break;
20018
20019 case VALUE:
20020 if (value == null) {
20021 unsetValue();
20022 } else {
20023 setValue((Long)value);
20024 }
20025 break;
20026
20027 }
20028 }
20029
20030 public void setFieldValue(int fieldID, Object value) {
20031 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
20032 }
20033
20034 public Object getFieldValue(_Fields field) {
20035 switch (field) {
20036 case TABLE_NAME:
20037 return getTableName();
20038
20039 case ROW:
20040 return getRow();
20041
20042 case COLUMN:
20043 return getColumn();
20044
20045 case VALUE:
20046 return new Long(getValue());
20047
20048 }
20049 throw new IllegalStateException();
20050 }
20051
20052 public Object getFieldValue(int fieldId) {
20053 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
20054 }
20055
20056
20057 public boolean isSet(_Fields field) {
20058 switch (field) {
20059 case TABLE_NAME:
20060 return isSetTableName();
20061 case ROW:
20062 return isSetRow();
20063 case COLUMN:
20064 return isSetColumn();
20065 case VALUE:
20066 return isSetValue();
20067 }
20068 throw new IllegalStateException();
20069 }
20070
20071 public boolean isSet(int fieldID) {
20072 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
20073 }
20074
20075 @Override
20076 public boolean equals(Object that) {
20077 if (that == null)
20078 return false;
20079 if (that instanceof atomicIncrement_args)
20080 return this.equals((atomicIncrement_args)that);
20081 return false;
20082 }
20083
20084 public boolean equals(atomicIncrement_args that) {
20085 if (that == null)
20086 return false;
20087
20088 boolean this_present_tableName = true && this.isSetTableName();
20089 boolean that_present_tableName = true && that.isSetTableName();
20090 if (this_present_tableName || that_present_tableName) {
20091 if (!(this_present_tableName && that_present_tableName))
20092 return false;
20093 if (!java.util.Arrays.equals(this.tableName, that.tableName))
20094 return false;
20095 }
20096
20097 boolean this_present_row = true && this.isSetRow();
20098 boolean that_present_row = true && that.isSetRow();
20099 if (this_present_row || that_present_row) {
20100 if (!(this_present_row && that_present_row))
20101 return false;
20102 if (!java.util.Arrays.equals(this.row, that.row))
20103 return false;
20104 }
20105
20106 boolean this_present_column = true && this.isSetColumn();
20107 boolean that_present_column = true && that.isSetColumn();
20108 if (this_present_column || that_present_column) {
20109 if (!(this_present_column && that_present_column))
20110 return false;
20111 if (!java.util.Arrays.equals(this.column, that.column))
20112 return false;
20113 }
20114
20115 boolean this_present_value = true;
20116 boolean that_present_value = true;
20117 if (this_present_value || that_present_value) {
20118 if (!(this_present_value && that_present_value))
20119 return false;
20120 if (this.value != that.value)
20121 return false;
20122 }
20123
20124 return true;
20125 }
20126
20127 @Override
20128 public int hashCode() {
20129 HashCodeBuilder builder = new HashCodeBuilder();
20130
20131 boolean present_tableName = true && (isSetTableName());
20132 builder.append(present_tableName);
20133 if (present_tableName)
20134 builder.append(tableName);
20135
20136 boolean present_row = true && (isSetRow());
20137 builder.append(present_row);
20138 if (present_row)
20139 builder.append(row);
20140
20141 boolean present_column = true && (isSetColumn());
20142 builder.append(present_column);
20143 if (present_column)
20144 builder.append(column);
20145
20146 boolean present_value = true;
20147 builder.append(present_value);
20148 if (present_value)
20149 builder.append(value);
20150
20151 return builder.toHashCode();
20152 }
20153
20154 public int compareTo(atomicIncrement_args other) {
20155 if (!getClass().equals(other.getClass())) {
20156 return getClass().getName().compareTo(other.getClass().getName());
20157 }
20158
20159 int lastComparison = 0;
20160 atomicIncrement_args typedOther = (atomicIncrement_args)other;
20161
20162 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
20163 if (lastComparison != 0) {
20164 return lastComparison;
20165 }
20166 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
20167 if (lastComparison != 0) {
20168 return lastComparison;
20169 }
20170 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
20171 if (lastComparison != 0) {
20172 return lastComparison;
20173 }
20174 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
20175 if (lastComparison != 0) {
20176 return lastComparison;
20177 }
20178 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
20179 if (lastComparison != 0) {
20180 return lastComparison;
20181 }
20182 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
20183 if (lastComparison != 0) {
20184 return lastComparison;
20185 }
20186 lastComparison = Boolean.valueOf(isSetValue()).compareTo(isSetValue());
20187 if (lastComparison != 0) {
20188 return lastComparison;
20189 }
20190 lastComparison = TBaseHelper.compareTo(value, typedOther.value);
20191 if (lastComparison != 0) {
20192 return lastComparison;
20193 }
20194 return 0;
20195 }
20196
20197 public void read(TProtocol iprot) throws TException {
20198 TField field;
20199 iprot.readStructBegin();
20200 while (true)
20201 {
20202 field = iprot.readFieldBegin();
20203 if (field.type == TType.STOP) {
20204 break;
20205 }
20206 _Fields fieldId = _Fields.findByThriftId(field.id);
20207 if (fieldId == null) {
20208 TProtocolUtil.skip(iprot, field.type);
20209 } else {
20210 switch (fieldId) {
20211 case TABLE_NAME:
20212 if (field.type == TType.STRING) {
20213 this.tableName = iprot.readBinary();
20214 } else {
20215 TProtocolUtil.skip(iprot, field.type);
20216 }
20217 break;
20218 case ROW:
20219 if (field.type == TType.STRING) {
20220 this.row = iprot.readBinary();
20221 } else {
20222 TProtocolUtil.skip(iprot, field.type);
20223 }
20224 break;
20225 case COLUMN:
20226 if (field.type == TType.STRING) {
20227 this.column = iprot.readBinary();
20228 } else {
20229 TProtocolUtil.skip(iprot, field.type);
20230 }
20231 break;
20232 case VALUE:
20233 if (field.type == TType.I64) {
20234 this.value = iprot.readI64();
20235 setValueIsSet(true);
20236 } else {
20237 TProtocolUtil.skip(iprot, field.type);
20238 }
20239 break;
20240 }
20241 iprot.readFieldEnd();
20242 }
20243 }
20244 iprot.readStructEnd();
20245
20246
20247 validate();
20248 }
20249
20250 public void write(TProtocol oprot) throws TException {
20251 validate();
20252
20253 oprot.writeStructBegin(STRUCT_DESC);
20254 if (this.tableName != null) {
20255 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
20256 oprot.writeBinary(this.tableName);
20257 oprot.writeFieldEnd();
20258 }
20259 if (this.row != null) {
20260 oprot.writeFieldBegin(ROW_FIELD_DESC);
20261 oprot.writeBinary(this.row);
20262 oprot.writeFieldEnd();
20263 }
20264 if (this.column != null) {
20265 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
20266 oprot.writeBinary(this.column);
20267 oprot.writeFieldEnd();
20268 }
20269 oprot.writeFieldBegin(VALUE_FIELD_DESC);
20270 oprot.writeI64(this.value);
20271 oprot.writeFieldEnd();
20272 oprot.writeFieldStop();
20273 oprot.writeStructEnd();
20274 }
20275
20276 @Override
20277 public String toString() {
20278 StringBuilder sb = new StringBuilder("atomicIncrement_args(");
20279 boolean first = true;
20280
20281 sb.append("tableName:");
20282 if (this.tableName == null) {
20283 sb.append("null");
20284 } else {
20285 sb.append(this.tableName);
20286 }
20287 first = false;
20288 if (!first) sb.append(", ");
20289 sb.append("row:");
20290 if (this.row == null) {
20291 sb.append("null");
20292 } else {
20293 sb.append(this.row);
20294 }
20295 first = false;
20296 if (!first) sb.append(", ");
20297 sb.append("column:");
20298 if (this.column == null) {
20299 sb.append("null");
20300 } else {
20301 sb.append(this.column);
20302 }
20303 first = false;
20304 if (!first) sb.append(", ");
20305 sb.append("value:");
20306 sb.append(this.value);
20307 first = false;
20308 sb.append(")");
20309 return sb.toString();
20310 }
20311
20312 public void validate() throws TException {
20313
20314 }
20315
20316 }
20317
20318 public static class atomicIncrement_result implements TBase<atomicIncrement_result._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_result> {
20319 private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_result");
20320
20321 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short)0);
20322 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
20323 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
20324
20325 public long success;
20326 public IOError io;
20327 public IllegalArgument ia;
20328
20329
20330 public enum _Fields implements TFieldIdEnum {
20331 SUCCESS((short)0, "success"),
20332 IO((short)1, "io"),
20333 IA((short)2, "ia");
20334
20335 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
20336 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
20337
20338 static {
20339 for (_Fields field : EnumSet.allOf(_Fields.class)) {
20340 byId.put((int)field._thriftId, field);
20341 byName.put(field.getFieldName(), field);
20342 }
20343 }
20344
20345
20346
20347
20348 public static _Fields findByThriftId(int fieldId) {
20349 return byId.get(fieldId);
20350 }
20351
20352
20353
20354
20355
20356 public static _Fields findByThriftIdOrThrow(int fieldId) {
20357 _Fields fields = findByThriftId(fieldId);
20358 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
20359 return fields;
20360 }
20361
20362
20363
20364
20365 public static _Fields findByName(String name) {
20366 return byName.get(name);
20367 }
20368
20369 private final short _thriftId;
20370 private final String _fieldName;
20371
20372 _Fields(short thriftId, String fieldName) {
20373 _thriftId = thriftId;
20374 _fieldName = fieldName;
20375 }
20376
20377 public short getThriftFieldId() {
20378 return _thriftId;
20379 }
20380
20381 public String getFieldName() {
20382 return _fieldName;
20383 }
20384 }
20385
20386
20387 private static final int __SUCCESS_ISSET_ID = 0;
20388 private BitSet __isset_bit_vector = new BitSet(1);
20389
20390 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
20391 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
20392 new FieldValueMetaData(TType.I64)));
20393 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
20394 new FieldValueMetaData(TType.STRUCT)));
20395 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
20396 new FieldValueMetaData(TType.STRUCT)));
20397 }});
20398
20399 static {
20400 FieldMetaData.addStructMetaDataMap(atomicIncrement_result.class, metaDataMap);
20401 }
20402
20403 public atomicIncrement_result() {
20404 }
20405
20406 public atomicIncrement_result(
20407 long success,
20408 IOError io,
20409 IllegalArgument ia)
20410 {
20411 this();
20412 this.success = success;
20413 setSuccessIsSet(true);
20414 this.io = io;
20415 this.ia = ia;
20416 }
20417
20418
20419
20420
20421 public atomicIncrement_result(atomicIncrement_result other) {
20422 __isset_bit_vector.clear();
20423 __isset_bit_vector.or(other.__isset_bit_vector);
20424 this.success = other.success;
20425 if (other.isSetIo()) {
20426 this.io = new IOError(other.io);
20427 }
20428 if (other.isSetIa()) {
20429 this.ia = new IllegalArgument(other.ia);
20430 }
20431 }
20432
20433 public atomicIncrement_result deepCopy() {
20434 return new atomicIncrement_result(this);
20435 }
20436
20437 @Deprecated
20438 public atomicIncrement_result clone() {
20439 return new atomicIncrement_result(this);
20440 }
20441
20442 public long getSuccess() {
20443 return this.success;
20444 }
20445
20446 public atomicIncrement_result setSuccess(long success) {
20447 this.success = success;
20448 setSuccessIsSet(true);
20449 return this;
20450 }
20451
20452 public void unsetSuccess() {
20453 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
20454 }
20455
20456
20457 public boolean isSetSuccess() {
20458 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
20459 }
20460
20461 public void setSuccessIsSet(boolean value) {
20462 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
20463 }
20464
20465 public IOError getIo() {
20466 return this.io;
20467 }
20468
20469 public atomicIncrement_result setIo(IOError io) {
20470 this.io = io;
20471 return this;
20472 }
20473
20474 public void unsetIo() {
20475 this.io = null;
20476 }
20477
20478
20479 public boolean isSetIo() {
20480 return this.io != null;
20481 }
20482
20483 public void setIoIsSet(boolean value) {
20484 if (!value) {
20485 this.io = null;
20486 }
20487 }
20488
20489 public IllegalArgument getIa() {
20490 return this.ia;
20491 }
20492
20493 public atomicIncrement_result setIa(IllegalArgument ia) {
20494 this.ia = ia;
20495 return this;
20496 }
20497
20498 public void unsetIa() {
20499 this.ia = null;
20500 }
20501
20502
20503 public boolean isSetIa() {
20504 return this.ia != null;
20505 }
20506
20507 public void setIaIsSet(boolean value) {
20508 if (!value) {
20509 this.ia = null;
20510 }
20511 }
20512
20513 public void setFieldValue(_Fields field, Object value) {
20514 switch (field) {
20515 case SUCCESS:
20516 if (value == null) {
20517 unsetSuccess();
20518 } else {
20519 setSuccess((Long)value);
20520 }
20521 break;
20522
20523 case IO:
20524 if (value == null) {
20525 unsetIo();
20526 } else {
20527 setIo((IOError)value);
20528 }
20529 break;
20530
20531 case IA:
20532 if (value == null) {
20533 unsetIa();
20534 } else {
20535 setIa((IllegalArgument)value);
20536 }
20537 break;
20538
20539 }
20540 }
20541
20542 public void setFieldValue(int fieldID, Object value) {
20543 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
20544 }
20545
20546 public Object getFieldValue(_Fields field) {
20547 switch (field) {
20548 case SUCCESS:
20549 return new Long(getSuccess());
20550
20551 case IO:
20552 return getIo();
20553
20554 case IA:
20555 return getIa();
20556
20557 }
20558 throw new IllegalStateException();
20559 }
20560
20561 public Object getFieldValue(int fieldId) {
20562 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
20563 }
20564
20565
20566 public boolean isSet(_Fields field) {
20567 switch (field) {
20568 case SUCCESS:
20569 return isSetSuccess();
20570 case IO:
20571 return isSetIo();
20572 case IA:
20573 return isSetIa();
20574 }
20575 throw new IllegalStateException();
20576 }
20577
20578 public boolean isSet(int fieldID) {
20579 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
20580 }
20581
20582 @Override
20583 public boolean equals(Object that) {
20584 if (that == null)
20585 return false;
20586 if (that instanceof atomicIncrement_result)
20587 return this.equals((atomicIncrement_result)that);
20588 return false;
20589 }
20590
20591 public boolean equals(atomicIncrement_result that) {
20592 if (that == null)
20593 return false;
20594
20595 boolean this_present_success = true;
20596 boolean that_present_success = true;
20597 if (this_present_success || that_present_success) {
20598 if (!(this_present_success && that_present_success))
20599 return false;
20600 if (this.success != that.success)
20601 return false;
20602 }
20603
20604 boolean this_present_io = true && this.isSetIo();
20605 boolean that_present_io = true && that.isSetIo();
20606 if (this_present_io || that_present_io) {
20607 if (!(this_present_io && that_present_io))
20608 return false;
20609 if (!this.io.equals(that.io))
20610 return false;
20611 }
20612
20613 boolean this_present_ia = true && this.isSetIa();
20614 boolean that_present_ia = true && that.isSetIa();
20615 if (this_present_ia || that_present_ia) {
20616 if (!(this_present_ia && that_present_ia))
20617 return false;
20618 if (!this.ia.equals(that.ia))
20619 return false;
20620 }
20621
20622 return true;
20623 }
20624
20625 @Override
20626 public int hashCode() {
20627 HashCodeBuilder builder = new HashCodeBuilder();
20628
20629 boolean present_success = true;
20630 builder.append(present_success);
20631 if (present_success)
20632 builder.append(success);
20633
20634 boolean present_io = true && (isSetIo());
20635 builder.append(present_io);
20636 if (present_io)
20637 builder.append(io);
20638
20639 boolean present_ia = true && (isSetIa());
20640 builder.append(present_ia);
20641 if (present_ia)
20642 builder.append(ia);
20643
20644 return builder.toHashCode();
20645 }
20646
20647 public int compareTo(atomicIncrement_result other) {
20648 if (!getClass().equals(other.getClass())) {
20649 return getClass().getName().compareTo(other.getClass().getName());
20650 }
20651
20652 int lastComparison = 0;
20653 atomicIncrement_result typedOther = (atomicIncrement_result)other;
20654
20655 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
20656 if (lastComparison != 0) {
20657 return lastComparison;
20658 }
20659 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
20660 if (lastComparison != 0) {
20661 return lastComparison;
20662 }
20663 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
20664 if (lastComparison != 0) {
20665 return lastComparison;
20666 }
20667 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
20668 if (lastComparison != 0) {
20669 return lastComparison;
20670 }
20671 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
20672 if (lastComparison != 0) {
20673 return lastComparison;
20674 }
20675 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
20676 if (lastComparison != 0) {
20677 return lastComparison;
20678 }
20679 return 0;
20680 }
20681
20682 public void read(TProtocol iprot) throws TException {
20683 TField field;
20684 iprot.readStructBegin();
20685 while (true)
20686 {
20687 field = iprot.readFieldBegin();
20688 if (field.type == TType.STOP) {
20689 break;
20690 }
20691 _Fields fieldId = _Fields.findByThriftId(field.id);
20692 if (fieldId == null) {
20693 TProtocolUtil.skip(iprot, field.type);
20694 } else {
20695 switch (fieldId) {
20696 case SUCCESS:
20697 if (field.type == TType.I64) {
20698 this.success = iprot.readI64();
20699 setSuccessIsSet(true);
20700 } else {
20701 TProtocolUtil.skip(iprot, field.type);
20702 }
20703 break;
20704 case IO:
20705 if (field.type == TType.STRUCT) {
20706 this.io = new IOError();
20707 this.io.read(iprot);
20708 } else {
20709 TProtocolUtil.skip(iprot, field.type);
20710 }
20711 break;
20712 case IA:
20713 if (field.type == TType.STRUCT) {
20714 this.ia = new IllegalArgument();
20715 this.ia.read(iprot);
20716 } else {
20717 TProtocolUtil.skip(iprot, field.type);
20718 }
20719 break;
20720 }
20721 iprot.readFieldEnd();
20722 }
20723 }
20724 iprot.readStructEnd();
20725
20726
20727 validate();
20728 }
20729
20730 public void write(TProtocol oprot) throws TException {
20731 oprot.writeStructBegin(STRUCT_DESC);
20732
20733 if (this.isSetSuccess()) {
20734 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20735 oprot.writeI64(this.success);
20736 oprot.writeFieldEnd();
20737 } else if (this.isSetIo()) {
20738 oprot.writeFieldBegin(IO_FIELD_DESC);
20739 this.io.write(oprot);
20740 oprot.writeFieldEnd();
20741 } else if (this.isSetIa()) {
20742 oprot.writeFieldBegin(IA_FIELD_DESC);
20743 this.ia.write(oprot);
20744 oprot.writeFieldEnd();
20745 }
20746 oprot.writeFieldStop();
20747 oprot.writeStructEnd();
20748 }
20749
20750 @Override
20751 public String toString() {
20752 StringBuilder sb = new StringBuilder("atomicIncrement_result(");
20753 boolean first = true;
20754
20755 sb.append("success:");
20756 sb.append(this.success);
20757 first = false;
20758 if (!first) sb.append(", ");
20759 sb.append("io:");
20760 if (this.io == null) {
20761 sb.append("null");
20762 } else {
20763 sb.append(this.io);
20764 }
20765 first = false;
20766 if (!first) sb.append(", ");
20767 sb.append("ia:");
20768 if (this.ia == null) {
20769 sb.append("null");
20770 } else {
20771 sb.append(this.ia);
20772 }
20773 first = false;
20774 sb.append(")");
20775 return sb.toString();
20776 }
20777
20778 public void validate() throws TException {
20779
20780 }
20781
20782 }
20783
20784 public static class deleteAll_args implements TBase<deleteAll_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_args> {
20785 private static final TStruct STRUCT_DESC = new TStruct("deleteAll_args");
20786
20787 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
20788 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
20789 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
20790
20791
20792
20793
20794 public byte[] tableName;
20795
20796
20797
20798 public byte[] row;
20799
20800
20801
20802 public byte[] column;
20803
20804
20805 public enum _Fields implements TFieldIdEnum {
20806
20807
20808
20809 TABLE_NAME((short)1, "tableName"),
20810
20811
20812
20813 ROW((short)2, "row"),
20814
20815
20816
20817 COLUMN((short)3, "column");
20818
20819 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
20820 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
20821
20822 static {
20823 for (_Fields field : EnumSet.allOf(_Fields.class)) {
20824 byId.put((int)field._thriftId, field);
20825 byName.put(field.getFieldName(), field);
20826 }
20827 }
20828
20829
20830
20831
20832 public static _Fields findByThriftId(int fieldId) {
20833 return byId.get(fieldId);
20834 }
20835
20836
20837
20838
20839
20840 public static _Fields findByThriftIdOrThrow(int fieldId) {
20841 _Fields fields = findByThriftId(fieldId);
20842 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
20843 return fields;
20844 }
20845
20846
20847
20848
20849 public static _Fields findByName(String name) {
20850 return byName.get(name);
20851 }
20852
20853 private final short _thriftId;
20854 private final String _fieldName;
20855
20856 _Fields(short thriftId, String fieldName) {
20857 _thriftId = thriftId;
20858 _fieldName = fieldName;
20859 }
20860
20861 public short getThriftFieldId() {
20862 return _thriftId;
20863 }
20864
20865 public String getFieldName() {
20866 return _fieldName;
20867 }
20868 }
20869
20870
20871
20872 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
20873 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
20874 new FieldValueMetaData(TType.STRING)));
20875 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
20876 new FieldValueMetaData(TType.STRING)));
20877 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
20878 new FieldValueMetaData(TType.STRING)));
20879 }});
20880
20881 static {
20882 FieldMetaData.addStructMetaDataMap(deleteAll_args.class, metaDataMap);
20883 }
20884
20885 public deleteAll_args() {
20886 }
20887
20888 public deleteAll_args(
20889 byte[] tableName,
20890 byte[] row,
20891 byte[] column)
20892 {
20893 this();
20894 this.tableName = tableName;
20895 this.row = row;
20896 this.column = column;
20897 }
20898
20899
20900
20901
20902 public deleteAll_args(deleteAll_args other) {
20903 if (other.isSetTableName()) {
20904 this.tableName = other.tableName;
20905 }
20906 if (other.isSetRow()) {
20907 this.row = other.row;
20908 }
20909 if (other.isSetColumn()) {
20910 this.column = other.column;
20911 }
20912 }
20913
20914 public deleteAll_args deepCopy() {
20915 return new deleteAll_args(this);
20916 }
20917
20918 @Deprecated
20919 public deleteAll_args clone() {
20920 return new deleteAll_args(this);
20921 }
20922
20923
20924
20925
20926 public byte[] getTableName() {
20927 return this.tableName;
20928 }
20929
20930
20931
20932
20933 public deleteAll_args setTableName(byte[] tableName) {
20934 this.tableName = tableName;
20935 return this;
20936 }
20937
20938 public void unsetTableName() {
20939 this.tableName = null;
20940 }
20941
20942
20943 public boolean isSetTableName() {
20944 return this.tableName != null;
20945 }
20946
20947 public void setTableNameIsSet(boolean value) {
20948 if (!value) {
20949 this.tableName = null;
20950 }
20951 }
20952
20953
20954
20955
20956 public byte[] getRow() {
20957 return this.row;
20958 }
20959
20960
20961
20962
20963 public deleteAll_args setRow(byte[] row) {
20964 this.row = row;
20965 return this;
20966 }
20967
20968 public void unsetRow() {
20969 this.row = null;
20970 }
20971
20972
20973 public boolean isSetRow() {
20974 return this.row != null;
20975 }
20976
20977 public void setRowIsSet(boolean value) {
20978 if (!value) {
20979 this.row = null;
20980 }
20981 }
20982
20983
20984
20985
20986 public byte[] getColumn() {
20987 return this.column;
20988 }
20989
20990
20991
20992
20993 public deleteAll_args setColumn(byte[] column) {
20994 this.column = column;
20995 return this;
20996 }
20997
20998 public void unsetColumn() {
20999 this.column = null;
21000 }
21001
21002
21003 public boolean isSetColumn() {
21004 return this.column != null;
21005 }
21006
21007 public void setColumnIsSet(boolean value) {
21008 if (!value) {
21009 this.column = null;
21010 }
21011 }
21012
21013 public void setFieldValue(_Fields field, Object value) {
21014 switch (field) {
21015 case TABLE_NAME:
21016 if (value == null) {
21017 unsetTableName();
21018 } else {
21019 setTableName((byte[])value);
21020 }
21021 break;
21022
21023 case ROW:
21024 if (value == null) {
21025 unsetRow();
21026 } else {
21027 setRow((byte[])value);
21028 }
21029 break;
21030
21031 case COLUMN:
21032 if (value == null) {
21033 unsetColumn();
21034 } else {
21035 setColumn((byte[])value);
21036 }
21037 break;
21038
21039 }
21040 }
21041
21042 public void setFieldValue(int fieldID, Object value) {
21043 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21044 }
21045
21046 public Object getFieldValue(_Fields field) {
21047 switch (field) {
21048 case TABLE_NAME:
21049 return getTableName();
21050
21051 case ROW:
21052 return getRow();
21053
21054 case COLUMN:
21055 return getColumn();
21056
21057 }
21058 throw new IllegalStateException();
21059 }
21060
21061 public Object getFieldValue(int fieldId) {
21062 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21063 }
21064
21065
21066 public boolean isSet(_Fields field) {
21067 switch (field) {
21068 case TABLE_NAME:
21069 return isSetTableName();
21070 case ROW:
21071 return isSetRow();
21072 case COLUMN:
21073 return isSetColumn();
21074 }
21075 throw new IllegalStateException();
21076 }
21077
21078 public boolean isSet(int fieldID) {
21079 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21080 }
21081
21082 @Override
21083 public boolean equals(Object that) {
21084 if (that == null)
21085 return false;
21086 if (that instanceof deleteAll_args)
21087 return this.equals((deleteAll_args)that);
21088 return false;
21089 }
21090
21091 public boolean equals(deleteAll_args that) {
21092 if (that == null)
21093 return false;
21094
21095 boolean this_present_tableName = true && this.isSetTableName();
21096 boolean that_present_tableName = true && that.isSetTableName();
21097 if (this_present_tableName || that_present_tableName) {
21098 if (!(this_present_tableName && that_present_tableName))
21099 return false;
21100 if (!java.util.Arrays.equals(this.tableName, that.tableName))
21101 return false;
21102 }
21103
21104 boolean this_present_row = true && this.isSetRow();
21105 boolean that_present_row = true && that.isSetRow();
21106 if (this_present_row || that_present_row) {
21107 if (!(this_present_row && that_present_row))
21108 return false;
21109 if (!java.util.Arrays.equals(this.row, that.row))
21110 return false;
21111 }
21112
21113 boolean this_present_column = true && this.isSetColumn();
21114 boolean that_present_column = true && that.isSetColumn();
21115 if (this_present_column || that_present_column) {
21116 if (!(this_present_column && that_present_column))
21117 return false;
21118 if (!java.util.Arrays.equals(this.column, that.column))
21119 return false;
21120 }
21121
21122 return true;
21123 }
21124
21125 @Override
21126 public int hashCode() {
21127 HashCodeBuilder builder = new HashCodeBuilder();
21128
21129 boolean present_tableName = true && (isSetTableName());
21130 builder.append(present_tableName);
21131 if (present_tableName)
21132 builder.append(tableName);
21133
21134 boolean present_row = true && (isSetRow());
21135 builder.append(present_row);
21136 if (present_row)
21137 builder.append(row);
21138
21139 boolean present_column = true && (isSetColumn());
21140 builder.append(present_column);
21141 if (present_column)
21142 builder.append(column);
21143
21144 return builder.toHashCode();
21145 }
21146
21147 public int compareTo(deleteAll_args other) {
21148 if (!getClass().equals(other.getClass())) {
21149 return getClass().getName().compareTo(other.getClass().getName());
21150 }
21151
21152 int lastComparison = 0;
21153 deleteAll_args typedOther = (deleteAll_args)other;
21154
21155 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
21156 if (lastComparison != 0) {
21157 return lastComparison;
21158 }
21159 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
21160 if (lastComparison != 0) {
21161 return lastComparison;
21162 }
21163 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
21164 if (lastComparison != 0) {
21165 return lastComparison;
21166 }
21167 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
21168 if (lastComparison != 0) {
21169 return lastComparison;
21170 }
21171 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
21172 if (lastComparison != 0) {
21173 return lastComparison;
21174 }
21175 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
21176 if (lastComparison != 0) {
21177 return lastComparison;
21178 }
21179 return 0;
21180 }
21181
21182 public void read(TProtocol iprot) throws TException {
21183 TField field;
21184 iprot.readStructBegin();
21185 while (true)
21186 {
21187 field = iprot.readFieldBegin();
21188 if (field.type == TType.STOP) {
21189 break;
21190 }
21191 _Fields fieldId = _Fields.findByThriftId(field.id);
21192 if (fieldId == null) {
21193 TProtocolUtil.skip(iprot, field.type);
21194 } else {
21195 switch (fieldId) {
21196 case TABLE_NAME:
21197 if (field.type == TType.STRING) {
21198 this.tableName = iprot.readBinary();
21199 } else {
21200 TProtocolUtil.skip(iprot, field.type);
21201 }
21202 break;
21203 case ROW:
21204 if (field.type == TType.STRING) {
21205 this.row = iprot.readBinary();
21206 } else {
21207 TProtocolUtil.skip(iprot, field.type);
21208 }
21209 break;
21210 case COLUMN:
21211 if (field.type == TType.STRING) {
21212 this.column = iprot.readBinary();
21213 } else {
21214 TProtocolUtil.skip(iprot, field.type);
21215 }
21216 break;
21217 }
21218 iprot.readFieldEnd();
21219 }
21220 }
21221 iprot.readStructEnd();
21222
21223
21224 validate();
21225 }
21226
21227 public void write(TProtocol oprot) throws TException {
21228 validate();
21229
21230 oprot.writeStructBegin(STRUCT_DESC);
21231 if (this.tableName != null) {
21232 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
21233 oprot.writeBinary(this.tableName);
21234 oprot.writeFieldEnd();
21235 }
21236 if (this.row != null) {
21237 oprot.writeFieldBegin(ROW_FIELD_DESC);
21238 oprot.writeBinary(this.row);
21239 oprot.writeFieldEnd();
21240 }
21241 if (this.column != null) {
21242 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
21243 oprot.writeBinary(this.column);
21244 oprot.writeFieldEnd();
21245 }
21246 oprot.writeFieldStop();
21247 oprot.writeStructEnd();
21248 }
21249
21250 @Override
21251 public String toString() {
21252 StringBuilder sb = new StringBuilder("deleteAll_args(");
21253 boolean first = true;
21254
21255 sb.append("tableName:");
21256 if (this.tableName == null) {
21257 sb.append("null");
21258 } else {
21259 sb.append(this.tableName);
21260 }
21261 first = false;
21262 if (!first) sb.append(", ");
21263 sb.append("row:");
21264 if (this.row == null) {
21265 sb.append("null");
21266 } else {
21267 sb.append(this.row);
21268 }
21269 first = false;
21270 if (!first) sb.append(", ");
21271 sb.append("column:");
21272 if (this.column == null) {
21273 sb.append("null");
21274 } else {
21275 sb.append(this.column);
21276 }
21277 first = false;
21278 sb.append(")");
21279 return sb.toString();
21280 }
21281
21282 public void validate() throws TException {
21283
21284 }
21285
21286 }
21287
21288 public static class deleteAll_result implements TBase<deleteAll_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_result> {
21289 private static final TStruct STRUCT_DESC = new TStruct("deleteAll_result");
21290
21291 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
21292
21293 public IOError io;
21294
21295
21296 public enum _Fields implements TFieldIdEnum {
21297 IO((short)1, "io");
21298
21299 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
21300 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
21301
21302 static {
21303 for (_Fields field : EnumSet.allOf(_Fields.class)) {
21304 byId.put((int)field._thriftId, field);
21305 byName.put(field.getFieldName(), field);
21306 }
21307 }
21308
21309
21310
21311
21312 public static _Fields findByThriftId(int fieldId) {
21313 return byId.get(fieldId);
21314 }
21315
21316
21317
21318
21319
21320 public static _Fields findByThriftIdOrThrow(int fieldId) {
21321 _Fields fields = findByThriftId(fieldId);
21322 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
21323 return fields;
21324 }
21325
21326
21327
21328
21329 public static _Fields findByName(String name) {
21330 return byName.get(name);
21331 }
21332
21333 private final short _thriftId;
21334 private final String _fieldName;
21335
21336 _Fields(short thriftId, String fieldName) {
21337 _thriftId = thriftId;
21338 _fieldName = fieldName;
21339 }
21340
21341 public short getThriftFieldId() {
21342 return _thriftId;
21343 }
21344
21345 public String getFieldName() {
21346 return _fieldName;
21347 }
21348 }
21349
21350
21351
21352 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
21353 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
21354 new FieldValueMetaData(TType.STRUCT)));
21355 }});
21356
21357 static {
21358 FieldMetaData.addStructMetaDataMap(deleteAll_result.class, metaDataMap);
21359 }
21360
21361 public deleteAll_result() {
21362 }
21363
21364 public deleteAll_result(
21365 IOError io)
21366 {
21367 this();
21368 this.io = io;
21369 }
21370
21371
21372
21373
21374 public deleteAll_result(deleteAll_result other) {
21375 if (other.isSetIo()) {
21376 this.io = new IOError(other.io);
21377 }
21378 }
21379
21380 public deleteAll_result deepCopy() {
21381 return new deleteAll_result(this);
21382 }
21383
21384 @Deprecated
21385 public deleteAll_result clone() {
21386 return new deleteAll_result(this);
21387 }
21388
21389 public IOError getIo() {
21390 return this.io;
21391 }
21392
21393 public deleteAll_result setIo(IOError io) {
21394 this.io = io;
21395 return this;
21396 }
21397
21398 public void unsetIo() {
21399 this.io = null;
21400 }
21401
21402
21403 public boolean isSetIo() {
21404 return this.io != null;
21405 }
21406
21407 public void setIoIsSet(boolean value) {
21408 if (!value) {
21409 this.io = null;
21410 }
21411 }
21412
21413 public void setFieldValue(_Fields field, Object value) {
21414 switch (field) {
21415 case IO:
21416 if (value == null) {
21417 unsetIo();
21418 } else {
21419 setIo((IOError)value);
21420 }
21421 break;
21422
21423 }
21424 }
21425
21426 public void setFieldValue(int fieldID, Object value) {
21427 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21428 }
21429
21430 public Object getFieldValue(_Fields field) {
21431 switch (field) {
21432 case IO:
21433 return getIo();
21434
21435 }
21436 throw new IllegalStateException();
21437 }
21438
21439 public Object getFieldValue(int fieldId) {
21440 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21441 }
21442
21443
21444 public boolean isSet(_Fields field) {
21445 switch (field) {
21446 case IO:
21447 return isSetIo();
21448 }
21449 throw new IllegalStateException();
21450 }
21451
21452 public boolean isSet(int fieldID) {
21453 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21454 }
21455
21456 @Override
21457 public boolean equals(Object that) {
21458 if (that == null)
21459 return false;
21460 if (that instanceof deleteAll_result)
21461 return this.equals((deleteAll_result)that);
21462 return false;
21463 }
21464
21465 public boolean equals(deleteAll_result that) {
21466 if (that == null)
21467 return false;
21468
21469 boolean this_present_io = true && this.isSetIo();
21470 boolean that_present_io = true && that.isSetIo();
21471 if (this_present_io || that_present_io) {
21472 if (!(this_present_io && that_present_io))
21473 return false;
21474 if (!this.io.equals(that.io))
21475 return false;
21476 }
21477
21478 return true;
21479 }
21480
21481 @Override
21482 public int hashCode() {
21483 HashCodeBuilder builder = new HashCodeBuilder();
21484
21485 boolean present_io = true && (isSetIo());
21486 builder.append(present_io);
21487 if (present_io)
21488 builder.append(io);
21489
21490 return builder.toHashCode();
21491 }
21492
21493 public int compareTo(deleteAll_result other) {
21494 if (!getClass().equals(other.getClass())) {
21495 return getClass().getName().compareTo(other.getClass().getName());
21496 }
21497
21498 int lastComparison = 0;
21499 deleteAll_result typedOther = (deleteAll_result)other;
21500
21501 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
21502 if (lastComparison != 0) {
21503 return lastComparison;
21504 }
21505 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
21506 if (lastComparison != 0) {
21507 return lastComparison;
21508 }
21509 return 0;
21510 }
21511
21512 public void read(TProtocol iprot) throws TException {
21513 TField field;
21514 iprot.readStructBegin();
21515 while (true)
21516 {
21517 field = iprot.readFieldBegin();
21518 if (field.type == TType.STOP) {
21519 break;
21520 }
21521 _Fields fieldId = _Fields.findByThriftId(field.id);
21522 if (fieldId == null) {
21523 TProtocolUtil.skip(iprot, field.type);
21524 } else {
21525 switch (fieldId) {
21526 case IO:
21527 if (field.type == TType.STRUCT) {
21528 this.io = new IOError();
21529 this.io.read(iprot);
21530 } else {
21531 TProtocolUtil.skip(iprot, field.type);
21532 }
21533 break;
21534 }
21535 iprot.readFieldEnd();
21536 }
21537 }
21538 iprot.readStructEnd();
21539
21540
21541 validate();
21542 }
21543
21544 public void write(TProtocol oprot) throws TException {
21545 oprot.writeStructBegin(STRUCT_DESC);
21546
21547 if (this.isSetIo()) {
21548 oprot.writeFieldBegin(IO_FIELD_DESC);
21549 this.io.write(oprot);
21550 oprot.writeFieldEnd();
21551 }
21552 oprot.writeFieldStop();
21553 oprot.writeStructEnd();
21554 }
21555
21556 @Override
21557 public String toString() {
21558 StringBuilder sb = new StringBuilder("deleteAll_result(");
21559 boolean first = true;
21560
21561 sb.append("io:");
21562 if (this.io == null) {
21563 sb.append("null");
21564 } else {
21565 sb.append(this.io);
21566 }
21567 first = false;
21568 sb.append(")");
21569 return sb.toString();
21570 }
21571
21572 public void validate() throws TException {
21573
21574 }
21575
21576 }
21577
21578 public static class deleteAllTs_args implements TBase<deleteAllTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_args> {
21579 private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_args");
21580
21581 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
21582 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
21583 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
21584 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
21585
21586
21587
21588
21589 public byte[] tableName;
21590
21591
21592
21593 public byte[] row;
21594
21595
21596
21597 public byte[] column;
21598
21599
21600
21601 public long timestamp;
21602
21603
21604 public enum _Fields implements TFieldIdEnum {
21605
21606
21607
21608 TABLE_NAME((short)1, "tableName"),
21609
21610
21611
21612 ROW((short)2, "row"),
21613
21614
21615
21616 COLUMN((short)3, "column"),
21617
21618
21619
21620 TIMESTAMP((short)4, "timestamp");
21621
21622 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
21623 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
21624
21625 static {
21626 for (_Fields field : EnumSet.allOf(_Fields.class)) {
21627 byId.put((int)field._thriftId, field);
21628 byName.put(field.getFieldName(), field);
21629 }
21630 }
21631
21632
21633
21634
21635 public static _Fields findByThriftId(int fieldId) {
21636 return byId.get(fieldId);
21637 }
21638
21639
21640
21641
21642
21643 public static _Fields findByThriftIdOrThrow(int fieldId) {
21644 _Fields fields = findByThriftId(fieldId);
21645 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
21646 return fields;
21647 }
21648
21649
21650
21651
21652 public static _Fields findByName(String name) {
21653 return byName.get(name);
21654 }
21655
21656 private final short _thriftId;
21657 private final String _fieldName;
21658
21659 _Fields(short thriftId, String fieldName) {
21660 _thriftId = thriftId;
21661 _fieldName = fieldName;
21662 }
21663
21664 public short getThriftFieldId() {
21665 return _thriftId;
21666 }
21667
21668 public String getFieldName() {
21669 return _fieldName;
21670 }
21671 }
21672
21673
21674 private static final int __TIMESTAMP_ISSET_ID = 0;
21675 private BitSet __isset_bit_vector = new BitSet(1);
21676
21677 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
21678 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
21679 new FieldValueMetaData(TType.STRING)));
21680 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
21681 new FieldValueMetaData(TType.STRING)));
21682 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
21683 new FieldValueMetaData(TType.STRING)));
21684 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
21685 new FieldValueMetaData(TType.I64)));
21686 }});
21687
21688 static {
21689 FieldMetaData.addStructMetaDataMap(deleteAllTs_args.class, metaDataMap);
21690 }
21691
21692 public deleteAllTs_args() {
21693 }
21694
21695 public deleteAllTs_args(
21696 byte[] tableName,
21697 byte[] row,
21698 byte[] column,
21699 long timestamp)
21700 {
21701 this();
21702 this.tableName = tableName;
21703 this.row = row;
21704 this.column = column;
21705 this.timestamp = timestamp;
21706 setTimestampIsSet(true);
21707 }
21708
21709
21710
21711
21712 public deleteAllTs_args(deleteAllTs_args other) {
21713 __isset_bit_vector.clear();
21714 __isset_bit_vector.or(other.__isset_bit_vector);
21715 if (other.isSetTableName()) {
21716 this.tableName = other.tableName;
21717 }
21718 if (other.isSetRow()) {
21719 this.row = other.row;
21720 }
21721 if (other.isSetColumn()) {
21722 this.column = other.column;
21723 }
21724 this.timestamp = other.timestamp;
21725 }
21726
21727 public deleteAllTs_args deepCopy() {
21728 return new deleteAllTs_args(this);
21729 }
21730
21731 @Deprecated
21732 public deleteAllTs_args clone() {
21733 return new deleteAllTs_args(this);
21734 }
21735
21736
21737
21738
21739 public byte[] getTableName() {
21740 return this.tableName;
21741 }
21742
21743
21744
21745
21746 public deleteAllTs_args setTableName(byte[] tableName) {
21747 this.tableName = tableName;
21748 return this;
21749 }
21750
21751 public void unsetTableName() {
21752 this.tableName = null;
21753 }
21754
21755
21756 public boolean isSetTableName() {
21757 return this.tableName != null;
21758 }
21759
21760 public void setTableNameIsSet(boolean value) {
21761 if (!value) {
21762 this.tableName = null;
21763 }
21764 }
21765
21766
21767
21768
21769 public byte[] getRow() {
21770 return this.row;
21771 }
21772
21773
21774
21775
21776 public deleteAllTs_args setRow(byte[] row) {
21777 this.row = row;
21778 return this;
21779 }
21780
21781 public void unsetRow() {
21782 this.row = null;
21783 }
21784
21785
21786 public boolean isSetRow() {
21787 return this.row != null;
21788 }
21789
21790 public void setRowIsSet(boolean value) {
21791 if (!value) {
21792 this.row = null;
21793 }
21794 }
21795
21796
21797
21798
21799 public byte[] getColumn() {
21800 return this.column;
21801 }
21802
21803
21804
21805
21806 public deleteAllTs_args setColumn(byte[] column) {
21807 this.column = column;
21808 return this;
21809 }
21810
21811 public void unsetColumn() {
21812 this.column = null;
21813 }
21814
21815
21816 public boolean isSetColumn() {
21817 return this.column != null;
21818 }
21819
21820 public void setColumnIsSet(boolean value) {
21821 if (!value) {
21822 this.column = null;
21823 }
21824 }
21825
21826
21827
21828
21829 public long getTimestamp() {
21830 return this.timestamp;
21831 }
21832
21833
21834
21835
21836 public deleteAllTs_args setTimestamp(long timestamp) {
21837 this.timestamp = timestamp;
21838 setTimestampIsSet(true);
21839 return this;
21840 }
21841
21842 public void unsetTimestamp() {
21843 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
21844 }
21845
21846
21847 public boolean isSetTimestamp() {
21848 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
21849 }
21850
21851 public void setTimestampIsSet(boolean value) {
21852 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
21853 }
21854
21855 public void setFieldValue(_Fields field, Object value) {
21856 switch (field) {
21857 case TABLE_NAME:
21858 if (value == null) {
21859 unsetTableName();
21860 } else {
21861 setTableName((byte[])value);
21862 }
21863 break;
21864
21865 case ROW:
21866 if (value == null) {
21867 unsetRow();
21868 } else {
21869 setRow((byte[])value);
21870 }
21871 break;
21872
21873 case COLUMN:
21874 if (value == null) {
21875 unsetColumn();
21876 } else {
21877 setColumn((byte[])value);
21878 }
21879 break;
21880
21881 case TIMESTAMP:
21882 if (value == null) {
21883 unsetTimestamp();
21884 } else {
21885 setTimestamp((Long)value);
21886 }
21887 break;
21888
21889 }
21890 }
21891
21892 public void setFieldValue(int fieldID, Object value) {
21893 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21894 }
21895
21896 public Object getFieldValue(_Fields field) {
21897 switch (field) {
21898 case TABLE_NAME:
21899 return getTableName();
21900
21901 case ROW:
21902 return getRow();
21903
21904 case COLUMN:
21905 return getColumn();
21906
21907 case TIMESTAMP:
21908 return new Long(getTimestamp());
21909
21910 }
21911 throw new IllegalStateException();
21912 }
21913
21914 public Object getFieldValue(int fieldId) {
21915 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21916 }
21917
21918
21919 public boolean isSet(_Fields field) {
21920 switch (field) {
21921 case TABLE_NAME:
21922 return isSetTableName();
21923 case ROW:
21924 return isSetRow();
21925 case COLUMN:
21926 return isSetColumn();
21927 case TIMESTAMP:
21928 return isSetTimestamp();
21929 }
21930 throw new IllegalStateException();
21931 }
21932
21933 public boolean isSet(int fieldID) {
21934 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21935 }
21936
21937 @Override
21938 public boolean equals(Object that) {
21939 if (that == null)
21940 return false;
21941 if (that instanceof deleteAllTs_args)
21942 return this.equals((deleteAllTs_args)that);
21943 return false;
21944 }
21945
21946 public boolean equals(deleteAllTs_args that) {
21947 if (that == null)
21948 return false;
21949
21950 boolean this_present_tableName = true && this.isSetTableName();
21951 boolean that_present_tableName = true && that.isSetTableName();
21952 if (this_present_tableName || that_present_tableName) {
21953 if (!(this_present_tableName && that_present_tableName))
21954 return false;
21955 if (!java.util.Arrays.equals(this.tableName, that.tableName))
21956 return false;
21957 }
21958
21959 boolean this_present_row = true && this.isSetRow();
21960 boolean that_present_row = true && that.isSetRow();
21961 if (this_present_row || that_present_row) {
21962 if (!(this_present_row && that_present_row))
21963 return false;
21964 if (!java.util.Arrays.equals(this.row, that.row))
21965 return false;
21966 }
21967
21968 boolean this_present_column = true && this.isSetColumn();
21969 boolean that_present_column = true && that.isSetColumn();
21970 if (this_present_column || that_present_column) {
21971 if (!(this_present_column && that_present_column))
21972 return false;
21973 if (!java.util.Arrays.equals(this.column, that.column))
21974 return false;
21975 }
21976
21977 boolean this_present_timestamp = true;
21978 boolean that_present_timestamp = true;
21979 if (this_present_timestamp || that_present_timestamp) {
21980 if (!(this_present_timestamp && that_present_timestamp))
21981 return false;
21982 if (this.timestamp != that.timestamp)
21983 return false;
21984 }
21985
21986 return true;
21987 }
21988
21989 @Override
21990 public int hashCode() {
21991 HashCodeBuilder builder = new HashCodeBuilder();
21992
21993 boolean present_tableName = true && (isSetTableName());
21994 builder.append(present_tableName);
21995 if (present_tableName)
21996 builder.append(tableName);
21997
21998 boolean present_row = true && (isSetRow());
21999 builder.append(present_row);
22000 if (present_row)
22001 builder.append(row);
22002
22003 boolean present_column = true && (isSetColumn());
22004 builder.append(present_column);
22005 if (present_column)
22006 builder.append(column);
22007
22008 boolean present_timestamp = true;
22009 builder.append(present_timestamp);
22010 if (present_timestamp)
22011 builder.append(timestamp);
22012
22013 return builder.toHashCode();
22014 }
22015
22016 public int compareTo(deleteAllTs_args other) {
22017 if (!getClass().equals(other.getClass())) {
22018 return getClass().getName().compareTo(other.getClass().getName());
22019 }
22020
22021 int lastComparison = 0;
22022 deleteAllTs_args typedOther = (deleteAllTs_args)other;
22023
22024 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
22025 if (lastComparison != 0) {
22026 return lastComparison;
22027 }
22028 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
22029 if (lastComparison != 0) {
22030 return lastComparison;
22031 }
22032 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
22033 if (lastComparison != 0) {
22034 return lastComparison;
22035 }
22036 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
22037 if (lastComparison != 0) {
22038 return lastComparison;
22039 }
22040 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
22041 if (lastComparison != 0) {
22042 return lastComparison;
22043 }
22044 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
22045 if (lastComparison != 0) {
22046 return lastComparison;
22047 }
22048 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
22049 if (lastComparison != 0) {
22050 return lastComparison;
22051 }
22052 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
22053 if (lastComparison != 0) {
22054 return lastComparison;
22055 }
22056 return 0;
22057 }
22058
22059 public void read(TProtocol iprot) throws TException {
22060 TField field;
22061 iprot.readStructBegin();
22062 while (true)
22063 {
22064 field = iprot.readFieldBegin();
22065 if (field.type == TType.STOP) {
22066 break;
22067 }
22068 _Fields fieldId = _Fields.findByThriftId(field.id);
22069 if (fieldId == null) {
22070 TProtocolUtil.skip(iprot, field.type);
22071 } else {
22072 switch (fieldId) {
22073 case TABLE_NAME:
22074 if (field.type == TType.STRING) {
22075 this.tableName = iprot.readBinary();
22076 } else {
22077 TProtocolUtil.skip(iprot, field.type);
22078 }
22079 break;
22080 case ROW:
22081 if (field.type == TType.STRING) {
22082 this.row = iprot.readBinary();
22083 } else {
22084 TProtocolUtil.skip(iprot, field.type);
22085 }
22086 break;
22087 case COLUMN:
22088 if (field.type == TType.STRING) {
22089 this.column = iprot.readBinary();
22090 } else {
22091 TProtocolUtil.skip(iprot, field.type);
22092 }
22093 break;
22094 case TIMESTAMP:
22095 if (field.type == TType.I64) {
22096 this.timestamp = iprot.readI64();
22097 setTimestampIsSet(true);
22098 } else {
22099 TProtocolUtil.skip(iprot, field.type);
22100 }
22101 break;
22102 }
22103 iprot.readFieldEnd();
22104 }
22105 }
22106 iprot.readStructEnd();
22107
22108
22109 validate();
22110 }
22111
22112 public void write(TProtocol oprot) throws TException {
22113 validate();
22114
22115 oprot.writeStructBegin(STRUCT_DESC);
22116 if (this.tableName != null) {
22117 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
22118 oprot.writeBinary(this.tableName);
22119 oprot.writeFieldEnd();
22120 }
22121 if (this.row != null) {
22122 oprot.writeFieldBegin(ROW_FIELD_DESC);
22123 oprot.writeBinary(this.row);
22124 oprot.writeFieldEnd();
22125 }
22126 if (this.column != null) {
22127 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
22128 oprot.writeBinary(this.column);
22129 oprot.writeFieldEnd();
22130 }
22131 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
22132 oprot.writeI64(this.timestamp);
22133 oprot.writeFieldEnd();
22134 oprot.writeFieldStop();
22135 oprot.writeStructEnd();
22136 }
22137
22138 @Override
22139 public String toString() {
22140 StringBuilder sb = new StringBuilder("deleteAllTs_args(");
22141 boolean first = true;
22142
22143 sb.append("tableName:");
22144 if (this.tableName == null) {
22145 sb.append("null");
22146 } else {
22147 sb.append(this.tableName);
22148 }
22149 first = false;
22150 if (!first) sb.append(", ");
22151 sb.append("row:");
22152 if (this.row == null) {
22153 sb.append("null");
22154 } else {
22155 sb.append(this.row);
22156 }
22157 first = false;
22158 if (!first) sb.append(", ");
22159 sb.append("column:");
22160 if (this.column == null) {
22161 sb.append("null");
22162 } else {
22163 sb.append(this.column);
22164 }
22165 first = false;
22166 if (!first) sb.append(", ");
22167 sb.append("timestamp:");
22168 sb.append(this.timestamp);
22169 first = false;
22170 sb.append(")");
22171 return sb.toString();
22172 }
22173
22174 public void validate() throws TException {
22175
22176 }
22177
22178 }
22179
22180 public static class deleteAllTs_result implements TBase<deleteAllTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_result> {
22181 private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_result");
22182
22183 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
22184
22185 public IOError io;
22186
22187
22188 public enum _Fields implements TFieldIdEnum {
22189 IO((short)1, "io");
22190
22191 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22192 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22193
22194 static {
22195 for (_Fields field : EnumSet.allOf(_Fields.class)) {
22196 byId.put((int)field._thriftId, field);
22197 byName.put(field.getFieldName(), field);
22198 }
22199 }
22200
22201
22202
22203
22204 public static _Fields findByThriftId(int fieldId) {
22205 return byId.get(fieldId);
22206 }
22207
22208
22209
22210
22211
22212 public static _Fields findByThriftIdOrThrow(int fieldId) {
22213 _Fields fields = findByThriftId(fieldId);
22214 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22215 return fields;
22216 }
22217
22218
22219
22220
22221 public static _Fields findByName(String name) {
22222 return byName.get(name);
22223 }
22224
22225 private final short _thriftId;
22226 private final String _fieldName;
22227
22228 _Fields(short thriftId, String fieldName) {
22229 _thriftId = thriftId;
22230 _fieldName = fieldName;
22231 }
22232
22233 public short getThriftFieldId() {
22234 return _thriftId;
22235 }
22236
22237 public String getFieldName() {
22238 return _fieldName;
22239 }
22240 }
22241
22242
22243
22244 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22245 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
22246 new FieldValueMetaData(TType.STRUCT)));
22247 }});
22248
22249 static {
22250 FieldMetaData.addStructMetaDataMap(deleteAllTs_result.class, metaDataMap);
22251 }
22252
22253 public deleteAllTs_result() {
22254 }
22255
22256 public deleteAllTs_result(
22257 IOError io)
22258 {
22259 this();
22260 this.io = io;
22261 }
22262
22263
22264
22265
22266 public deleteAllTs_result(deleteAllTs_result other) {
22267 if (other.isSetIo()) {
22268 this.io = new IOError(other.io);
22269 }
22270 }
22271
22272 public deleteAllTs_result deepCopy() {
22273 return new deleteAllTs_result(this);
22274 }
22275
22276 @Deprecated
22277 public deleteAllTs_result clone() {
22278 return new deleteAllTs_result(this);
22279 }
22280
22281 public IOError getIo() {
22282 return this.io;
22283 }
22284
22285 public deleteAllTs_result setIo(IOError io) {
22286 this.io = io;
22287 return this;
22288 }
22289
22290 public void unsetIo() {
22291 this.io = null;
22292 }
22293
22294
22295 public boolean isSetIo() {
22296 return this.io != null;
22297 }
22298
22299 public void setIoIsSet(boolean value) {
22300 if (!value) {
22301 this.io = null;
22302 }
22303 }
22304
22305 public void setFieldValue(_Fields field, Object value) {
22306 switch (field) {
22307 case IO:
22308 if (value == null) {
22309 unsetIo();
22310 } else {
22311 setIo((IOError)value);
22312 }
22313 break;
22314
22315 }
22316 }
22317
22318 public void setFieldValue(int fieldID, Object value) {
22319 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
22320 }
22321
22322 public Object getFieldValue(_Fields field) {
22323 switch (field) {
22324 case IO:
22325 return getIo();
22326
22327 }
22328 throw new IllegalStateException();
22329 }
22330
22331 public Object getFieldValue(int fieldId) {
22332 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
22333 }
22334
22335
22336 public boolean isSet(_Fields field) {
22337 switch (field) {
22338 case IO:
22339 return isSetIo();
22340 }
22341 throw new IllegalStateException();
22342 }
22343
22344 public boolean isSet(int fieldID) {
22345 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
22346 }
22347
22348 @Override
22349 public boolean equals(Object that) {
22350 if (that == null)
22351 return false;
22352 if (that instanceof deleteAllTs_result)
22353 return this.equals((deleteAllTs_result)that);
22354 return false;
22355 }
22356
22357 public boolean equals(deleteAllTs_result that) {
22358 if (that == null)
22359 return false;
22360
22361 boolean this_present_io = true && this.isSetIo();
22362 boolean that_present_io = true && that.isSetIo();
22363 if (this_present_io || that_present_io) {
22364 if (!(this_present_io && that_present_io))
22365 return false;
22366 if (!this.io.equals(that.io))
22367 return false;
22368 }
22369
22370 return true;
22371 }
22372
22373 @Override
22374 public int hashCode() {
22375 HashCodeBuilder builder = new HashCodeBuilder();
22376
22377 boolean present_io = true && (isSetIo());
22378 builder.append(present_io);
22379 if (present_io)
22380 builder.append(io);
22381
22382 return builder.toHashCode();
22383 }
22384
22385 public int compareTo(deleteAllTs_result other) {
22386 if (!getClass().equals(other.getClass())) {
22387 return getClass().getName().compareTo(other.getClass().getName());
22388 }
22389
22390 int lastComparison = 0;
22391 deleteAllTs_result typedOther = (deleteAllTs_result)other;
22392
22393 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
22394 if (lastComparison != 0) {
22395 return lastComparison;
22396 }
22397 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
22398 if (lastComparison != 0) {
22399 return lastComparison;
22400 }
22401 return 0;
22402 }
22403
22404 public void read(TProtocol iprot) throws TException {
22405 TField field;
22406 iprot.readStructBegin();
22407 while (true)
22408 {
22409 field = iprot.readFieldBegin();
22410 if (field.type == TType.STOP) {
22411 break;
22412 }
22413 _Fields fieldId = _Fields.findByThriftId(field.id);
22414 if (fieldId == null) {
22415 TProtocolUtil.skip(iprot, field.type);
22416 } else {
22417 switch (fieldId) {
22418 case IO:
22419 if (field.type == TType.STRUCT) {
22420 this.io = new IOError();
22421 this.io.read(iprot);
22422 } else {
22423 TProtocolUtil.skip(iprot, field.type);
22424 }
22425 break;
22426 }
22427 iprot.readFieldEnd();
22428 }
22429 }
22430 iprot.readStructEnd();
22431
22432
22433 validate();
22434 }
22435
22436 public void write(TProtocol oprot) throws TException {
22437 oprot.writeStructBegin(STRUCT_DESC);
22438
22439 if (this.isSetIo()) {
22440 oprot.writeFieldBegin(IO_FIELD_DESC);
22441 this.io.write(oprot);
22442 oprot.writeFieldEnd();
22443 }
22444 oprot.writeFieldStop();
22445 oprot.writeStructEnd();
22446 }
22447
22448 @Override
22449 public String toString() {
22450 StringBuilder sb = new StringBuilder("deleteAllTs_result(");
22451 boolean first = true;
22452
22453 sb.append("io:");
22454 if (this.io == null) {
22455 sb.append("null");
22456 } else {
22457 sb.append(this.io);
22458 }
22459 first = false;
22460 sb.append(")");
22461 return sb.toString();
22462 }
22463
22464 public void validate() throws TException {
22465
22466 }
22467
22468 }
22469
22470 public static class deleteAllRow_args implements TBase<deleteAllRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_args> {
22471 private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_args");
22472
22473 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
22474 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
22475
22476
22477
22478
22479 public byte[] tableName;
22480
22481
22482
22483 public byte[] row;
22484
22485
22486 public enum _Fields implements TFieldIdEnum {
22487
22488
22489
22490 TABLE_NAME((short)1, "tableName"),
22491
22492
22493
22494 ROW((short)2, "row");
22495
22496 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22497 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22498
22499 static {
22500 for (_Fields field : EnumSet.allOf(_Fields.class)) {
22501 byId.put((int)field._thriftId, field);
22502 byName.put(field.getFieldName(), field);
22503 }
22504 }
22505
22506
22507
22508
22509 public static _Fields findByThriftId(int fieldId) {
22510 return byId.get(fieldId);
22511 }
22512
22513
22514
22515
22516
22517 public static _Fields findByThriftIdOrThrow(int fieldId) {
22518 _Fields fields = findByThriftId(fieldId);
22519 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22520 return fields;
22521 }
22522
22523
22524
22525
22526 public static _Fields findByName(String name) {
22527 return byName.get(name);
22528 }
22529
22530 private final short _thriftId;
22531 private final String _fieldName;
22532
22533 _Fields(short thriftId, String fieldName) {
22534 _thriftId = thriftId;
22535 _fieldName = fieldName;
22536 }
22537
22538 public short getThriftFieldId() {
22539 return _thriftId;
22540 }
22541
22542 public String getFieldName() {
22543 return _fieldName;
22544 }
22545 }
22546
22547
22548
22549 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22550 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
22551 new FieldValueMetaData(TType.STRING)));
22552 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
22553 new FieldValueMetaData(TType.STRING)));
22554 }});
22555
22556 static {
22557 FieldMetaData.addStructMetaDataMap(deleteAllRow_args.class, metaDataMap);
22558 }
22559
22560 public deleteAllRow_args() {
22561 }
22562
22563 public deleteAllRow_args(
22564 byte[] tableName,
22565 byte[] row)
22566 {
22567 this();
22568 this.tableName = tableName;
22569 this.row = row;
22570 }
22571
22572
22573
22574
22575 public deleteAllRow_args(deleteAllRow_args other) {
22576 if (other.isSetTableName()) {
22577 this.tableName = other.tableName;
22578 }
22579 if (other.isSetRow()) {
22580 this.row = other.row;
22581 }
22582 }
22583
22584 public deleteAllRow_args deepCopy() {
22585 return new deleteAllRow_args(this);
22586 }
22587
22588 @Deprecated
22589 public deleteAllRow_args clone() {
22590 return new deleteAllRow_args(this);
22591 }
22592
22593
22594
22595
22596 public byte[] getTableName() {
22597 return this.tableName;
22598 }
22599
22600
22601
22602
22603 public deleteAllRow_args setTableName(byte[] tableName) {
22604 this.tableName = tableName;
22605 return this;
22606 }
22607
22608 public void unsetTableName() {
22609 this.tableName = null;
22610 }
22611
22612
22613 public boolean isSetTableName() {
22614 return this.tableName != null;
22615 }
22616
22617 public void setTableNameIsSet(boolean value) {
22618 if (!value) {
22619 this.tableName = null;
22620 }
22621 }
22622
22623
22624
22625
22626 public byte[] getRow() {
22627 return this.row;
22628 }
22629
22630
22631
22632
22633 public deleteAllRow_args setRow(byte[] row) {
22634 this.row = row;
22635 return this;
22636 }
22637
22638 public void unsetRow() {
22639 this.row = null;
22640 }
22641
22642
22643 public boolean isSetRow() {
22644 return this.row != null;
22645 }
22646
22647 public void setRowIsSet(boolean value) {
22648 if (!value) {
22649 this.row = null;
22650 }
22651 }
22652
22653 public void setFieldValue(_Fields field, Object value) {
22654 switch (field) {
22655 case TABLE_NAME:
22656 if (value == null) {
22657 unsetTableName();
22658 } else {
22659 setTableName((byte[])value);
22660 }
22661 break;
22662
22663 case ROW:
22664 if (value == null) {
22665 unsetRow();
22666 } else {
22667 setRow((byte[])value);
22668 }
22669 break;
22670
22671 }
22672 }
22673
22674 public void setFieldValue(int fieldID, Object value) {
22675 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
22676 }
22677
22678 public Object getFieldValue(_Fields field) {
22679 switch (field) {
22680 case TABLE_NAME:
22681 return getTableName();
22682
22683 case ROW:
22684 return getRow();
22685
22686 }
22687 throw new IllegalStateException();
22688 }
22689
22690 public Object getFieldValue(int fieldId) {
22691 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
22692 }
22693
22694
22695 public boolean isSet(_Fields field) {
22696 switch (field) {
22697 case TABLE_NAME:
22698 return isSetTableName();
22699 case ROW:
22700 return isSetRow();
22701 }
22702 throw new IllegalStateException();
22703 }
22704
22705 public boolean isSet(int fieldID) {
22706 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
22707 }
22708
22709 @Override
22710 public boolean equals(Object that) {
22711 if (that == null)
22712 return false;
22713 if (that instanceof deleteAllRow_args)
22714 return this.equals((deleteAllRow_args)that);
22715 return false;
22716 }
22717
22718 public boolean equals(deleteAllRow_args that) {
22719 if (that == null)
22720 return false;
22721
22722 boolean this_present_tableName = true && this.isSetTableName();
22723 boolean that_present_tableName = true && that.isSetTableName();
22724 if (this_present_tableName || that_present_tableName) {
22725 if (!(this_present_tableName && that_present_tableName))
22726 return false;
22727 if (!java.util.Arrays.equals(this.tableName, that.tableName))
22728 return false;
22729 }
22730
22731 boolean this_present_row = true && this.isSetRow();
22732 boolean that_present_row = true && that.isSetRow();
22733 if (this_present_row || that_present_row) {
22734 if (!(this_present_row && that_present_row))
22735 return false;
22736 if (!java.util.Arrays.equals(this.row, that.row))
22737 return false;
22738 }
22739
22740 return true;
22741 }
22742
22743 @Override
22744 public int hashCode() {
22745 HashCodeBuilder builder = new HashCodeBuilder();
22746
22747 boolean present_tableName = true && (isSetTableName());
22748 builder.append(present_tableName);
22749 if (present_tableName)
22750 builder.append(tableName);
22751
22752 boolean present_row = true && (isSetRow());
22753 builder.append(present_row);
22754 if (present_row)
22755 builder.append(row);
22756
22757 return builder.toHashCode();
22758 }
22759
22760 public int compareTo(deleteAllRow_args other) {
22761 if (!getClass().equals(other.getClass())) {
22762 return getClass().getName().compareTo(other.getClass().getName());
22763 }
22764
22765 int lastComparison = 0;
22766 deleteAllRow_args typedOther = (deleteAllRow_args)other;
22767
22768 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
22769 if (lastComparison != 0) {
22770 return lastComparison;
22771 }
22772 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
22773 if (lastComparison != 0) {
22774 return lastComparison;
22775 }
22776 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
22777 if (lastComparison != 0) {
22778 return lastComparison;
22779 }
22780 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
22781 if (lastComparison != 0) {
22782 return lastComparison;
22783 }
22784 return 0;
22785 }
22786
22787 public void read(TProtocol iprot) throws TException {
22788 TField field;
22789 iprot.readStructBegin();
22790 while (true)
22791 {
22792 field = iprot.readFieldBegin();
22793 if (field.type == TType.STOP) {
22794 break;
22795 }
22796 _Fields fieldId = _Fields.findByThriftId(field.id);
22797 if (fieldId == null) {
22798 TProtocolUtil.skip(iprot, field.type);
22799 } else {
22800 switch (fieldId) {
22801 case TABLE_NAME:
22802 if (field.type == TType.STRING) {
22803 this.tableName = iprot.readBinary();
22804 } else {
22805 TProtocolUtil.skip(iprot, field.type);
22806 }
22807 break;
22808 case ROW:
22809 if (field.type == TType.STRING) {
22810 this.row = iprot.readBinary();
22811 } else {
22812 TProtocolUtil.skip(iprot, field.type);
22813 }
22814 break;
22815 }
22816 iprot.readFieldEnd();
22817 }
22818 }
22819 iprot.readStructEnd();
22820
22821
22822 validate();
22823 }
22824
22825 public void write(TProtocol oprot) throws TException {
22826 validate();
22827
22828 oprot.writeStructBegin(STRUCT_DESC);
22829 if (this.tableName != null) {
22830 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
22831 oprot.writeBinary(this.tableName);
22832 oprot.writeFieldEnd();
22833 }
22834 if (this.row != null) {
22835 oprot.writeFieldBegin(ROW_FIELD_DESC);
22836 oprot.writeBinary(this.row);
22837 oprot.writeFieldEnd();
22838 }
22839 oprot.writeFieldStop();
22840 oprot.writeStructEnd();
22841 }
22842
22843 @Override
22844 public String toString() {
22845 StringBuilder sb = new StringBuilder("deleteAllRow_args(");
22846 boolean first = true;
22847
22848 sb.append("tableName:");
22849 if (this.tableName == null) {
22850 sb.append("null");
22851 } else {
22852 sb.append(this.tableName);
22853 }
22854 first = false;
22855 if (!first) sb.append(", ");
22856 sb.append("row:");
22857 if (this.row == null) {
22858 sb.append("null");
22859 } else {
22860 sb.append(this.row);
22861 }
22862 first = false;
22863 sb.append(")");
22864 return sb.toString();
22865 }
22866
22867 public void validate() throws TException {
22868
22869 }
22870
22871 }
22872
22873 public static class deleteAllRow_result implements TBase<deleteAllRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_result> {
22874 private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_result");
22875
22876 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
22877
22878 public IOError io;
22879
22880
22881 public enum _Fields implements TFieldIdEnum {
22882 IO((short)1, "io");
22883
22884 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22885 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22886
22887 static {
22888 for (_Fields field : EnumSet.allOf(_Fields.class)) {
22889 byId.put((int)field._thriftId, field);
22890 byName.put(field.getFieldName(), field);
22891 }
22892 }
22893
22894
22895
22896
22897 public static _Fields findByThriftId(int fieldId) {
22898 return byId.get(fieldId);
22899 }
22900
22901
22902
22903
22904
22905 public static _Fields findByThriftIdOrThrow(int fieldId) {
22906 _Fields fields = findByThriftId(fieldId);
22907 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22908 return fields;
22909 }
22910
22911
22912
22913
22914 public static _Fields findByName(String name) {
22915 return byName.get(name);
22916 }
22917
22918 private final short _thriftId;
22919 private final String _fieldName;
22920
22921 _Fields(short thriftId, String fieldName) {
22922 _thriftId = thriftId;
22923 _fieldName = fieldName;
22924 }
22925
22926 public short getThriftFieldId() {
22927 return _thriftId;
22928 }
22929
22930 public String getFieldName() {
22931 return _fieldName;
22932 }
22933 }
22934
22935
22936
22937 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22938 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
22939 new FieldValueMetaData(TType.STRUCT)));
22940 }});
22941
22942 static {
22943 FieldMetaData.addStructMetaDataMap(deleteAllRow_result.class, metaDataMap);
22944 }
22945
22946 public deleteAllRow_result() {
22947 }
22948
22949 public deleteAllRow_result(
22950 IOError io)
22951 {
22952 this();
22953 this.io = io;
22954 }
22955
22956
22957
22958
22959 public deleteAllRow_result(deleteAllRow_result other) {
22960 if (other.isSetIo()) {
22961 this.io = new IOError(other.io);
22962 }
22963 }
22964
22965 public deleteAllRow_result deepCopy() {
22966 return new deleteAllRow_result(this);
22967 }
22968
22969 @Deprecated
22970 public deleteAllRow_result clone() {
22971 return new deleteAllRow_result(this);
22972 }
22973
22974 public IOError getIo() {
22975 return this.io;
22976 }
22977
22978 public deleteAllRow_result setIo(IOError io) {
22979 this.io = io;
22980 return this;
22981 }
22982
22983 public void unsetIo() {
22984 this.io = null;
22985 }
22986
22987
22988 public boolean isSetIo() {
22989 return this.io != null;
22990 }
22991
22992 public void setIoIsSet(boolean value) {
22993 if (!value) {
22994 this.io = null;
22995 }
22996 }
22997
22998 public void setFieldValue(_Fields field, Object value) {
22999 switch (field) {
23000 case IO:
23001 if (value == null) {
23002 unsetIo();
23003 } else {
23004 setIo((IOError)value);
23005 }
23006 break;
23007
23008 }
23009 }
23010
23011 public void setFieldValue(int fieldID, Object value) {
23012 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23013 }
23014
23015 public Object getFieldValue(_Fields field) {
23016 switch (field) {
23017 case IO:
23018 return getIo();
23019
23020 }
23021 throw new IllegalStateException();
23022 }
23023
23024 public Object getFieldValue(int fieldId) {
23025 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23026 }
23027
23028
23029 public boolean isSet(_Fields field) {
23030 switch (field) {
23031 case IO:
23032 return isSetIo();
23033 }
23034 throw new IllegalStateException();
23035 }
23036
23037 public boolean isSet(int fieldID) {
23038 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23039 }
23040
23041 @Override
23042 public boolean equals(Object that) {
23043 if (that == null)
23044 return false;
23045 if (that instanceof deleteAllRow_result)
23046 return this.equals((deleteAllRow_result)that);
23047 return false;
23048 }
23049
23050 public boolean equals(deleteAllRow_result that) {
23051 if (that == null)
23052 return false;
23053
23054 boolean this_present_io = true && this.isSetIo();
23055 boolean that_present_io = true && that.isSetIo();
23056 if (this_present_io || that_present_io) {
23057 if (!(this_present_io && that_present_io))
23058 return false;
23059 if (!this.io.equals(that.io))
23060 return false;
23061 }
23062
23063 return true;
23064 }
23065
23066 @Override
23067 public int hashCode() {
23068 HashCodeBuilder builder = new HashCodeBuilder();
23069
23070 boolean present_io = true && (isSetIo());
23071 builder.append(present_io);
23072 if (present_io)
23073 builder.append(io);
23074
23075 return builder.toHashCode();
23076 }
23077
23078 public int compareTo(deleteAllRow_result other) {
23079 if (!getClass().equals(other.getClass())) {
23080 return getClass().getName().compareTo(other.getClass().getName());
23081 }
23082
23083 int lastComparison = 0;
23084 deleteAllRow_result typedOther = (deleteAllRow_result)other;
23085
23086 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
23087 if (lastComparison != 0) {
23088 return lastComparison;
23089 }
23090 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
23091 if (lastComparison != 0) {
23092 return lastComparison;
23093 }
23094 return 0;
23095 }
23096
23097 public void read(TProtocol iprot) throws TException {
23098 TField field;
23099 iprot.readStructBegin();
23100 while (true)
23101 {
23102 field = iprot.readFieldBegin();
23103 if (field.type == TType.STOP) {
23104 break;
23105 }
23106 _Fields fieldId = _Fields.findByThriftId(field.id);
23107 if (fieldId == null) {
23108 TProtocolUtil.skip(iprot, field.type);
23109 } else {
23110 switch (fieldId) {
23111 case IO:
23112 if (field.type == TType.STRUCT) {
23113 this.io = new IOError();
23114 this.io.read(iprot);
23115 } else {
23116 TProtocolUtil.skip(iprot, field.type);
23117 }
23118 break;
23119 }
23120 iprot.readFieldEnd();
23121 }
23122 }
23123 iprot.readStructEnd();
23124
23125
23126 validate();
23127 }
23128
23129 public void write(TProtocol oprot) throws TException {
23130 oprot.writeStructBegin(STRUCT_DESC);
23131
23132 if (this.isSetIo()) {
23133 oprot.writeFieldBegin(IO_FIELD_DESC);
23134 this.io.write(oprot);
23135 oprot.writeFieldEnd();
23136 }
23137 oprot.writeFieldStop();
23138 oprot.writeStructEnd();
23139 }
23140
23141 @Override
23142 public String toString() {
23143 StringBuilder sb = new StringBuilder("deleteAllRow_result(");
23144 boolean first = true;
23145
23146 sb.append("io:");
23147 if (this.io == null) {
23148 sb.append("null");
23149 } else {
23150 sb.append(this.io);
23151 }
23152 first = false;
23153 sb.append(")");
23154 return sb.toString();
23155 }
23156
23157 public void validate() throws TException {
23158
23159 }
23160
23161 }
23162
23163 public static class deleteAllRowTs_args implements TBase<deleteAllRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_args> {
23164 private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_args");
23165
23166 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
23167 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
23168 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
23169
23170
23171
23172
23173 public byte[] tableName;
23174
23175
23176
23177 public byte[] row;
23178
23179
23180
23181 public long timestamp;
23182
23183
23184 public enum _Fields implements TFieldIdEnum {
23185
23186
23187
23188 TABLE_NAME((short)1, "tableName"),
23189
23190
23191
23192 ROW((short)2, "row"),
23193
23194
23195
23196 TIMESTAMP((short)3, "timestamp");
23197
23198 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23199 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23200
23201 static {
23202 for (_Fields field : EnumSet.allOf(_Fields.class)) {
23203 byId.put((int)field._thriftId, field);
23204 byName.put(field.getFieldName(), field);
23205 }
23206 }
23207
23208
23209
23210
23211 public static _Fields findByThriftId(int fieldId) {
23212 return byId.get(fieldId);
23213 }
23214
23215
23216
23217
23218
23219 public static _Fields findByThriftIdOrThrow(int fieldId) {
23220 _Fields fields = findByThriftId(fieldId);
23221 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
23222 return fields;
23223 }
23224
23225
23226
23227
23228 public static _Fields findByName(String name) {
23229 return byName.get(name);
23230 }
23231
23232 private final short _thriftId;
23233 private final String _fieldName;
23234
23235 _Fields(short thriftId, String fieldName) {
23236 _thriftId = thriftId;
23237 _fieldName = fieldName;
23238 }
23239
23240 public short getThriftFieldId() {
23241 return _thriftId;
23242 }
23243
23244 public String getFieldName() {
23245 return _fieldName;
23246 }
23247 }
23248
23249
23250 private static final int __TIMESTAMP_ISSET_ID = 0;
23251 private BitSet __isset_bit_vector = new BitSet(1);
23252
23253 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
23254 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
23255 new FieldValueMetaData(TType.STRING)));
23256 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
23257 new FieldValueMetaData(TType.STRING)));
23258 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
23259 new FieldValueMetaData(TType.I64)));
23260 }});
23261
23262 static {
23263 FieldMetaData.addStructMetaDataMap(deleteAllRowTs_args.class, metaDataMap);
23264 }
23265
23266 public deleteAllRowTs_args() {
23267 }
23268
23269 public deleteAllRowTs_args(
23270 byte[] tableName,
23271 byte[] row,
23272 long timestamp)
23273 {
23274 this();
23275 this.tableName = tableName;
23276 this.row = row;
23277 this.timestamp = timestamp;
23278 setTimestampIsSet(true);
23279 }
23280
23281
23282
23283
23284 public deleteAllRowTs_args(deleteAllRowTs_args other) {
23285 __isset_bit_vector.clear();
23286 __isset_bit_vector.or(other.__isset_bit_vector);
23287 if (other.isSetTableName()) {
23288 this.tableName = other.tableName;
23289 }
23290 if (other.isSetRow()) {
23291 this.row = other.row;
23292 }
23293 this.timestamp = other.timestamp;
23294 }
23295
23296 public deleteAllRowTs_args deepCopy() {
23297 return new deleteAllRowTs_args(this);
23298 }
23299
23300 @Deprecated
23301 public deleteAllRowTs_args clone() {
23302 return new deleteAllRowTs_args(this);
23303 }
23304
23305
23306
23307
23308 public byte[] getTableName() {
23309 return this.tableName;
23310 }
23311
23312
23313
23314
23315 public deleteAllRowTs_args setTableName(byte[] tableName) {
23316 this.tableName = tableName;
23317 return this;
23318 }
23319
23320 public void unsetTableName() {
23321 this.tableName = null;
23322 }
23323
23324
23325 public boolean isSetTableName() {
23326 return this.tableName != null;
23327 }
23328
23329 public void setTableNameIsSet(boolean value) {
23330 if (!value) {
23331 this.tableName = null;
23332 }
23333 }
23334
23335
23336
23337
23338 public byte[] getRow() {
23339 return this.row;
23340 }
23341
23342
23343
23344
23345 public deleteAllRowTs_args setRow(byte[] row) {
23346 this.row = row;
23347 return this;
23348 }
23349
23350 public void unsetRow() {
23351 this.row = null;
23352 }
23353
23354
23355 public boolean isSetRow() {
23356 return this.row != null;
23357 }
23358
23359 public void setRowIsSet(boolean value) {
23360 if (!value) {
23361 this.row = null;
23362 }
23363 }
23364
23365
23366
23367
23368 public long getTimestamp() {
23369 return this.timestamp;
23370 }
23371
23372
23373
23374
23375 public deleteAllRowTs_args setTimestamp(long timestamp) {
23376 this.timestamp = timestamp;
23377 setTimestampIsSet(true);
23378 return this;
23379 }
23380
23381 public void unsetTimestamp() {
23382 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
23383 }
23384
23385
23386 public boolean isSetTimestamp() {
23387 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
23388 }
23389
23390 public void setTimestampIsSet(boolean value) {
23391 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
23392 }
23393
23394 public void setFieldValue(_Fields field, Object value) {
23395 switch (field) {
23396 case TABLE_NAME:
23397 if (value == null) {
23398 unsetTableName();
23399 } else {
23400 setTableName((byte[])value);
23401 }
23402 break;
23403
23404 case ROW:
23405 if (value == null) {
23406 unsetRow();
23407 } else {
23408 setRow((byte[])value);
23409 }
23410 break;
23411
23412 case TIMESTAMP:
23413 if (value == null) {
23414 unsetTimestamp();
23415 } else {
23416 setTimestamp((Long)value);
23417 }
23418 break;
23419
23420 }
23421 }
23422
23423 public void setFieldValue(int fieldID, Object value) {
23424 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23425 }
23426
23427 public Object getFieldValue(_Fields field) {
23428 switch (field) {
23429 case TABLE_NAME:
23430 return getTableName();
23431
23432 case ROW:
23433 return getRow();
23434
23435 case TIMESTAMP:
23436 return new Long(getTimestamp());
23437
23438 }
23439 throw new IllegalStateException();
23440 }
23441
23442 public Object getFieldValue(int fieldId) {
23443 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23444 }
23445
23446
23447 public boolean isSet(_Fields field) {
23448 switch (field) {
23449 case TABLE_NAME:
23450 return isSetTableName();
23451 case ROW:
23452 return isSetRow();
23453 case TIMESTAMP:
23454 return isSetTimestamp();
23455 }
23456 throw new IllegalStateException();
23457 }
23458
23459 public boolean isSet(int fieldID) {
23460 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23461 }
23462
23463 @Override
23464 public boolean equals(Object that) {
23465 if (that == null)
23466 return false;
23467 if (that instanceof deleteAllRowTs_args)
23468 return this.equals((deleteAllRowTs_args)that);
23469 return false;
23470 }
23471
23472 public boolean equals(deleteAllRowTs_args that) {
23473 if (that == null)
23474 return false;
23475
23476 boolean this_present_tableName = true && this.isSetTableName();
23477 boolean that_present_tableName = true && that.isSetTableName();
23478 if (this_present_tableName || that_present_tableName) {
23479 if (!(this_present_tableName && that_present_tableName))
23480 return false;
23481 if (!java.util.Arrays.equals(this.tableName, that.tableName))
23482 return false;
23483 }
23484
23485 boolean this_present_row = true && this.isSetRow();
23486 boolean that_present_row = true && that.isSetRow();
23487 if (this_present_row || that_present_row) {
23488 if (!(this_present_row && that_present_row))
23489 return false;
23490 if (!java.util.Arrays.equals(this.row, that.row))
23491 return false;
23492 }
23493
23494 boolean this_present_timestamp = true;
23495 boolean that_present_timestamp = true;
23496 if (this_present_timestamp || that_present_timestamp) {
23497 if (!(this_present_timestamp && that_present_timestamp))
23498 return false;
23499 if (this.timestamp != that.timestamp)
23500 return false;
23501 }
23502
23503 return true;
23504 }
23505
23506 @Override
23507 public int hashCode() {
23508 HashCodeBuilder builder = new HashCodeBuilder();
23509
23510 boolean present_tableName = true && (isSetTableName());
23511 builder.append(present_tableName);
23512 if (present_tableName)
23513 builder.append(tableName);
23514
23515 boolean present_row = true && (isSetRow());
23516 builder.append(present_row);
23517 if (present_row)
23518 builder.append(row);
23519
23520 boolean present_timestamp = true;
23521 builder.append(present_timestamp);
23522 if (present_timestamp)
23523 builder.append(timestamp);
23524
23525 return builder.toHashCode();
23526 }
23527
23528 public int compareTo(deleteAllRowTs_args other) {
23529 if (!getClass().equals(other.getClass())) {
23530 return getClass().getName().compareTo(other.getClass().getName());
23531 }
23532
23533 int lastComparison = 0;
23534 deleteAllRowTs_args typedOther = (deleteAllRowTs_args)other;
23535
23536 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
23537 if (lastComparison != 0) {
23538 return lastComparison;
23539 }
23540 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
23541 if (lastComparison != 0) {
23542 return lastComparison;
23543 }
23544 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
23545 if (lastComparison != 0) {
23546 return lastComparison;
23547 }
23548 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
23549 if (lastComparison != 0) {
23550 return lastComparison;
23551 }
23552 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
23553 if (lastComparison != 0) {
23554 return lastComparison;
23555 }
23556 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
23557 if (lastComparison != 0) {
23558 return lastComparison;
23559 }
23560 return 0;
23561 }
23562
23563 public void read(TProtocol iprot) throws TException {
23564 TField field;
23565 iprot.readStructBegin();
23566 while (true)
23567 {
23568 field = iprot.readFieldBegin();
23569 if (field.type == TType.STOP) {
23570 break;
23571 }
23572 _Fields fieldId = _Fields.findByThriftId(field.id);
23573 if (fieldId == null) {
23574 TProtocolUtil.skip(iprot, field.type);
23575 } else {
23576 switch (fieldId) {
23577 case TABLE_NAME:
23578 if (field.type == TType.STRING) {
23579 this.tableName = iprot.readBinary();
23580 } else {
23581 TProtocolUtil.skip(iprot, field.type);
23582 }
23583 break;
23584 case ROW:
23585 if (field.type == TType.STRING) {
23586 this.row = iprot.readBinary();
23587 } else {
23588 TProtocolUtil.skip(iprot, field.type);
23589 }
23590 break;
23591 case TIMESTAMP:
23592 if (field.type == TType.I64) {
23593 this.timestamp = iprot.readI64();
23594 setTimestampIsSet(true);
23595 } else {
23596 TProtocolUtil.skip(iprot, field.type);
23597 }
23598 break;
23599 }
23600 iprot.readFieldEnd();
23601 }
23602 }
23603 iprot.readStructEnd();
23604
23605
23606 validate();
23607 }
23608
23609 public void write(TProtocol oprot) throws TException {
23610 validate();
23611
23612 oprot.writeStructBegin(STRUCT_DESC);
23613 if (this.tableName != null) {
23614 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
23615 oprot.writeBinary(this.tableName);
23616 oprot.writeFieldEnd();
23617 }
23618 if (this.row != null) {
23619 oprot.writeFieldBegin(ROW_FIELD_DESC);
23620 oprot.writeBinary(this.row);
23621 oprot.writeFieldEnd();
23622 }
23623 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
23624 oprot.writeI64(this.timestamp);
23625 oprot.writeFieldEnd();
23626 oprot.writeFieldStop();
23627 oprot.writeStructEnd();
23628 }
23629
23630 @Override
23631 public String toString() {
23632 StringBuilder sb = new StringBuilder("deleteAllRowTs_args(");
23633 boolean first = true;
23634
23635 sb.append("tableName:");
23636 if (this.tableName == null) {
23637 sb.append("null");
23638 } else {
23639 sb.append(this.tableName);
23640 }
23641 first = false;
23642 if (!first) sb.append(", ");
23643 sb.append("row:");
23644 if (this.row == null) {
23645 sb.append("null");
23646 } else {
23647 sb.append(this.row);
23648 }
23649 first = false;
23650 if (!first) sb.append(", ");
23651 sb.append("timestamp:");
23652 sb.append(this.timestamp);
23653 first = false;
23654 sb.append(")");
23655 return sb.toString();
23656 }
23657
23658 public void validate() throws TException {
23659
23660 }
23661
23662 }
23663
23664 public static class deleteAllRowTs_result implements TBase<deleteAllRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_result> {
23665 private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_result");
23666
23667 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
23668
23669 public IOError io;
23670
23671
23672 public enum _Fields implements TFieldIdEnum {
23673 IO((short)1, "io");
23674
23675 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23676 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23677
23678 static {
23679 for (_Fields field : EnumSet.allOf(_Fields.class)) {
23680 byId.put((int)field._thriftId, field);
23681 byName.put(field.getFieldName(), field);
23682 }
23683 }
23684
23685
23686
23687
23688 public static _Fields findByThriftId(int fieldId) {
23689 return byId.get(fieldId);
23690 }
23691
23692
23693
23694
23695
23696 public static _Fields findByThriftIdOrThrow(int fieldId) {
23697 _Fields fields = findByThriftId(fieldId);
23698 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
23699 return fields;
23700 }
23701
23702
23703
23704
23705 public static _Fields findByName(String name) {
23706 return byName.get(name);
23707 }
23708
23709 private final short _thriftId;
23710 private final String _fieldName;
23711
23712 _Fields(short thriftId, String fieldName) {
23713 _thriftId = thriftId;
23714 _fieldName = fieldName;
23715 }
23716
23717 public short getThriftFieldId() {
23718 return _thriftId;
23719 }
23720
23721 public String getFieldName() {
23722 return _fieldName;
23723 }
23724 }
23725
23726
23727
23728 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
23729 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
23730 new FieldValueMetaData(TType.STRUCT)));
23731 }});
23732
23733 static {
23734 FieldMetaData.addStructMetaDataMap(deleteAllRowTs_result.class, metaDataMap);
23735 }
23736
23737 public deleteAllRowTs_result() {
23738 }
23739
23740 public deleteAllRowTs_result(
23741 IOError io)
23742 {
23743 this();
23744 this.io = io;
23745 }
23746
23747
23748
23749
23750 public deleteAllRowTs_result(deleteAllRowTs_result other) {
23751 if (other.isSetIo()) {
23752 this.io = new IOError(other.io);
23753 }
23754 }
23755
23756 public deleteAllRowTs_result deepCopy() {
23757 return new deleteAllRowTs_result(this);
23758 }
23759
23760 @Deprecated
23761 public deleteAllRowTs_result clone() {
23762 return new deleteAllRowTs_result(this);
23763 }
23764
23765 public IOError getIo() {
23766 return this.io;
23767 }
23768
23769 public deleteAllRowTs_result setIo(IOError io) {
23770 this.io = io;
23771 return this;
23772 }
23773
23774 public void unsetIo() {
23775 this.io = null;
23776 }
23777
23778
23779 public boolean isSetIo() {
23780 return this.io != null;
23781 }
23782
23783 public void setIoIsSet(boolean value) {
23784 if (!value) {
23785 this.io = null;
23786 }
23787 }
23788
23789 public void setFieldValue(_Fields field, Object value) {
23790 switch (field) {
23791 case IO:
23792 if (value == null) {
23793 unsetIo();
23794 } else {
23795 setIo((IOError)value);
23796 }
23797 break;
23798
23799 }
23800 }
23801
23802 public void setFieldValue(int fieldID, Object value) {
23803 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23804 }
23805
23806 public Object getFieldValue(_Fields field) {
23807 switch (field) {
23808 case IO:
23809 return getIo();
23810
23811 }
23812 throw new IllegalStateException();
23813 }
23814
23815 public Object getFieldValue(int fieldId) {
23816 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23817 }
23818
23819
23820 public boolean isSet(_Fields field) {
23821 switch (field) {
23822 case IO:
23823 return isSetIo();
23824 }
23825 throw new IllegalStateException();
23826 }
23827
23828 public boolean isSet(int fieldID) {
23829 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23830 }
23831
23832 @Override
23833 public boolean equals(Object that) {
23834 if (that == null)
23835 return false;
23836 if (that instanceof deleteAllRowTs_result)
23837 return this.equals((deleteAllRowTs_result)that);
23838 return false;
23839 }
23840
23841 public boolean equals(deleteAllRowTs_result that) {
23842 if (that == null)
23843 return false;
23844
23845 boolean this_present_io = true && this.isSetIo();
23846 boolean that_present_io = true && that.isSetIo();
23847 if (this_present_io || that_present_io) {
23848 if (!(this_present_io && that_present_io))
23849 return false;
23850 if (!this.io.equals(that.io))
23851 return false;
23852 }
23853
23854 return true;
23855 }
23856
23857 @Override
23858 public int hashCode() {
23859 HashCodeBuilder builder = new HashCodeBuilder();
23860
23861 boolean present_io = true && (isSetIo());
23862 builder.append(present_io);
23863 if (present_io)
23864 builder.append(io);
23865
23866 return builder.toHashCode();
23867 }
23868
23869 public int compareTo(deleteAllRowTs_result other) {
23870 if (!getClass().equals(other.getClass())) {
23871 return getClass().getName().compareTo(other.getClass().getName());
23872 }
23873
23874 int lastComparison = 0;
23875 deleteAllRowTs_result typedOther = (deleteAllRowTs_result)other;
23876
23877 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
23878 if (lastComparison != 0) {
23879 return lastComparison;
23880 }
23881 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
23882 if (lastComparison != 0) {
23883 return lastComparison;
23884 }
23885 return 0;
23886 }
23887
23888 public void read(TProtocol iprot) throws TException {
23889 TField field;
23890 iprot.readStructBegin();
23891 while (true)
23892 {
23893 field = iprot.readFieldBegin();
23894 if (field.type == TType.STOP) {
23895 break;
23896 }
23897 _Fields fieldId = _Fields.findByThriftId(field.id);
23898 if (fieldId == null) {
23899 TProtocolUtil.skip(iprot, field.type);
23900 } else {
23901 switch (fieldId) {
23902 case IO:
23903 if (field.type == TType.STRUCT) {
23904 this.io = new IOError();
23905 this.io.read(iprot);
23906 } else {
23907 TProtocolUtil.skip(iprot, field.type);
23908 }
23909 break;
23910 }
23911 iprot.readFieldEnd();
23912 }
23913 }
23914 iprot.readStructEnd();
23915
23916
23917 validate();
23918 }
23919
23920 public void write(TProtocol oprot) throws TException {
23921 oprot.writeStructBegin(STRUCT_DESC);
23922
23923 if (this.isSetIo()) {
23924 oprot.writeFieldBegin(IO_FIELD_DESC);
23925 this.io.write(oprot);
23926 oprot.writeFieldEnd();
23927 }
23928 oprot.writeFieldStop();
23929 oprot.writeStructEnd();
23930 }
23931
23932 @Override
23933 public String toString() {
23934 StringBuilder sb = new StringBuilder("deleteAllRowTs_result(");
23935 boolean first = true;
23936
23937 sb.append("io:");
23938 if (this.io == null) {
23939 sb.append("null");
23940 } else {
23941 sb.append(this.io);
23942 }
23943 first = false;
23944 sb.append(")");
23945 return sb.toString();
23946 }
23947
23948 public void validate() throws TException {
23949
23950 }
23951
23952 }
23953
23954 public static class scannerOpen_args implements TBase<scannerOpen_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_args> {
23955 private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_args");
23956
23957 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
23958 private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
23959 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
23960
23961
23962
23963
23964 public byte[] tableName;
23965
23966
23967
23968
23969 public byte[] startRow;
23970
23971
23972
23973
23974
23975 public List<byte[]> columns;
23976
23977
23978 public enum _Fields implements TFieldIdEnum {
23979
23980
23981
23982 TABLE_NAME((short)1, "tableName"),
23983
23984
23985
23986
23987 START_ROW((short)2, "startRow"),
23988
23989
23990
23991
23992
23993 COLUMNS((short)3, "columns");
23994
23995 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23996 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23997
23998 static {
23999 for (_Fields field : EnumSet.allOf(_Fields.class)) {
24000 byId.put((int)field._thriftId, field);
24001 byName.put(field.getFieldName(), field);
24002 }
24003 }
24004
24005
24006
24007
24008 public static _Fields findByThriftId(int fieldId) {
24009 return byId.get(fieldId);
24010 }
24011
24012
24013
24014
24015
24016 public static _Fields findByThriftIdOrThrow(int fieldId) {
24017 _Fields fields = findByThriftId(fieldId);
24018 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24019 return fields;
24020 }
24021
24022
24023
24024
24025 public static _Fields findByName(String name) {
24026 return byName.get(name);
24027 }
24028
24029 private final short _thriftId;
24030 private final String _fieldName;
24031
24032 _Fields(short thriftId, String fieldName) {
24033 _thriftId = thriftId;
24034 _fieldName = fieldName;
24035 }
24036
24037 public short getThriftFieldId() {
24038 return _thriftId;
24039 }
24040
24041 public String getFieldName() {
24042 return _fieldName;
24043 }
24044 }
24045
24046
24047
24048 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24049 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
24050 new FieldValueMetaData(TType.STRING)));
24051 put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
24052 new FieldValueMetaData(TType.STRING)));
24053 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
24054 new ListMetaData(TType.LIST,
24055 new FieldValueMetaData(TType.STRING))));
24056 }});
24057
24058 static {
24059 FieldMetaData.addStructMetaDataMap(scannerOpen_args.class, metaDataMap);
24060 }
24061
24062 public scannerOpen_args() {
24063 }
24064
24065 public scannerOpen_args(
24066 byte[] tableName,
24067 byte[] startRow,
24068 List<byte[]> columns)
24069 {
24070 this();
24071 this.tableName = tableName;
24072 this.startRow = startRow;
24073 this.columns = columns;
24074 }
24075
24076
24077
24078
24079 public scannerOpen_args(scannerOpen_args other) {
24080 if (other.isSetTableName()) {
24081 this.tableName = other.tableName;
24082 }
24083 if (other.isSetStartRow()) {
24084 this.startRow = other.startRow;
24085 }
24086 if (other.isSetColumns()) {
24087 List<byte[]> __this__columns = new ArrayList<byte[]>();
24088 for (byte[] other_element : other.columns) {
24089 __this__columns.add(other_element);
24090 }
24091 this.columns = __this__columns;
24092 }
24093 }
24094
24095 public scannerOpen_args deepCopy() {
24096 return new scannerOpen_args(this);
24097 }
24098
24099 @Deprecated
24100 public scannerOpen_args clone() {
24101 return new scannerOpen_args(this);
24102 }
24103
24104
24105
24106
24107 public byte[] getTableName() {
24108 return this.tableName;
24109 }
24110
24111
24112
24113
24114 public scannerOpen_args setTableName(byte[] tableName) {
24115 this.tableName = tableName;
24116 return this;
24117 }
24118
24119 public void unsetTableName() {
24120 this.tableName = null;
24121 }
24122
24123
24124 public boolean isSetTableName() {
24125 return this.tableName != null;
24126 }
24127
24128 public void setTableNameIsSet(boolean value) {
24129 if (!value) {
24130 this.tableName = null;
24131 }
24132 }
24133
24134
24135
24136
24137
24138 public byte[] getStartRow() {
24139 return this.startRow;
24140 }
24141
24142
24143
24144
24145
24146 public scannerOpen_args setStartRow(byte[] startRow) {
24147 this.startRow = startRow;
24148 return this;
24149 }
24150
24151 public void unsetStartRow() {
24152 this.startRow = null;
24153 }
24154
24155
24156 public boolean isSetStartRow() {
24157 return this.startRow != null;
24158 }
24159
24160 public void setStartRowIsSet(boolean value) {
24161 if (!value) {
24162 this.startRow = null;
24163 }
24164 }
24165
24166 public int getColumnsSize() {
24167 return (this.columns == null) ? 0 : this.columns.size();
24168 }
24169
24170 public java.util.Iterator<byte[]> getColumnsIterator() {
24171 return (this.columns == null) ? null : this.columns.iterator();
24172 }
24173
24174 public void addToColumns(byte[] elem) {
24175 if (this.columns == null) {
24176 this.columns = new ArrayList<byte[]>();
24177 }
24178 this.columns.add(elem);
24179 }
24180
24181
24182
24183
24184
24185
24186 public List<byte[]> getColumns() {
24187 return this.columns;
24188 }
24189
24190
24191
24192
24193
24194
24195 public scannerOpen_args setColumns(List<byte[]> columns) {
24196 this.columns = columns;
24197 return this;
24198 }
24199
24200 public void unsetColumns() {
24201 this.columns = null;
24202 }
24203
24204
24205 public boolean isSetColumns() {
24206 return this.columns != null;
24207 }
24208
24209 public void setColumnsIsSet(boolean value) {
24210 if (!value) {
24211 this.columns = null;
24212 }
24213 }
24214
24215 public void setFieldValue(_Fields field, Object value) {
24216 switch (field) {
24217 case TABLE_NAME:
24218 if (value == null) {
24219 unsetTableName();
24220 } else {
24221 setTableName((byte[])value);
24222 }
24223 break;
24224
24225 case START_ROW:
24226 if (value == null) {
24227 unsetStartRow();
24228 } else {
24229 setStartRow((byte[])value);
24230 }
24231 break;
24232
24233 case COLUMNS:
24234 if (value == null) {
24235 unsetColumns();
24236 } else {
24237 setColumns((List<byte[]>)value);
24238 }
24239 break;
24240
24241 }
24242 }
24243
24244 public void setFieldValue(int fieldID, Object value) {
24245 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
24246 }
24247
24248 public Object getFieldValue(_Fields field) {
24249 switch (field) {
24250 case TABLE_NAME:
24251 return getTableName();
24252
24253 case START_ROW:
24254 return getStartRow();
24255
24256 case COLUMNS:
24257 return getColumns();
24258
24259 }
24260 throw new IllegalStateException();
24261 }
24262
24263 public Object getFieldValue(int fieldId) {
24264 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
24265 }
24266
24267
24268 public boolean isSet(_Fields field) {
24269 switch (field) {
24270 case TABLE_NAME:
24271 return isSetTableName();
24272 case START_ROW:
24273 return isSetStartRow();
24274 case COLUMNS:
24275 return isSetColumns();
24276 }
24277 throw new IllegalStateException();
24278 }
24279
24280 public boolean isSet(int fieldID) {
24281 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
24282 }
24283
24284 @Override
24285 public boolean equals(Object that) {
24286 if (that == null)
24287 return false;
24288 if (that instanceof scannerOpen_args)
24289 return this.equals((scannerOpen_args)that);
24290 return false;
24291 }
24292
24293 public boolean equals(scannerOpen_args that) {
24294 if (that == null)
24295 return false;
24296
24297 boolean this_present_tableName = true && this.isSetTableName();
24298 boolean that_present_tableName = true && that.isSetTableName();
24299 if (this_present_tableName || that_present_tableName) {
24300 if (!(this_present_tableName && that_present_tableName))
24301 return false;
24302 if (!java.util.Arrays.equals(this.tableName, that.tableName))
24303 return false;
24304 }
24305
24306 boolean this_present_startRow = true && this.isSetStartRow();
24307 boolean that_present_startRow = true && that.isSetStartRow();
24308 if (this_present_startRow || that_present_startRow) {
24309 if (!(this_present_startRow && that_present_startRow))
24310 return false;
24311 if (!java.util.Arrays.equals(this.startRow, that.startRow))
24312 return false;
24313 }
24314
24315 boolean this_present_columns = true && this.isSetColumns();
24316 boolean that_present_columns = true && that.isSetColumns();
24317 if (this_present_columns || that_present_columns) {
24318 if (!(this_present_columns && that_present_columns))
24319 return false;
24320 if (!this.columns.equals(that.columns))
24321 return false;
24322 }
24323
24324 return true;
24325 }
24326
24327 @Override
24328 public int hashCode() {
24329 HashCodeBuilder builder = new HashCodeBuilder();
24330
24331 boolean present_tableName = true && (isSetTableName());
24332 builder.append(present_tableName);
24333 if (present_tableName)
24334 builder.append(tableName);
24335
24336 boolean present_startRow = true && (isSetStartRow());
24337 builder.append(present_startRow);
24338 if (present_startRow)
24339 builder.append(startRow);
24340
24341 boolean present_columns = true && (isSetColumns());
24342 builder.append(present_columns);
24343 if (present_columns)
24344 builder.append(columns);
24345
24346 return builder.toHashCode();
24347 }
24348
24349 public int compareTo(scannerOpen_args other) {
24350 if (!getClass().equals(other.getClass())) {
24351 return getClass().getName().compareTo(other.getClass().getName());
24352 }
24353
24354 int lastComparison = 0;
24355 scannerOpen_args typedOther = (scannerOpen_args)other;
24356
24357 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
24358 if (lastComparison != 0) {
24359 return lastComparison;
24360 }
24361 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
24362 if (lastComparison != 0) {
24363 return lastComparison;
24364 }
24365 lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
24366 if (lastComparison != 0) {
24367 return lastComparison;
24368 }
24369 lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
24370 if (lastComparison != 0) {
24371 return lastComparison;
24372 }
24373 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
24374 if (lastComparison != 0) {
24375 return lastComparison;
24376 }
24377 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
24378 if (lastComparison != 0) {
24379 return lastComparison;
24380 }
24381 return 0;
24382 }
24383
24384 public void read(TProtocol iprot) throws TException {
24385 TField field;
24386 iprot.readStructBegin();
24387 while (true)
24388 {
24389 field = iprot.readFieldBegin();
24390 if (field.type == TType.STOP) {
24391 break;
24392 }
24393 _Fields fieldId = _Fields.findByThriftId(field.id);
24394 if (fieldId == null) {
24395 TProtocolUtil.skip(iprot, field.type);
24396 } else {
24397 switch (fieldId) {
24398 case TABLE_NAME:
24399 if (field.type == TType.STRING) {
24400 this.tableName = iprot.readBinary();
24401 } else {
24402 TProtocolUtil.skip(iprot, field.type);
24403 }
24404 break;
24405 case START_ROW:
24406 if (field.type == TType.STRING) {
24407 this.startRow = iprot.readBinary();
24408 } else {
24409 TProtocolUtil.skip(iprot, field.type);
24410 }
24411 break;
24412 case COLUMNS:
24413 if (field.type == TType.LIST) {
24414 {
24415 TList _list78 = iprot.readListBegin();
24416 this.columns = new ArrayList<byte[]>(_list78.size);
24417 for (int _i79 = 0; _i79 < _list78.size; ++_i79)
24418 {
24419 byte[] _elem80;
24420 _elem80 = iprot.readBinary();
24421 this.columns.add(_elem80);
24422 }
24423 iprot.readListEnd();
24424 }
24425 } else {
24426 TProtocolUtil.skip(iprot, field.type);
24427 }
24428 break;
24429 }
24430 iprot.readFieldEnd();
24431 }
24432 }
24433 iprot.readStructEnd();
24434
24435
24436 validate();
24437 }
24438
24439 public void write(TProtocol oprot) throws TException {
24440 validate();
24441
24442 oprot.writeStructBegin(STRUCT_DESC);
24443 if (this.tableName != null) {
24444 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
24445 oprot.writeBinary(this.tableName);
24446 oprot.writeFieldEnd();
24447 }
24448 if (this.startRow != null) {
24449 oprot.writeFieldBegin(START_ROW_FIELD_DESC);
24450 oprot.writeBinary(this.startRow);
24451 oprot.writeFieldEnd();
24452 }
24453 if (this.columns != null) {
24454 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
24455 {
24456 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
24457 for (byte[] _iter81 : this.columns)
24458 {
24459 oprot.writeBinary(_iter81);
24460 }
24461 oprot.writeListEnd();
24462 }
24463 oprot.writeFieldEnd();
24464 }
24465 oprot.writeFieldStop();
24466 oprot.writeStructEnd();
24467 }
24468
24469 @Override
24470 public String toString() {
24471 StringBuilder sb = new StringBuilder("scannerOpen_args(");
24472 boolean first = true;
24473
24474 sb.append("tableName:");
24475 if (this.tableName == null) {
24476 sb.append("null");
24477 } else {
24478 sb.append(this.tableName);
24479 }
24480 first = false;
24481 if (!first) sb.append(", ");
24482 sb.append("startRow:");
24483 if (this.startRow == null) {
24484 sb.append("null");
24485 } else {
24486 sb.append(this.startRow);
24487 }
24488 first = false;
24489 if (!first) sb.append(", ");
24490 sb.append("columns:");
24491 if (this.columns == null) {
24492 sb.append("null");
24493 } else {
24494 sb.append(this.columns);
24495 }
24496 first = false;
24497 sb.append(")");
24498 return sb.toString();
24499 }
24500
24501 public void validate() throws TException {
24502
24503 }
24504
24505 }
24506
24507 public static class scannerOpen_result implements TBase<scannerOpen_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_result> {
24508 private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_result");
24509
24510 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
24511 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
24512
24513 public int success;
24514 public IOError io;
24515
24516
24517 public enum _Fields implements TFieldIdEnum {
24518 SUCCESS((short)0, "success"),
24519 IO((short)1, "io");
24520
24521 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
24522 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
24523
24524 static {
24525 for (_Fields field : EnumSet.allOf(_Fields.class)) {
24526 byId.put((int)field._thriftId, field);
24527 byName.put(field.getFieldName(), field);
24528 }
24529 }
24530
24531
24532
24533
24534 public static _Fields findByThriftId(int fieldId) {
24535 return byId.get(fieldId);
24536 }
24537
24538
24539
24540
24541
24542 public static _Fields findByThriftIdOrThrow(int fieldId) {
24543 _Fields fields = findByThriftId(fieldId);
24544 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24545 return fields;
24546 }
24547
24548
24549
24550
24551 public static _Fields findByName(String name) {
24552 return byName.get(name);
24553 }
24554
24555 private final short _thriftId;
24556 private final String _fieldName;
24557
24558 _Fields(short thriftId, String fieldName) {
24559 _thriftId = thriftId;
24560 _fieldName = fieldName;
24561 }
24562
24563 public short getThriftFieldId() {
24564 return _thriftId;
24565 }
24566
24567 public String getFieldName() {
24568 return _fieldName;
24569 }
24570 }
24571
24572
24573 private static final int __SUCCESS_ISSET_ID = 0;
24574 private BitSet __isset_bit_vector = new BitSet(1);
24575
24576 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24577 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
24578 new FieldValueMetaData(TType.I32)));
24579 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
24580 new FieldValueMetaData(TType.STRUCT)));
24581 }});
24582
24583 static {
24584 FieldMetaData.addStructMetaDataMap(scannerOpen_result.class, metaDataMap);
24585 }
24586
24587 public scannerOpen_result() {
24588 }
24589
24590 public scannerOpen_result(
24591 int success,
24592 IOError io)
24593 {
24594 this();
24595 this.success = success;
24596 setSuccessIsSet(true);
24597 this.io = io;
24598 }
24599
24600
24601
24602
24603 public scannerOpen_result(scannerOpen_result other) {
24604 __isset_bit_vector.clear();
24605 __isset_bit_vector.or(other.__isset_bit_vector);
24606 this.success = other.success;
24607 if (other.isSetIo()) {
24608 this.io = new IOError(other.io);
24609 }
24610 }
24611
24612 public scannerOpen_result deepCopy() {
24613 return new scannerOpen_result(this);
24614 }
24615
24616 @Deprecated
24617 public scannerOpen_result clone() {
24618 return new scannerOpen_result(this);
24619 }
24620
24621 public int getSuccess() {
24622 return this.success;
24623 }
24624
24625 public scannerOpen_result setSuccess(int success) {
24626 this.success = success;
24627 setSuccessIsSet(true);
24628 return this;
24629 }
24630
24631 public void unsetSuccess() {
24632 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
24633 }
24634
24635
24636 public boolean isSetSuccess() {
24637 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
24638 }
24639
24640 public void setSuccessIsSet(boolean value) {
24641 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
24642 }
24643
24644 public IOError getIo() {
24645 return this.io;
24646 }
24647
24648 public scannerOpen_result setIo(IOError io) {
24649 this.io = io;
24650 return this;
24651 }
24652
24653 public void unsetIo() {
24654 this.io = null;
24655 }
24656
24657
24658 public boolean isSetIo() {
24659 return this.io != null;
24660 }
24661
24662 public void setIoIsSet(boolean value) {
24663 if (!value) {
24664 this.io = null;
24665 }
24666 }
24667
24668 public void setFieldValue(_Fields field, Object value) {
24669 switch (field) {
24670 case SUCCESS:
24671 if (value == null) {
24672 unsetSuccess();
24673 } else {
24674 setSuccess((Integer)value);
24675 }
24676 break;
24677
24678 case IO:
24679 if (value == null) {
24680 unsetIo();
24681 } else {
24682 setIo((IOError)value);
24683 }
24684 break;
24685
24686 }
24687 }
24688
24689 public void setFieldValue(int fieldID, Object value) {
24690 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
24691 }
24692
24693 public Object getFieldValue(_Fields field) {
24694 switch (field) {
24695 case SUCCESS:
24696 return new Integer(getSuccess());
24697
24698 case IO:
24699 return getIo();
24700
24701 }
24702 throw new IllegalStateException();
24703 }
24704
24705 public Object getFieldValue(int fieldId) {
24706 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
24707 }
24708
24709
24710 public boolean isSet(_Fields field) {
24711 switch (field) {
24712 case SUCCESS:
24713 return isSetSuccess();
24714 case IO:
24715 return isSetIo();
24716 }
24717 throw new IllegalStateException();
24718 }
24719
24720 public boolean isSet(int fieldID) {
24721 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
24722 }
24723
24724 @Override
24725 public boolean equals(Object that) {
24726 if (that == null)
24727 return false;
24728 if (that instanceof scannerOpen_result)
24729 return this.equals((scannerOpen_result)that);
24730 return false;
24731 }
24732
24733 public boolean equals(scannerOpen_result that) {
24734 if (that == null)
24735 return false;
24736
24737 boolean this_present_success = true;
24738 boolean that_present_success = true;
24739 if (this_present_success || that_present_success) {
24740 if (!(this_present_success && that_present_success))
24741 return false;
24742 if (this.success != that.success)
24743 return false;
24744 }
24745
24746 boolean this_present_io = true && this.isSetIo();
24747 boolean that_present_io = true && that.isSetIo();
24748 if (this_present_io || that_present_io) {
24749 if (!(this_present_io && that_present_io))
24750 return false;
24751 if (!this.io.equals(that.io))
24752 return false;
24753 }
24754
24755 return true;
24756 }
24757
24758 @Override
24759 public int hashCode() {
24760 HashCodeBuilder builder = new HashCodeBuilder();
24761
24762 boolean present_success = true;
24763 builder.append(present_success);
24764 if (present_success)
24765 builder.append(success);
24766
24767 boolean present_io = true && (isSetIo());
24768 builder.append(present_io);
24769 if (present_io)
24770 builder.append(io);
24771
24772 return builder.toHashCode();
24773 }
24774
24775 public int compareTo(scannerOpen_result other) {
24776 if (!getClass().equals(other.getClass())) {
24777 return getClass().getName().compareTo(other.getClass().getName());
24778 }
24779
24780 int lastComparison = 0;
24781 scannerOpen_result typedOther = (scannerOpen_result)other;
24782
24783 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
24784 if (lastComparison != 0) {
24785 return lastComparison;
24786 }
24787 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
24788 if (lastComparison != 0) {
24789 return lastComparison;
24790 }
24791 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
24792 if (lastComparison != 0) {
24793 return lastComparison;
24794 }
24795 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
24796 if (lastComparison != 0) {
24797 return lastComparison;
24798 }
24799 return 0;
24800 }
24801
24802 public void read(TProtocol iprot) throws TException {
24803 TField field;
24804 iprot.readStructBegin();
24805 while (true)
24806 {
24807 field = iprot.readFieldBegin();
24808 if (field.type == TType.STOP) {
24809 break;
24810 }
24811 _Fields fieldId = _Fields.findByThriftId(field.id);
24812 if (fieldId == null) {
24813 TProtocolUtil.skip(iprot, field.type);
24814 } else {
24815 switch (fieldId) {
24816 case SUCCESS:
24817 if (field.type == TType.I32) {
24818 this.success = iprot.readI32();
24819 setSuccessIsSet(true);
24820 } else {
24821 TProtocolUtil.skip(iprot, field.type);
24822 }
24823 break;
24824 case IO:
24825 if (field.type == TType.STRUCT) {
24826 this.io = new IOError();
24827 this.io.read(iprot);
24828 } else {
24829 TProtocolUtil.skip(iprot, field.type);
24830 }
24831 break;
24832 }
24833 iprot.readFieldEnd();
24834 }
24835 }
24836 iprot.readStructEnd();
24837
24838
24839 validate();
24840 }
24841
24842 public void write(TProtocol oprot) throws TException {
24843 oprot.writeStructBegin(STRUCT_DESC);
24844
24845 if (this.isSetSuccess()) {
24846 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
24847 oprot.writeI32(this.success);
24848 oprot.writeFieldEnd();
24849 } else if (this.isSetIo()) {
24850 oprot.writeFieldBegin(IO_FIELD_DESC);
24851 this.io.write(oprot);
24852 oprot.writeFieldEnd();
24853 }
24854 oprot.writeFieldStop();
24855 oprot.writeStructEnd();
24856 }
24857
24858 @Override
24859 public String toString() {
24860 StringBuilder sb = new StringBuilder("scannerOpen_result(");
24861 boolean first = true;
24862
24863 sb.append("success:");
24864 sb.append(this.success);
24865 first = false;
24866 if (!first) sb.append(", ");
24867 sb.append("io:");
24868 if (this.io == null) {
24869 sb.append("null");
24870 } else {
24871 sb.append(this.io);
24872 }
24873 first = false;
24874 sb.append(")");
24875 return sb.toString();
24876 }
24877
24878 public void validate() throws TException {
24879
24880 }
24881
24882 }
24883
24884 public static class scannerOpenWithStop_args implements TBase<scannerOpenWithStop_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_args> {
24885 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_args");
24886
24887 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
24888 private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
24889 private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3);
24890 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4);
24891
24892
24893
24894
24895 public byte[] tableName;
24896
24897
24898
24899
24900 public byte[] startRow;
24901
24902
24903
24904
24905 public byte[] stopRow;
24906
24907
24908
24909
24910
24911 public List<byte[]> columns;
24912
24913
24914 public enum _Fields implements TFieldIdEnum {
24915
24916
24917
24918 TABLE_NAME((short)1, "tableName"),
24919
24920
24921
24922
24923 START_ROW((short)2, "startRow"),
24924
24925
24926
24927
24928 STOP_ROW((short)3, "stopRow"),
24929
24930
24931
24932
24933
24934 COLUMNS((short)4, "columns");
24935
24936 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
24937 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
24938
24939 static {
24940 for (_Fields field : EnumSet.allOf(_Fields.class)) {
24941 byId.put((int)field._thriftId, field);
24942 byName.put(field.getFieldName(), field);
24943 }
24944 }
24945
24946
24947
24948
24949 public static _Fields findByThriftId(int fieldId) {
24950 return byId.get(fieldId);
24951 }
24952
24953
24954
24955
24956
24957 public static _Fields findByThriftIdOrThrow(int fieldId) {
24958 _Fields fields = findByThriftId(fieldId);
24959 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24960 return fields;
24961 }
24962
24963
24964
24965
24966 public static _Fields findByName(String name) {
24967 return byName.get(name);
24968 }
24969
24970 private final short _thriftId;
24971 private final String _fieldName;
24972
24973 _Fields(short thriftId, String fieldName) {
24974 _thriftId = thriftId;
24975 _fieldName = fieldName;
24976 }
24977
24978 public short getThriftFieldId() {
24979 return _thriftId;
24980 }
24981
24982 public String getFieldName() {
24983 return _fieldName;
24984 }
24985 }
24986
24987
24988
24989 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24990 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
24991 new FieldValueMetaData(TType.STRING)));
24992 put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
24993 new FieldValueMetaData(TType.STRING)));
24994 put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT,
24995 new FieldValueMetaData(TType.STRING)));
24996 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
24997 new ListMetaData(TType.LIST,
24998 new FieldValueMetaData(TType.STRING))));
24999 }});
25000
25001 static {
25002 FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_args.class, metaDataMap);
25003 }
25004
25005 public scannerOpenWithStop_args() {
25006 }
25007
25008 public scannerOpenWithStop_args(
25009 byte[] tableName,
25010 byte[] startRow,
25011 byte[] stopRow,
25012 List<byte[]> columns)
25013 {
25014 this();
25015 this.tableName = tableName;
25016 this.startRow = startRow;
25017 this.stopRow = stopRow;
25018 this.columns = columns;
25019 }
25020
25021
25022
25023
25024 public scannerOpenWithStop_args(scannerOpenWithStop_args other) {
25025 if (other.isSetTableName()) {
25026 this.tableName = other.tableName;
25027 }
25028 if (other.isSetStartRow()) {
25029 this.startRow = other.startRow;
25030 }
25031 if (other.isSetStopRow()) {
25032 this.stopRow = other.stopRow;
25033 }
25034 if (other.isSetColumns()) {
25035 List<byte[]> __this__columns = new ArrayList<byte[]>();
25036 for (byte[] other_element : other.columns) {
25037 __this__columns.add(other_element);
25038 }
25039 this.columns = __this__columns;
25040 }
25041 }
25042
25043 public scannerOpenWithStop_args deepCopy() {
25044 return new scannerOpenWithStop_args(this);
25045 }
25046
25047 @Deprecated
25048 public scannerOpenWithStop_args clone() {
25049 return new scannerOpenWithStop_args(this);
25050 }
25051
25052
25053
25054
25055 public byte[] getTableName() {
25056 return this.tableName;
25057 }
25058
25059
25060
25061
25062 public scannerOpenWithStop_args setTableName(byte[] tableName) {
25063 this.tableName = tableName;
25064 return this;
25065 }
25066
25067 public void unsetTableName() {
25068 this.tableName = null;
25069 }
25070
25071
25072 public boolean isSetTableName() {
25073 return this.tableName != null;
25074 }
25075
25076 public void setTableNameIsSet(boolean value) {
25077 if (!value) {
25078 this.tableName = null;
25079 }
25080 }
25081
25082
25083
25084
25085
25086 public byte[] getStartRow() {
25087 return this.startRow;
25088 }
25089
25090
25091
25092
25093
25094 public scannerOpenWithStop_args setStartRow(byte[] startRow) {
25095 this.startRow = startRow;
25096 return this;
25097 }
25098
25099 public void unsetStartRow() {
25100 this.startRow = null;
25101 }
25102
25103
25104 public boolean isSetStartRow() {
25105 return this.startRow != null;
25106 }
25107
25108 public void setStartRowIsSet(boolean value) {
25109 if (!value) {
25110 this.startRow = null;
25111 }
25112 }
25113
25114
25115
25116
25117
25118 public byte[] getStopRow() {
25119 return this.stopRow;
25120 }
25121
25122
25123
25124
25125
25126 public scannerOpenWithStop_args setStopRow(byte[] stopRow) {
25127 this.stopRow = stopRow;
25128 return this;
25129 }
25130
25131 public void unsetStopRow() {
25132 this.stopRow = null;
25133 }
25134
25135
25136 public boolean isSetStopRow() {
25137 return this.stopRow != null;
25138 }
25139
25140 public void setStopRowIsSet(boolean value) {
25141 if (!value) {
25142 this.stopRow = null;
25143 }
25144 }
25145
25146 public int getColumnsSize() {
25147 return (this.columns == null) ? 0 : this.columns.size();
25148 }
25149
25150 public java.util.Iterator<byte[]> getColumnsIterator() {
25151 return (this.columns == null) ? null : this.columns.iterator();
25152 }
25153
25154 public void addToColumns(byte[] elem) {
25155 if (this.columns == null) {
25156 this.columns = new ArrayList<byte[]>();
25157 }
25158 this.columns.add(elem);
25159 }
25160
25161
25162
25163
25164
25165
25166 public List<byte[]> getColumns() {
25167 return this.columns;
25168 }
25169
25170
25171
25172
25173
25174
25175 public scannerOpenWithStop_args setColumns(List<byte[]> columns) {
25176 this.columns = columns;
25177 return this;
25178 }
25179
25180 public void unsetColumns() {
25181 this.columns = null;
25182 }
25183
25184
25185 public boolean isSetColumns() {
25186 return this.columns != null;
25187 }
25188
25189 public void setColumnsIsSet(boolean value) {
25190 if (!value) {
25191 this.columns = null;
25192 }
25193 }
25194
25195 public void setFieldValue(_Fields field, Object value) {
25196 switch (field) {
25197 case TABLE_NAME:
25198 if (value == null) {
25199 unsetTableName();
25200 } else {
25201 setTableName((byte[])value);
25202 }
25203 break;
25204
25205 case START_ROW:
25206 if (value == null) {
25207 unsetStartRow();
25208 } else {
25209 setStartRow((byte[])value);
25210 }
25211 break;
25212
25213 case STOP_ROW:
25214 if (value == null) {
25215 unsetStopRow();
25216 } else {
25217 setStopRow((byte[])value);
25218 }
25219 break;
25220
25221 case COLUMNS:
25222 if (value == null) {
25223 unsetColumns();
25224 } else {
25225 setColumns((List<byte[]>)value);
25226 }
25227 break;
25228
25229 }
25230 }
25231
25232 public void setFieldValue(int fieldID, Object value) {
25233 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
25234 }
25235
25236 public Object getFieldValue(_Fields field) {
25237 switch (field) {
25238 case TABLE_NAME:
25239 return getTableName();
25240
25241 case START_ROW:
25242 return getStartRow();
25243
25244 case STOP_ROW:
25245 return getStopRow();
25246
25247 case COLUMNS:
25248 return getColumns();
25249
25250 }
25251 throw new IllegalStateException();
25252 }
25253
25254 public Object getFieldValue(int fieldId) {
25255 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
25256 }
25257
25258
25259 public boolean isSet(_Fields field) {
25260 switch (field) {
25261 case TABLE_NAME:
25262 return isSetTableName();
25263 case START_ROW:
25264 return isSetStartRow();
25265 case STOP_ROW:
25266 return isSetStopRow();
25267 case COLUMNS:
25268 return isSetColumns();
25269 }
25270 throw new IllegalStateException();
25271 }
25272
25273 public boolean isSet(int fieldID) {
25274 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
25275 }
25276
25277 @Override
25278 public boolean equals(Object that) {
25279 if (that == null)
25280 return false;
25281 if (that instanceof scannerOpenWithStop_args)
25282 return this.equals((scannerOpenWithStop_args)that);
25283 return false;
25284 }
25285
25286 public boolean equals(scannerOpenWithStop_args that) {
25287 if (that == null)
25288 return false;
25289
25290 boolean this_present_tableName = true && this.isSetTableName();
25291 boolean that_present_tableName = true && that.isSetTableName();
25292 if (this_present_tableName || that_present_tableName) {
25293 if (!(this_present_tableName && that_present_tableName))
25294 return false;
25295 if (!java.util.Arrays.equals(this.tableName, that.tableName))
25296 return false;
25297 }
25298
25299 boolean this_present_startRow = true && this.isSetStartRow();
25300 boolean that_present_startRow = true && that.isSetStartRow();
25301 if (this_present_startRow || that_present_startRow) {
25302 if (!(this_present_startRow && that_present_startRow))
25303 return false;
25304 if (!java.util.Arrays.equals(this.startRow, that.startRow))
25305 return false;
25306 }
25307
25308 boolean this_present_stopRow = true && this.isSetStopRow();
25309 boolean that_present_stopRow = true && that.isSetStopRow();
25310 if (this_present_stopRow || that_present_stopRow) {
25311 if (!(this_present_stopRow && that_present_stopRow))
25312 return false;
25313 if (!java.util.Arrays.equals(this.stopRow, that.stopRow))
25314 return false;
25315 }
25316
25317 boolean this_present_columns = true && this.isSetColumns();
25318 boolean that_present_columns = true && that.isSetColumns();
25319 if (this_present_columns || that_present_columns) {
25320 if (!(this_present_columns && that_present_columns))
25321 return false;
25322 if (!this.columns.equals(that.columns))
25323 return false;
25324 }
25325
25326 return true;
25327 }
25328
25329 @Override
25330 public int hashCode() {
25331 HashCodeBuilder builder = new HashCodeBuilder();
25332
25333 boolean present_tableName = true && (isSetTableName());
25334 builder.append(present_tableName);
25335 if (present_tableName)
25336 builder.append(tableName);
25337
25338 boolean present_startRow = true && (isSetStartRow());
25339 builder.append(present_startRow);
25340 if (present_startRow)
25341 builder.append(startRow);
25342
25343 boolean present_stopRow = true && (isSetStopRow());
25344 builder.append(present_stopRow);
25345 if (present_stopRow)
25346 builder.append(stopRow);
25347
25348 boolean present_columns = true && (isSetColumns());
25349 builder.append(present_columns);
25350 if (present_columns)
25351 builder.append(columns);
25352
25353 return builder.toHashCode();
25354 }
25355
25356 public int compareTo(scannerOpenWithStop_args other) {
25357 if (!getClass().equals(other.getClass())) {
25358 return getClass().getName().compareTo(other.getClass().getName());
25359 }
25360
25361 int lastComparison = 0;
25362 scannerOpenWithStop_args typedOther = (scannerOpenWithStop_args)other;
25363
25364 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
25365 if (lastComparison != 0) {
25366 return lastComparison;
25367 }
25368 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
25369 if (lastComparison != 0) {
25370 return lastComparison;
25371 }
25372 lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
25373 if (lastComparison != 0) {
25374 return lastComparison;
25375 }
25376 lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
25377 if (lastComparison != 0) {
25378 return lastComparison;
25379 }
25380 lastComparison = Boolean.valueOf(isSetStopRow()).compareTo(isSetStopRow());
25381 if (lastComparison != 0) {
25382 return lastComparison;
25383 }
25384 lastComparison = TBaseHelper.compareTo(stopRow, typedOther.stopRow);
25385 if (lastComparison != 0) {
25386 return lastComparison;
25387 }
25388 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
25389 if (lastComparison != 0) {
25390 return lastComparison;
25391 }
25392 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
25393 if (lastComparison != 0) {
25394 return lastComparison;
25395 }
25396 return 0;
25397 }
25398
25399 public void read(TProtocol iprot) throws TException {
25400 TField field;
25401 iprot.readStructBegin();
25402 while (true)
25403 {
25404 field = iprot.readFieldBegin();
25405 if (field.type == TType.STOP) {
25406 break;
25407 }
25408 _Fields fieldId = _Fields.findByThriftId(field.id);
25409 if (fieldId == null) {
25410 TProtocolUtil.skip(iprot, field.type);
25411 } else {
25412 switch (fieldId) {
25413 case TABLE_NAME:
25414 if (field.type == TType.STRING) {
25415 this.tableName = iprot.readBinary();
25416 } else {
25417 TProtocolUtil.skip(iprot, field.type);
25418 }
25419 break;
25420 case START_ROW:
25421 if (field.type == TType.STRING) {
25422 this.startRow = iprot.readBinary();
25423 } else {
25424 TProtocolUtil.skip(iprot, field.type);
25425 }
25426 break;
25427 case STOP_ROW:
25428 if (field.type == TType.STRING) {
25429 this.stopRow = iprot.readBinary();
25430 } else {
25431 TProtocolUtil.skip(iprot, field.type);
25432 }
25433 break;
25434 case COLUMNS:
25435 if (field.type == TType.LIST) {
25436 {
25437 TList _list82 = iprot.readListBegin();
25438 this.columns = new ArrayList<byte[]>(_list82.size);
25439 for (int _i83 = 0; _i83 < _list82.size; ++_i83)
25440 {
25441 byte[] _elem84;
25442 _elem84 = iprot.readBinary();
25443 this.columns.add(_elem84);
25444 }
25445 iprot.readListEnd();
25446 }
25447 } else {
25448 TProtocolUtil.skip(iprot, field.type);
25449 }
25450 break;
25451 }
25452 iprot.readFieldEnd();
25453 }
25454 }
25455 iprot.readStructEnd();
25456
25457
25458 validate();
25459 }
25460
25461 public void write(TProtocol oprot) throws TException {
25462 validate();
25463
25464 oprot.writeStructBegin(STRUCT_DESC);
25465 if (this.tableName != null) {
25466 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
25467 oprot.writeBinary(this.tableName);
25468 oprot.writeFieldEnd();
25469 }
25470 if (this.startRow != null) {
25471 oprot.writeFieldBegin(START_ROW_FIELD_DESC);
25472 oprot.writeBinary(this.startRow);
25473 oprot.writeFieldEnd();
25474 }
25475 if (this.stopRow != null) {
25476 oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
25477 oprot.writeBinary(this.stopRow);
25478 oprot.writeFieldEnd();
25479 }
25480 if (this.columns != null) {
25481 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
25482 {
25483 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
25484 for (byte[] _iter85 : this.columns)
25485 {
25486 oprot.writeBinary(_iter85);
25487 }
25488 oprot.writeListEnd();
25489 }
25490 oprot.writeFieldEnd();
25491 }
25492 oprot.writeFieldStop();
25493 oprot.writeStructEnd();
25494 }
25495
25496 @Override
25497 public String toString() {
25498 StringBuilder sb = new StringBuilder("scannerOpenWithStop_args(");
25499 boolean first = true;
25500
25501 sb.append("tableName:");
25502 if (this.tableName == null) {
25503 sb.append("null");
25504 } else {
25505 sb.append(this.tableName);
25506 }
25507 first = false;
25508 if (!first) sb.append(", ");
25509 sb.append("startRow:");
25510 if (this.startRow == null) {
25511 sb.append("null");
25512 } else {
25513 sb.append(this.startRow);
25514 }
25515 first = false;
25516 if (!first) sb.append(", ");
25517 sb.append("stopRow:");
25518 if (this.stopRow == null) {
25519 sb.append("null");
25520 } else {
25521 sb.append(this.stopRow);
25522 }
25523 first = false;
25524 if (!first) sb.append(", ");
25525 sb.append("columns:");
25526 if (this.columns == null) {
25527 sb.append("null");
25528 } else {
25529 sb.append(this.columns);
25530 }
25531 first = false;
25532 sb.append(")");
25533 return sb.toString();
25534 }
25535
25536 public void validate() throws TException {
25537
25538 }
25539
25540 }
25541
25542 public static class scannerOpenWithStop_result implements TBase<scannerOpenWithStop_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_result> {
25543 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_result");
25544
25545 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
25546 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
25547
25548 public int success;
25549 public IOError io;
25550
25551
25552 public enum _Fields implements TFieldIdEnum {
25553 SUCCESS((short)0, "success"),
25554 IO((short)1, "io");
25555
25556 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
25557 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
25558
25559 static {
25560 for (_Fields field : EnumSet.allOf(_Fields.class)) {
25561 byId.put((int)field._thriftId, field);
25562 byName.put(field.getFieldName(), field);
25563 }
25564 }
25565
25566
25567
25568
25569 public static _Fields findByThriftId(int fieldId) {
25570 return byId.get(fieldId);
25571 }
25572
25573
25574
25575
25576
25577 public static _Fields findByThriftIdOrThrow(int fieldId) {
25578 _Fields fields = findByThriftId(fieldId);
25579 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
25580 return fields;
25581 }
25582
25583
25584
25585
25586 public static _Fields findByName(String name) {
25587 return byName.get(name);
25588 }
25589
25590 private final short _thriftId;
25591 private final String _fieldName;
25592
25593 _Fields(short thriftId, String fieldName) {
25594 _thriftId = thriftId;
25595 _fieldName = fieldName;
25596 }
25597
25598 public short getThriftFieldId() {
25599 return _thriftId;
25600 }
25601
25602 public String getFieldName() {
25603 return _fieldName;
25604 }
25605 }
25606
25607
25608 private static final int __SUCCESS_ISSET_ID = 0;
25609 private BitSet __isset_bit_vector = new BitSet(1);
25610
25611 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
25612 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
25613 new FieldValueMetaData(TType.I32)));
25614 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
25615 new FieldValueMetaData(TType.STRUCT)));
25616 }});
25617
25618 static {
25619 FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_result.class, metaDataMap);
25620 }
25621
25622 public scannerOpenWithStop_result() {
25623 }
25624
25625 public scannerOpenWithStop_result(
25626 int success,
25627 IOError io)
25628 {
25629 this();
25630 this.success = success;
25631 setSuccessIsSet(true);
25632 this.io = io;
25633 }
25634
25635
25636
25637
25638 public scannerOpenWithStop_result(scannerOpenWithStop_result other) {
25639 __isset_bit_vector.clear();
25640 __isset_bit_vector.or(other.__isset_bit_vector);
25641 this.success = other.success;
25642 if (other.isSetIo()) {
25643 this.io = new IOError(other.io);
25644 }
25645 }
25646
25647 public scannerOpenWithStop_result deepCopy() {
25648 return new scannerOpenWithStop_result(this);
25649 }
25650
25651 @Deprecated
25652 public scannerOpenWithStop_result clone() {
25653 return new scannerOpenWithStop_result(this);
25654 }
25655
25656 public int getSuccess() {
25657 return this.success;
25658 }
25659
25660 public scannerOpenWithStop_result setSuccess(int success) {
25661 this.success = success;
25662 setSuccessIsSet(true);
25663 return this;
25664 }
25665
25666 public void unsetSuccess() {
25667 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
25668 }
25669
25670
25671 public boolean isSetSuccess() {
25672 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
25673 }
25674
25675 public void setSuccessIsSet(boolean value) {
25676 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
25677 }
25678
25679 public IOError getIo() {
25680 return this.io;
25681 }
25682
25683 public scannerOpenWithStop_result setIo(IOError io) {
25684 this.io = io;
25685 return this;
25686 }
25687
25688 public void unsetIo() {
25689 this.io = null;
25690 }
25691
25692
25693 public boolean isSetIo() {
25694 return this.io != null;
25695 }
25696
25697 public void setIoIsSet(boolean value) {
25698 if (!value) {
25699 this.io = null;
25700 }
25701 }
25702
25703 public void setFieldValue(_Fields field, Object value) {
25704 switch (field) {
25705 case SUCCESS:
25706 if (value == null) {
25707 unsetSuccess();
25708 } else {
25709 setSuccess((Integer)value);
25710 }
25711 break;
25712
25713 case IO:
25714 if (value == null) {
25715 unsetIo();
25716 } else {
25717 setIo((IOError)value);
25718 }
25719 break;
25720
25721 }
25722 }
25723
25724 public void setFieldValue(int fieldID, Object value) {
25725 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
25726 }
25727
25728 public Object getFieldValue(_Fields field) {
25729 switch (field) {
25730 case SUCCESS:
25731 return new Integer(getSuccess());
25732
25733 case IO:
25734 return getIo();
25735
25736 }
25737 throw new IllegalStateException();
25738 }
25739
25740 public Object getFieldValue(int fieldId) {
25741 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
25742 }
25743
25744
25745 public boolean isSet(_Fields field) {
25746 switch (field) {
25747 case SUCCESS:
25748 return isSetSuccess();
25749 case IO:
25750 return isSetIo();
25751 }
25752 throw new IllegalStateException();
25753 }
25754
25755 public boolean isSet(int fieldID) {
25756 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
25757 }
25758
25759 @Override
25760 public boolean equals(Object that) {
25761 if (that == null)
25762 return false;
25763 if (that instanceof scannerOpenWithStop_result)
25764 return this.equals((scannerOpenWithStop_result)that);
25765 return false;
25766 }
25767
25768 public boolean equals(scannerOpenWithStop_result that) {
25769 if (that == null)
25770 return false;
25771
25772 boolean this_present_success = true;
25773 boolean that_present_success = true;
25774 if (this_present_success || that_present_success) {
25775 if (!(this_present_success && that_present_success))
25776 return false;
25777 if (this.success != that.success)
25778 return false;
25779 }
25780
25781 boolean this_present_io = true && this.isSetIo();
25782 boolean that_present_io = true && that.isSetIo();
25783 if (this_present_io || that_present_io) {
25784 if (!(this_present_io && that_present_io))
25785 return false;
25786 if (!this.io.equals(that.io))
25787 return false;
25788 }
25789
25790 return true;
25791 }
25792
25793 @Override
25794 public int hashCode() {
25795 HashCodeBuilder builder = new HashCodeBuilder();
25796
25797 boolean present_success = true;
25798 builder.append(present_success);
25799 if (present_success)
25800 builder.append(success);
25801
25802 boolean present_io = true && (isSetIo());
25803 builder.append(present_io);
25804 if (present_io)
25805 builder.append(io);
25806
25807 return builder.toHashCode();
25808 }
25809
25810 public int compareTo(scannerOpenWithStop_result other) {
25811 if (!getClass().equals(other.getClass())) {
25812 return getClass().getName().compareTo(other.getClass().getName());
25813 }
25814
25815 int lastComparison = 0;
25816 scannerOpenWithStop_result typedOther = (scannerOpenWithStop_result)other;
25817
25818 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
25819 if (lastComparison != 0) {
25820 return lastComparison;
25821 }
25822 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
25823 if (lastComparison != 0) {
25824 return lastComparison;
25825 }
25826 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
25827 if (lastComparison != 0) {
25828 return lastComparison;
25829 }
25830 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
25831 if (lastComparison != 0) {
25832 return lastComparison;
25833 }
25834 return 0;
25835 }
25836
25837 public void read(TProtocol iprot) throws TException {
25838 TField field;
25839 iprot.readStructBegin();
25840 while (true)
25841 {
25842 field = iprot.readFieldBegin();
25843 if (field.type == TType.STOP) {
25844 break;
25845 }
25846 _Fields fieldId = _Fields.findByThriftId(field.id);
25847 if (fieldId == null) {
25848 TProtocolUtil.skip(iprot, field.type);
25849 } else {
25850 switch (fieldId) {
25851 case SUCCESS:
25852 if (field.type == TType.I32) {
25853 this.success = iprot.readI32();
25854 setSuccessIsSet(true);
25855 } else {
25856 TProtocolUtil.skip(iprot, field.type);
25857 }
25858 break;
25859 case IO:
25860 if (field.type == TType.STRUCT) {
25861 this.io = new IOError();
25862 this.io.read(iprot);
25863 } else {
25864 TProtocolUtil.skip(iprot, field.type);
25865 }
25866 break;
25867 }
25868 iprot.readFieldEnd();
25869 }
25870 }
25871 iprot.readStructEnd();
25872
25873
25874 validate();
25875 }
25876
25877 public void write(TProtocol oprot) throws TException {
25878 oprot.writeStructBegin(STRUCT_DESC);
25879
25880 if (this.isSetSuccess()) {
25881 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25882 oprot.writeI32(this.success);
25883 oprot.writeFieldEnd();
25884 } else if (this.isSetIo()) {
25885 oprot.writeFieldBegin(IO_FIELD_DESC);
25886 this.io.write(oprot);
25887 oprot.writeFieldEnd();
25888 }
25889 oprot.writeFieldStop();
25890 oprot.writeStructEnd();
25891 }
25892
25893 @Override
25894 public String toString() {
25895 StringBuilder sb = new StringBuilder("scannerOpenWithStop_result(");
25896 boolean first = true;
25897
25898 sb.append("success:");
25899 sb.append(this.success);
25900 first = false;
25901 if (!first) sb.append(", ");
25902 sb.append("io:");
25903 if (this.io == null) {
25904 sb.append("null");
25905 } else {
25906 sb.append(this.io);
25907 }
25908 first = false;
25909 sb.append(")");
25910 return sb.toString();
25911 }
25912
25913 public void validate() throws TException {
25914
25915 }
25916
25917 }
25918
25919 public static class scannerOpenWithPrefix_args implements TBase<scannerOpenWithPrefix_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_args> {
25920 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_args");
25921
25922 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
25923 private static final TField START_AND_PREFIX_FIELD_DESC = new TField("startAndPrefix", TType.STRING, (short)2);
25924 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
25925
25926
25927
25928
25929 public byte[] tableName;
25930
25931
25932
25933 public byte[] startAndPrefix;
25934
25935
25936
25937 public List<byte[]> columns;
25938
25939
25940 public enum _Fields implements TFieldIdEnum {
25941
25942
25943
25944 TABLE_NAME((short)1, "tableName"),
25945
25946
25947
25948 START_AND_PREFIX((short)2, "startAndPrefix"),
25949
25950
25951
25952 COLUMNS((short)3, "columns");
25953
25954 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
25955 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
25956
25957 static {
25958 for (_Fields field : EnumSet.allOf(_Fields.class)) {
25959 byId.put((int)field._thriftId, field);
25960 byName.put(field.getFieldName(), field);
25961 }
25962 }
25963
25964
25965
25966
25967 public static _Fields findByThriftId(int fieldId) {
25968 return byId.get(fieldId);
25969 }
25970
25971
25972
25973
25974
25975 public static _Fields findByThriftIdOrThrow(int fieldId) {
25976 _Fields fields = findByThriftId(fieldId);
25977 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
25978 return fields;
25979 }
25980
25981
25982
25983
25984 public static _Fields findByName(String name) {
25985 return byName.get(name);
25986 }
25987
25988 private final short _thriftId;
25989 private final String _fieldName;
25990
25991 _Fields(short thriftId, String fieldName) {
25992 _thriftId = thriftId;
25993 _fieldName = fieldName;
25994 }
25995
25996 public short getThriftFieldId() {
25997 return _thriftId;
25998 }
25999
26000 public String getFieldName() {
26001 return _fieldName;
26002 }
26003 }
26004
26005
26006
26007 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26008 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
26009 new FieldValueMetaData(TType.STRING)));
26010 put(_Fields.START_AND_PREFIX, new FieldMetaData("startAndPrefix", TFieldRequirementType.DEFAULT,
26011 new FieldValueMetaData(TType.STRING)));
26012 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
26013 new ListMetaData(TType.LIST,
26014 new FieldValueMetaData(TType.STRING))));
26015 }});
26016
26017 static {
26018 FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_args.class, metaDataMap);
26019 }
26020
26021 public scannerOpenWithPrefix_args() {
26022 }
26023
26024 public scannerOpenWithPrefix_args(
26025 byte[] tableName,
26026 byte[] startAndPrefix,
26027 List<byte[]> columns)
26028 {
26029 this();
26030 this.tableName = tableName;
26031 this.startAndPrefix = startAndPrefix;
26032 this.columns = columns;
26033 }
26034
26035
26036
26037
26038 public scannerOpenWithPrefix_args(scannerOpenWithPrefix_args other) {
26039 if (other.isSetTableName()) {
26040 this.tableName = other.tableName;
26041 }
26042 if (other.isSetStartAndPrefix()) {
26043 this.startAndPrefix = other.startAndPrefix;
26044 }
26045 if (other.isSetColumns()) {
26046 List<byte[]> __this__columns = new ArrayList<byte[]>();
26047 for (byte[] other_element : other.columns) {
26048 __this__columns.add(other_element);
26049 }
26050 this.columns = __this__columns;
26051 }
26052 }
26053
26054 public scannerOpenWithPrefix_args deepCopy() {
26055 return new scannerOpenWithPrefix_args(this);
26056 }
26057
26058 @Deprecated
26059 public scannerOpenWithPrefix_args clone() {
26060 return new scannerOpenWithPrefix_args(this);
26061 }
26062
26063
26064
26065
26066 public byte[] getTableName() {
26067 return this.tableName;
26068 }
26069
26070
26071
26072
26073 public scannerOpenWithPrefix_args setTableName(byte[] tableName) {
26074 this.tableName = tableName;
26075 return this;
26076 }
26077
26078 public void unsetTableName() {
26079 this.tableName = null;
26080 }
26081
26082
26083 public boolean isSetTableName() {
26084 return this.tableName != null;
26085 }
26086
26087 public void setTableNameIsSet(boolean value) {
26088 if (!value) {
26089 this.tableName = null;
26090 }
26091 }
26092
26093
26094
26095
26096 public byte[] getStartAndPrefix() {
26097 return this.startAndPrefix;
26098 }
26099
26100
26101
26102
26103 public scannerOpenWithPrefix_args setStartAndPrefix(byte[] startAndPrefix) {
26104 this.startAndPrefix = startAndPrefix;
26105 return this;
26106 }
26107
26108 public void unsetStartAndPrefix() {
26109 this.startAndPrefix = null;
26110 }
26111
26112
26113 public boolean isSetStartAndPrefix() {
26114 return this.startAndPrefix != null;
26115 }
26116
26117 public void setStartAndPrefixIsSet(boolean value) {
26118 if (!value) {
26119 this.startAndPrefix = null;
26120 }
26121 }
26122
26123 public int getColumnsSize() {
26124 return (this.columns == null) ? 0 : this.columns.size();
26125 }
26126
26127 public java.util.Iterator<byte[]> getColumnsIterator() {
26128 return (this.columns == null) ? null : this.columns.iterator();
26129 }
26130
26131 public void addToColumns(byte[] elem) {
26132 if (this.columns == null) {
26133 this.columns = new ArrayList<byte[]>();
26134 }
26135 this.columns.add(elem);
26136 }
26137
26138
26139
26140
26141 public List<byte[]> getColumns() {
26142 return this.columns;
26143 }
26144
26145
26146
26147
26148 public scannerOpenWithPrefix_args setColumns(List<byte[]> columns) {
26149 this.columns = columns;
26150 return this;
26151 }
26152
26153 public void unsetColumns() {
26154 this.columns = null;
26155 }
26156
26157
26158 public boolean isSetColumns() {
26159 return this.columns != null;
26160 }
26161
26162 public void setColumnsIsSet(boolean value) {
26163 if (!value) {
26164 this.columns = null;
26165 }
26166 }
26167
26168 public void setFieldValue(_Fields field, Object value) {
26169 switch (field) {
26170 case TABLE_NAME:
26171 if (value == null) {
26172 unsetTableName();
26173 } else {
26174 setTableName((byte[])value);
26175 }
26176 break;
26177
26178 case START_AND_PREFIX:
26179 if (value == null) {
26180 unsetStartAndPrefix();
26181 } else {
26182 setStartAndPrefix((byte[])value);
26183 }
26184 break;
26185
26186 case COLUMNS:
26187 if (value == null) {
26188 unsetColumns();
26189 } else {
26190 setColumns((List<byte[]>)value);
26191 }
26192 break;
26193
26194 }
26195 }
26196
26197 public void setFieldValue(int fieldID, Object value) {
26198 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26199 }
26200
26201 public Object getFieldValue(_Fields field) {
26202 switch (field) {
26203 case TABLE_NAME:
26204 return getTableName();
26205
26206 case START_AND_PREFIX:
26207 return getStartAndPrefix();
26208
26209 case COLUMNS:
26210 return getColumns();
26211
26212 }
26213 throw new IllegalStateException();
26214 }
26215
26216 public Object getFieldValue(int fieldId) {
26217 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26218 }
26219
26220
26221 public boolean isSet(_Fields field) {
26222 switch (field) {
26223 case TABLE_NAME:
26224 return isSetTableName();
26225 case START_AND_PREFIX:
26226 return isSetStartAndPrefix();
26227 case COLUMNS:
26228 return isSetColumns();
26229 }
26230 throw new IllegalStateException();
26231 }
26232
26233 public boolean isSet(int fieldID) {
26234 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26235 }
26236
26237 @Override
26238 public boolean equals(Object that) {
26239 if (that == null)
26240 return false;
26241 if (that instanceof scannerOpenWithPrefix_args)
26242 return this.equals((scannerOpenWithPrefix_args)that);
26243 return false;
26244 }
26245
26246 public boolean equals(scannerOpenWithPrefix_args that) {
26247 if (that == null)
26248 return false;
26249
26250 boolean this_present_tableName = true && this.isSetTableName();
26251 boolean that_present_tableName = true && that.isSetTableName();
26252 if (this_present_tableName || that_present_tableName) {
26253 if (!(this_present_tableName && that_present_tableName))
26254 return false;
26255 if (!java.util.Arrays.equals(this.tableName, that.tableName))
26256 return false;
26257 }
26258
26259 boolean this_present_startAndPrefix = true && this.isSetStartAndPrefix();
26260 boolean that_present_startAndPrefix = true && that.isSetStartAndPrefix();
26261 if (this_present_startAndPrefix || that_present_startAndPrefix) {
26262 if (!(this_present_startAndPrefix && that_present_startAndPrefix))
26263 return false;
26264 if (!java.util.Arrays.equals(this.startAndPrefix, that.startAndPrefix))
26265 return false;
26266 }
26267
26268 boolean this_present_columns = true && this.isSetColumns();
26269 boolean that_present_columns = true && that.isSetColumns();
26270 if (this_present_columns || that_present_columns) {
26271 if (!(this_present_columns && that_present_columns))
26272 return false;
26273 if (!this.columns.equals(that.columns))
26274 return false;
26275 }
26276
26277 return true;
26278 }
26279
26280 @Override
26281 public int hashCode() {
26282 HashCodeBuilder builder = new HashCodeBuilder();
26283
26284 boolean present_tableName = true && (isSetTableName());
26285 builder.append(present_tableName);
26286 if (present_tableName)
26287 builder.append(tableName);
26288
26289 boolean present_startAndPrefix = true && (isSetStartAndPrefix());
26290 builder.append(present_startAndPrefix);
26291 if (present_startAndPrefix)
26292 builder.append(startAndPrefix);
26293
26294 boolean present_columns = true && (isSetColumns());
26295 builder.append(present_columns);
26296 if (present_columns)
26297 builder.append(columns);
26298
26299 return builder.toHashCode();
26300 }
26301
26302 public int compareTo(scannerOpenWithPrefix_args other) {
26303 if (!getClass().equals(other.getClass())) {
26304 return getClass().getName().compareTo(other.getClass().getName());
26305 }
26306
26307 int lastComparison = 0;
26308 scannerOpenWithPrefix_args typedOther = (scannerOpenWithPrefix_args)other;
26309
26310 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
26311 if (lastComparison != 0) {
26312 return lastComparison;
26313 }
26314 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
26315 if (lastComparison != 0) {
26316 return lastComparison;
26317 }
26318 lastComparison = Boolean.valueOf(isSetStartAndPrefix()).compareTo(isSetStartAndPrefix());
26319 if (lastComparison != 0) {
26320 return lastComparison;
26321 }
26322 lastComparison = TBaseHelper.compareTo(startAndPrefix, typedOther.startAndPrefix);
26323 if (lastComparison != 0) {
26324 return lastComparison;
26325 }
26326 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
26327 if (lastComparison != 0) {
26328 return lastComparison;
26329 }
26330 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
26331 if (lastComparison != 0) {
26332 return lastComparison;
26333 }
26334 return 0;
26335 }
26336
26337 public void read(TProtocol iprot) throws TException {
26338 TField field;
26339 iprot.readStructBegin();
26340 while (true)
26341 {
26342 field = iprot.readFieldBegin();
26343 if (field.type == TType.STOP) {
26344 break;
26345 }
26346 _Fields fieldId = _Fields.findByThriftId(field.id);
26347 if (fieldId == null) {
26348 TProtocolUtil.skip(iprot, field.type);
26349 } else {
26350 switch (fieldId) {
26351 case TABLE_NAME:
26352 if (field.type == TType.STRING) {
26353 this.tableName = iprot.readBinary();
26354 } else {
26355 TProtocolUtil.skip(iprot, field.type);
26356 }
26357 break;
26358 case START_AND_PREFIX:
26359 if (field.type == TType.STRING) {
26360 this.startAndPrefix = iprot.readBinary();
26361 } else {
26362 TProtocolUtil.skip(iprot, field.type);
26363 }
26364 break;
26365 case COLUMNS:
26366 if (field.type == TType.LIST) {
26367 {
26368 TList _list86 = iprot.readListBegin();
26369 this.columns = new ArrayList<byte[]>(_list86.size);
26370 for (int _i87 = 0; _i87 < _list86.size; ++_i87)
26371 {
26372 byte[] _elem88;
26373 _elem88 = iprot.readBinary();
26374 this.columns.add(_elem88);
26375 }
26376 iprot.readListEnd();
26377 }
26378 } else {
26379 TProtocolUtil.skip(iprot, field.type);
26380 }
26381 break;
26382 }
26383 iprot.readFieldEnd();
26384 }
26385 }
26386 iprot.readStructEnd();
26387
26388
26389 validate();
26390 }
26391
26392 public void write(TProtocol oprot) throws TException {
26393 validate();
26394
26395 oprot.writeStructBegin(STRUCT_DESC);
26396 if (this.tableName != null) {
26397 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
26398 oprot.writeBinary(this.tableName);
26399 oprot.writeFieldEnd();
26400 }
26401 if (this.startAndPrefix != null) {
26402 oprot.writeFieldBegin(START_AND_PREFIX_FIELD_DESC);
26403 oprot.writeBinary(this.startAndPrefix);
26404 oprot.writeFieldEnd();
26405 }
26406 if (this.columns != null) {
26407 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
26408 {
26409 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
26410 for (byte[] _iter89 : this.columns)
26411 {
26412 oprot.writeBinary(_iter89);
26413 }
26414 oprot.writeListEnd();
26415 }
26416 oprot.writeFieldEnd();
26417 }
26418 oprot.writeFieldStop();
26419 oprot.writeStructEnd();
26420 }
26421
26422 @Override
26423 public String toString() {
26424 StringBuilder sb = new StringBuilder("scannerOpenWithPrefix_args(");
26425 boolean first = true;
26426
26427 sb.append("tableName:");
26428 if (this.tableName == null) {
26429 sb.append("null");
26430 } else {
26431 sb.append(this.tableName);
26432 }
26433 first = false;
26434 if (!first) sb.append(", ");
26435 sb.append("startAndPrefix:");
26436 if (this.startAndPrefix == null) {
26437 sb.append("null");
26438 } else {
26439 sb.append(this.startAndPrefix);
26440 }
26441 first = false;
26442 if (!first) sb.append(", ");
26443 sb.append("columns:");
26444 if (this.columns == null) {
26445 sb.append("null");
26446 } else {
26447 sb.append(this.columns);
26448 }
26449 first = false;
26450 sb.append(")");
26451 return sb.toString();
26452 }
26453
26454 public void validate() throws TException {
26455
26456 }
26457
26458 }
26459
26460 public static class scannerOpenWithPrefix_result implements TBase<scannerOpenWithPrefix_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_result> {
26461 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_result");
26462
26463 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
26464 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
26465
26466 public int success;
26467 public IOError io;
26468
26469
26470 public enum _Fields implements TFieldIdEnum {
26471 SUCCESS((short)0, "success"),
26472 IO((short)1, "io");
26473
26474 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26475 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26476
26477 static {
26478 for (_Fields field : EnumSet.allOf(_Fields.class)) {
26479 byId.put((int)field._thriftId, field);
26480 byName.put(field.getFieldName(), field);
26481 }
26482 }
26483
26484
26485
26486
26487 public static _Fields findByThriftId(int fieldId) {
26488 return byId.get(fieldId);
26489 }
26490
26491
26492
26493
26494
26495 public static _Fields findByThriftIdOrThrow(int fieldId) {
26496 _Fields fields = findByThriftId(fieldId);
26497 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
26498 return fields;
26499 }
26500
26501
26502
26503
26504 public static _Fields findByName(String name) {
26505 return byName.get(name);
26506 }
26507
26508 private final short _thriftId;
26509 private final String _fieldName;
26510
26511 _Fields(short thriftId, String fieldName) {
26512 _thriftId = thriftId;
26513 _fieldName = fieldName;
26514 }
26515
26516 public short getThriftFieldId() {
26517 return _thriftId;
26518 }
26519
26520 public String getFieldName() {
26521 return _fieldName;
26522 }
26523 }
26524
26525
26526 private static final int __SUCCESS_ISSET_ID = 0;
26527 private BitSet __isset_bit_vector = new BitSet(1);
26528
26529 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26530 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
26531 new FieldValueMetaData(TType.I32)));
26532 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
26533 new FieldValueMetaData(TType.STRUCT)));
26534 }});
26535
26536 static {
26537 FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_result.class, metaDataMap);
26538 }
26539
26540 public scannerOpenWithPrefix_result() {
26541 }
26542
26543 public scannerOpenWithPrefix_result(
26544 int success,
26545 IOError io)
26546 {
26547 this();
26548 this.success = success;
26549 setSuccessIsSet(true);
26550 this.io = io;
26551 }
26552
26553
26554
26555
26556 public scannerOpenWithPrefix_result(scannerOpenWithPrefix_result other) {
26557 __isset_bit_vector.clear();
26558 __isset_bit_vector.or(other.__isset_bit_vector);
26559 this.success = other.success;
26560 if (other.isSetIo()) {
26561 this.io = new IOError(other.io);
26562 }
26563 }
26564
26565 public scannerOpenWithPrefix_result deepCopy() {
26566 return new scannerOpenWithPrefix_result(this);
26567 }
26568
26569 @Deprecated
26570 public scannerOpenWithPrefix_result clone() {
26571 return new scannerOpenWithPrefix_result(this);
26572 }
26573
26574 public int getSuccess() {
26575 return this.success;
26576 }
26577
26578 public scannerOpenWithPrefix_result setSuccess(int success) {
26579 this.success = success;
26580 setSuccessIsSet(true);
26581 return this;
26582 }
26583
26584 public void unsetSuccess() {
26585 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
26586 }
26587
26588
26589 public boolean isSetSuccess() {
26590 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
26591 }
26592
26593 public void setSuccessIsSet(boolean value) {
26594 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
26595 }
26596
26597 public IOError getIo() {
26598 return this.io;
26599 }
26600
26601 public scannerOpenWithPrefix_result setIo(IOError io) {
26602 this.io = io;
26603 return this;
26604 }
26605
26606 public void unsetIo() {
26607 this.io = null;
26608 }
26609
26610
26611 public boolean isSetIo() {
26612 return this.io != null;
26613 }
26614
26615 public void setIoIsSet(boolean value) {
26616 if (!value) {
26617 this.io = null;
26618 }
26619 }
26620
26621 public void setFieldValue(_Fields field, Object value) {
26622 switch (field) {
26623 case SUCCESS:
26624 if (value == null) {
26625 unsetSuccess();
26626 } else {
26627 setSuccess((Integer)value);
26628 }
26629 break;
26630
26631 case IO:
26632 if (value == null) {
26633 unsetIo();
26634 } else {
26635 setIo((IOError)value);
26636 }
26637 break;
26638
26639 }
26640 }
26641
26642 public void setFieldValue(int fieldID, Object value) {
26643 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26644 }
26645
26646 public Object getFieldValue(_Fields field) {
26647 switch (field) {
26648 case SUCCESS:
26649 return new Integer(getSuccess());
26650
26651 case IO:
26652 return getIo();
26653
26654 }
26655 throw new IllegalStateException();
26656 }
26657
26658 public Object getFieldValue(int fieldId) {
26659 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26660 }
26661
26662
26663 public boolean isSet(_Fields field) {
26664 switch (field) {
26665 case SUCCESS:
26666 return isSetSuccess();
26667 case IO:
26668 return isSetIo();
26669 }
26670 throw new IllegalStateException();
26671 }
26672
26673 public boolean isSet(int fieldID) {
26674 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26675 }
26676
26677 @Override
26678 public boolean equals(Object that) {
26679 if (that == null)
26680 return false;
26681 if (that instanceof scannerOpenWithPrefix_result)
26682 return this.equals((scannerOpenWithPrefix_result)that);
26683 return false;
26684 }
26685
26686 public boolean equals(scannerOpenWithPrefix_result that) {
26687 if (that == null)
26688 return false;
26689
26690 boolean this_present_success = true;
26691 boolean that_present_success = true;
26692 if (this_present_success || that_present_success) {
26693 if (!(this_present_success && that_present_success))
26694 return false;
26695 if (this.success != that.success)
26696 return false;
26697 }
26698
26699 boolean this_present_io = true && this.isSetIo();
26700 boolean that_present_io = true && that.isSetIo();
26701 if (this_present_io || that_present_io) {
26702 if (!(this_present_io && that_present_io))
26703 return false;
26704 if (!this.io.equals(that.io))
26705 return false;
26706 }
26707
26708 return true;
26709 }
26710
26711 @Override
26712 public int hashCode() {
26713 HashCodeBuilder builder = new HashCodeBuilder();
26714
26715 boolean present_success = true;
26716 builder.append(present_success);
26717 if (present_success)
26718 builder.append(success);
26719
26720 boolean present_io = true && (isSetIo());
26721 builder.append(present_io);
26722 if (present_io)
26723 builder.append(io);
26724
26725 return builder.toHashCode();
26726 }
26727
26728 public int compareTo(scannerOpenWithPrefix_result other) {
26729 if (!getClass().equals(other.getClass())) {
26730 return getClass().getName().compareTo(other.getClass().getName());
26731 }
26732
26733 int lastComparison = 0;
26734 scannerOpenWithPrefix_result typedOther = (scannerOpenWithPrefix_result)other;
26735
26736 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
26737 if (lastComparison != 0) {
26738 return lastComparison;
26739 }
26740 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
26741 if (lastComparison != 0) {
26742 return lastComparison;
26743 }
26744 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
26745 if (lastComparison != 0) {
26746 return lastComparison;
26747 }
26748 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
26749 if (lastComparison != 0) {
26750 return lastComparison;
26751 }
26752 return 0;
26753 }
26754
26755 public void read(TProtocol iprot) throws TException {
26756 TField field;
26757 iprot.readStructBegin();
26758 while (true)
26759 {
26760 field = iprot.readFieldBegin();
26761 if (field.type == TType.STOP) {
26762 break;
26763 }
26764 _Fields fieldId = _Fields.findByThriftId(field.id);
26765 if (fieldId == null) {
26766 TProtocolUtil.skip(iprot, field.type);
26767 } else {
26768 switch (fieldId) {
26769 case SUCCESS:
26770 if (field.type == TType.I32) {
26771 this.success = iprot.readI32();
26772 setSuccessIsSet(true);
26773 } else {
26774 TProtocolUtil.skip(iprot, field.type);
26775 }
26776 break;
26777 case IO:
26778 if (field.type == TType.STRUCT) {
26779 this.io = new IOError();
26780 this.io.read(iprot);
26781 } else {
26782 TProtocolUtil.skip(iprot, field.type);
26783 }
26784 break;
26785 }
26786 iprot.readFieldEnd();
26787 }
26788 }
26789 iprot.readStructEnd();
26790
26791
26792 validate();
26793 }
26794
26795 public void write(TProtocol oprot) throws TException {
26796 oprot.writeStructBegin(STRUCT_DESC);
26797
26798 if (this.isSetSuccess()) {
26799 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
26800 oprot.writeI32(this.success);
26801 oprot.writeFieldEnd();
26802 } else if (this.isSetIo()) {
26803 oprot.writeFieldBegin(IO_FIELD_DESC);
26804 this.io.write(oprot);
26805 oprot.writeFieldEnd();
26806 }
26807 oprot.writeFieldStop();
26808 oprot.writeStructEnd();
26809 }
26810
26811 @Override
26812 public String toString() {
26813 StringBuilder sb = new StringBuilder("scannerOpenWithPrefix_result(");
26814 boolean first = true;
26815
26816 sb.append("success:");
26817 sb.append(this.success);
26818 first = false;
26819 if (!first) sb.append(", ");
26820 sb.append("io:");
26821 if (this.io == null) {
26822 sb.append("null");
26823 } else {
26824 sb.append(this.io);
26825 }
26826 first = false;
26827 sb.append(")");
26828 return sb.toString();
26829 }
26830
26831 public void validate() throws TException {
26832
26833 }
26834
26835 }
26836
26837 public static class scannerOpenTs_args implements TBase<scannerOpenTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_args> {
26838 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_args");
26839
26840 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
26841 private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
26842 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
26843 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
26844
26845
26846
26847
26848 public byte[] tableName;
26849
26850
26851
26852
26853 public byte[] startRow;
26854
26855
26856
26857
26858
26859 public List<byte[]> columns;
26860
26861
26862
26863 public long timestamp;
26864
26865
26866 public enum _Fields implements TFieldIdEnum {
26867
26868
26869
26870 TABLE_NAME((short)1, "tableName"),
26871
26872
26873
26874
26875 START_ROW((short)2, "startRow"),
26876
26877
26878
26879
26880
26881 COLUMNS((short)3, "columns"),
26882
26883
26884
26885 TIMESTAMP((short)4, "timestamp");
26886
26887 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26888 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26889
26890 static {
26891 for (_Fields field : EnumSet.allOf(_Fields.class)) {
26892 byId.put((int)field._thriftId, field);
26893 byName.put(field.getFieldName(), field);
26894 }
26895 }
26896
26897
26898
26899
26900 public static _Fields findByThriftId(int fieldId) {
26901 return byId.get(fieldId);
26902 }
26903
26904
26905
26906
26907
26908 public static _Fields findByThriftIdOrThrow(int fieldId) {
26909 _Fields fields = findByThriftId(fieldId);
26910 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
26911 return fields;
26912 }
26913
26914
26915
26916
26917 public static _Fields findByName(String name) {
26918 return byName.get(name);
26919 }
26920
26921 private final short _thriftId;
26922 private final String _fieldName;
26923
26924 _Fields(short thriftId, String fieldName) {
26925 _thriftId = thriftId;
26926 _fieldName = fieldName;
26927 }
26928
26929 public short getThriftFieldId() {
26930 return _thriftId;
26931 }
26932
26933 public String getFieldName() {
26934 return _fieldName;
26935 }
26936 }
26937
26938
26939 private static final int __TIMESTAMP_ISSET_ID = 0;
26940 private BitSet __isset_bit_vector = new BitSet(1);
26941
26942 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26943 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
26944 new FieldValueMetaData(TType.STRING)));
26945 put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
26946 new FieldValueMetaData(TType.STRING)));
26947 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
26948 new ListMetaData(TType.LIST,
26949 new FieldValueMetaData(TType.STRING))));
26950 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
26951 new FieldValueMetaData(TType.I64)));
26952 }});
26953
26954 static {
26955 FieldMetaData.addStructMetaDataMap(scannerOpenTs_args.class, metaDataMap);
26956 }
26957
26958 public scannerOpenTs_args() {
26959 }
26960
26961 public scannerOpenTs_args(
26962 byte[] tableName,
26963 byte[] startRow,
26964 List<byte[]> columns,
26965 long timestamp)
26966 {
26967 this();
26968 this.tableName = tableName;
26969 this.startRow = startRow;
26970 this.columns = columns;
26971 this.timestamp = timestamp;
26972 setTimestampIsSet(true);
26973 }
26974
26975
26976
26977
26978 public scannerOpenTs_args(scannerOpenTs_args other) {
26979 __isset_bit_vector.clear();
26980 __isset_bit_vector.or(other.__isset_bit_vector);
26981 if (other.isSetTableName()) {
26982 this.tableName = other.tableName;
26983 }
26984 if (other.isSetStartRow()) {
26985 this.startRow = other.startRow;
26986 }
26987 if (other.isSetColumns()) {
26988 List<byte[]> __this__columns = new ArrayList<byte[]>();
26989 for (byte[] other_element : other.columns) {
26990 __this__columns.add(other_element);
26991 }
26992 this.columns = __this__columns;
26993 }
26994 this.timestamp = other.timestamp;
26995 }
26996
26997 public scannerOpenTs_args deepCopy() {
26998 return new scannerOpenTs_args(this);
26999 }
27000
27001 @Deprecated
27002 public scannerOpenTs_args clone() {
27003 return new scannerOpenTs_args(this);
27004 }
27005
27006
27007
27008
27009 public byte[] getTableName() {
27010 return this.tableName;
27011 }
27012
27013
27014
27015
27016 public scannerOpenTs_args setTableName(byte[] tableName) {
27017 this.tableName = tableName;
27018 return this;
27019 }
27020
27021 public void unsetTableName() {
27022 this.tableName = null;
27023 }
27024
27025
27026 public boolean isSetTableName() {
27027 return this.tableName != null;
27028 }
27029
27030 public void setTableNameIsSet(boolean value) {
27031 if (!value) {
27032 this.tableName = null;
27033 }
27034 }
27035
27036
27037
27038
27039
27040 public byte[] getStartRow() {
27041 return this.startRow;
27042 }
27043
27044
27045
27046
27047
27048 public scannerOpenTs_args setStartRow(byte[] startRow) {
27049 this.startRow = startRow;
27050 return this;
27051 }
27052
27053 public void unsetStartRow() {
27054 this.startRow = null;
27055 }
27056
27057
27058 public boolean isSetStartRow() {
27059 return this.startRow != null;
27060 }
27061
27062 public void setStartRowIsSet(boolean value) {
27063 if (!value) {
27064 this.startRow = null;
27065 }
27066 }
27067
27068 public int getColumnsSize() {
27069 return (this.columns == null) ? 0 : this.columns.size();
27070 }
27071
27072 public java.util.Iterator<byte[]> getColumnsIterator() {
27073 return (this.columns == null) ? null : this.columns.iterator();
27074 }
27075
27076 public void addToColumns(byte[] elem) {
27077 if (this.columns == null) {
27078 this.columns = new ArrayList<byte[]>();
27079 }
27080 this.columns.add(elem);
27081 }
27082
27083
27084
27085
27086
27087
27088 public List<byte[]> getColumns() {
27089 return this.columns;
27090 }
27091
27092
27093
27094
27095
27096
27097 public scannerOpenTs_args setColumns(List<byte[]> columns) {
27098 this.columns = columns;
27099 return this;
27100 }
27101
27102 public void unsetColumns() {
27103 this.columns = null;
27104 }
27105
27106
27107 public boolean isSetColumns() {
27108 return this.columns != null;
27109 }
27110
27111 public void setColumnsIsSet(boolean value) {
27112 if (!value) {
27113 this.columns = null;
27114 }
27115 }
27116
27117
27118
27119
27120 public long getTimestamp() {
27121 return this.timestamp;
27122 }
27123
27124
27125
27126
27127 public scannerOpenTs_args setTimestamp(long timestamp) {
27128 this.timestamp = timestamp;
27129 setTimestampIsSet(true);
27130 return this;
27131 }
27132
27133 public void unsetTimestamp() {
27134 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
27135 }
27136
27137
27138 public boolean isSetTimestamp() {
27139 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
27140 }
27141
27142 public void setTimestampIsSet(boolean value) {
27143 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
27144 }
27145
27146 public void setFieldValue(_Fields field, Object value) {
27147 switch (field) {
27148 case TABLE_NAME:
27149 if (value == null) {
27150 unsetTableName();
27151 } else {
27152 setTableName((byte[])value);
27153 }
27154 break;
27155
27156 case START_ROW:
27157 if (value == null) {
27158 unsetStartRow();
27159 } else {
27160 setStartRow((byte[])value);
27161 }
27162 break;
27163
27164 case COLUMNS:
27165 if (value == null) {
27166 unsetColumns();
27167 } else {
27168 setColumns((List<byte[]>)value);
27169 }
27170 break;
27171
27172 case TIMESTAMP:
27173 if (value == null) {
27174 unsetTimestamp();
27175 } else {
27176 setTimestamp((Long)value);
27177 }
27178 break;
27179
27180 }
27181 }
27182
27183 public void setFieldValue(int fieldID, Object value) {
27184 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27185 }
27186
27187 public Object getFieldValue(_Fields field) {
27188 switch (field) {
27189 case TABLE_NAME:
27190 return getTableName();
27191
27192 case START_ROW:
27193 return getStartRow();
27194
27195 case COLUMNS:
27196 return getColumns();
27197
27198 case TIMESTAMP:
27199 return new Long(getTimestamp());
27200
27201 }
27202 throw new IllegalStateException();
27203 }
27204
27205 public Object getFieldValue(int fieldId) {
27206 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27207 }
27208
27209
27210 public boolean isSet(_Fields field) {
27211 switch (field) {
27212 case TABLE_NAME:
27213 return isSetTableName();
27214 case START_ROW:
27215 return isSetStartRow();
27216 case COLUMNS:
27217 return isSetColumns();
27218 case TIMESTAMP:
27219 return isSetTimestamp();
27220 }
27221 throw new IllegalStateException();
27222 }
27223
27224 public boolean isSet(int fieldID) {
27225 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27226 }
27227
27228 @Override
27229 public boolean equals(Object that) {
27230 if (that == null)
27231 return false;
27232 if (that instanceof scannerOpenTs_args)
27233 return this.equals((scannerOpenTs_args)that);
27234 return false;
27235 }
27236
27237 public boolean equals(scannerOpenTs_args that) {
27238 if (that == null)
27239 return false;
27240
27241 boolean this_present_tableName = true && this.isSetTableName();
27242 boolean that_present_tableName = true && that.isSetTableName();
27243 if (this_present_tableName || that_present_tableName) {
27244 if (!(this_present_tableName && that_present_tableName))
27245 return false;
27246 if (!java.util.Arrays.equals(this.tableName, that.tableName))
27247 return false;
27248 }
27249
27250 boolean this_present_startRow = true && this.isSetStartRow();
27251 boolean that_present_startRow = true && that.isSetStartRow();
27252 if (this_present_startRow || that_present_startRow) {
27253 if (!(this_present_startRow && that_present_startRow))
27254 return false;
27255 if (!java.util.Arrays.equals(this.startRow, that.startRow))
27256 return false;
27257 }
27258
27259 boolean this_present_columns = true && this.isSetColumns();
27260 boolean that_present_columns = true && that.isSetColumns();
27261 if (this_present_columns || that_present_columns) {
27262 if (!(this_present_columns && that_present_columns))
27263 return false;
27264 if (!this.columns.equals(that.columns))
27265 return false;
27266 }
27267
27268 boolean this_present_timestamp = true;
27269 boolean that_present_timestamp = true;
27270 if (this_present_timestamp || that_present_timestamp) {
27271 if (!(this_present_timestamp && that_present_timestamp))
27272 return false;
27273 if (this.timestamp != that.timestamp)
27274 return false;
27275 }
27276
27277 return true;
27278 }
27279
27280 @Override
27281 public int hashCode() {
27282 HashCodeBuilder builder = new HashCodeBuilder();
27283
27284 boolean present_tableName = true && (isSetTableName());
27285 builder.append(present_tableName);
27286 if (present_tableName)
27287 builder.append(tableName);
27288
27289 boolean present_startRow = true && (isSetStartRow());
27290 builder.append(present_startRow);
27291 if (present_startRow)
27292 builder.append(startRow);
27293
27294 boolean present_columns = true && (isSetColumns());
27295 builder.append(present_columns);
27296 if (present_columns)
27297 builder.append(columns);
27298
27299 boolean present_timestamp = true;
27300 builder.append(present_timestamp);
27301 if (present_timestamp)
27302 builder.append(timestamp);
27303
27304 return builder.toHashCode();
27305 }
27306
27307 public int compareTo(scannerOpenTs_args other) {
27308 if (!getClass().equals(other.getClass())) {
27309 return getClass().getName().compareTo(other.getClass().getName());
27310 }
27311
27312 int lastComparison = 0;
27313 scannerOpenTs_args typedOther = (scannerOpenTs_args)other;
27314
27315 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
27316 if (lastComparison != 0) {
27317 return lastComparison;
27318 }
27319 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
27320 if (lastComparison != 0) {
27321 return lastComparison;
27322 }
27323 lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
27324 if (lastComparison != 0) {
27325 return lastComparison;
27326 }
27327 lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
27328 if (lastComparison != 0) {
27329 return lastComparison;
27330 }
27331 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
27332 if (lastComparison != 0) {
27333 return lastComparison;
27334 }
27335 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
27336 if (lastComparison != 0) {
27337 return lastComparison;
27338 }
27339 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
27340 if (lastComparison != 0) {
27341 return lastComparison;
27342 }
27343 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
27344 if (lastComparison != 0) {
27345 return lastComparison;
27346 }
27347 return 0;
27348 }
27349
27350 public void read(TProtocol iprot) throws TException {
27351 TField field;
27352 iprot.readStructBegin();
27353 while (true)
27354 {
27355 field = iprot.readFieldBegin();
27356 if (field.type == TType.STOP) {
27357 break;
27358 }
27359 _Fields fieldId = _Fields.findByThriftId(field.id);
27360 if (fieldId == null) {
27361 TProtocolUtil.skip(iprot, field.type);
27362 } else {
27363 switch (fieldId) {
27364 case TABLE_NAME:
27365 if (field.type == TType.STRING) {
27366 this.tableName = iprot.readBinary();
27367 } else {
27368 TProtocolUtil.skip(iprot, field.type);
27369 }
27370 break;
27371 case START_ROW:
27372 if (field.type == TType.STRING) {
27373 this.startRow = iprot.readBinary();
27374 } else {
27375 TProtocolUtil.skip(iprot, field.type);
27376 }
27377 break;
27378 case COLUMNS:
27379 if (field.type == TType.LIST) {
27380 {
27381 TList _list90 = iprot.readListBegin();
27382 this.columns = new ArrayList<byte[]>(_list90.size);
27383 for (int _i91 = 0; _i91 < _list90.size; ++_i91)
27384 {
27385 byte[] _elem92;
27386 _elem92 = iprot.readBinary();
27387 this.columns.add(_elem92);
27388 }
27389 iprot.readListEnd();
27390 }
27391 } else {
27392 TProtocolUtil.skip(iprot, field.type);
27393 }
27394 break;
27395 case TIMESTAMP:
27396 if (field.type == TType.I64) {
27397 this.timestamp = iprot.readI64();
27398 setTimestampIsSet(true);
27399 } else {
27400 TProtocolUtil.skip(iprot, field.type);
27401 }
27402 break;
27403 }
27404 iprot.readFieldEnd();
27405 }
27406 }
27407 iprot.readStructEnd();
27408
27409
27410 validate();
27411 }
27412
27413 public void write(TProtocol oprot) throws TException {
27414 validate();
27415
27416 oprot.writeStructBegin(STRUCT_DESC);
27417 if (this.tableName != null) {
27418 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
27419 oprot.writeBinary(this.tableName);
27420 oprot.writeFieldEnd();
27421 }
27422 if (this.startRow != null) {
27423 oprot.writeFieldBegin(START_ROW_FIELD_DESC);
27424 oprot.writeBinary(this.startRow);
27425 oprot.writeFieldEnd();
27426 }
27427 if (this.columns != null) {
27428 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
27429 {
27430 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
27431 for (byte[] _iter93 : this.columns)
27432 {
27433 oprot.writeBinary(_iter93);
27434 }
27435 oprot.writeListEnd();
27436 }
27437 oprot.writeFieldEnd();
27438 }
27439 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
27440 oprot.writeI64(this.timestamp);
27441 oprot.writeFieldEnd();
27442 oprot.writeFieldStop();
27443 oprot.writeStructEnd();
27444 }
27445
27446 @Override
27447 public String toString() {
27448 StringBuilder sb = new StringBuilder("scannerOpenTs_args(");
27449 boolean first = true;
27450
27451 sb.append("tableName:");
27452 if (this.tableName == null) {
27453 sb.append("null");
27454 } else {
27455 sb.append(this.tableName);
27456 }
27457 first = false;
27458 if (!first) sb.append(", ");
27459 sb.append("startRow:");
27460 if (this.startRow == null) {
27461 sb.append("null");
27462 } else {
27463 sb.append(this.startRow);
27464 }
27465 first = false;
27466 if (!first) sb.append(", ");
27467 sb.append("columns:");
27468 if (this.columns == null) {
27469 sb.append("null");
27470 } else {
27471 sb.append(this.columns);
27472 }
27473 first = false;
27474 if (!first) sb.append(", ");
27475 sb.append("timestamp:");
27476 sb.append(this.timestamp);
27477 first = false;
27478 sb.append(")");
27479 return sb.toString();
27480 }
27481
27482 public void validate() throws TException {
27483
27484 }
27485
27486 }
27487
27488 public static class scannerOpenTs_result implements TBase<scannerOpenTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_result> {
27489 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_result");
27490
27491 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
27492 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
27493
27494 public int success;
27495 public IOError io;
27496
27497
27498 public enum _Fields implements TFieldIdEnum {
27499 SUCCESS((short)0, "success"),
27500 IO((short)1, "io");
27501
27502 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
27503 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
27504
27505 static {
27506 for (_Fields field : EnumSet.allOf(_Fields.class)) {
27507 byId.put((int)field._thriftId, field);
27508 byName.put(field.getFieldName(), field);
27509 }
27510 }
27511
27512
27513
27514
27515 public static _Fields findByThriftId(int fieldId) {
27516 return byId.get(fieldId);
27517 }
27518
27519
27520
27521
27522
27523 public static _Fields findByThriftIdOrThrow(int fieldId) {
27524 _Fields fields = findByThriftId(fieldId);
27525 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27526 return fields;
27527 }
27528
27529
27530
27531
27532 public static _Fields findByName(String name) {
27533 return byName.get(name);
27534 }
27535
27536 private final short _thriftId;
27537 private final String _fieldName;
27538
27539 _Fields(short thriftId, String fieldName) {
27540 _thriftId = thriftId;
27541 _fieldName = fieldName;
27542 }
27543
27544 public short getThriftFieldId() {
27545 return _thriftId;
27546 }
27547
27548 public String getFieldName() {
27549 return _fieldName;
27550 }
27551 }
27552
27553
27554 private static final int __SUCCESS_ISSET_ID = 0;
27555 private BitSet __isset_bit_vector = new BitSet(1);
27556
27557 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27558 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
27559 new FieldValueMetaData(TType.I32)));
27560 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
27561 new FieldValueMetaData(TType.STRUCT)));
27562 }});
27563
27564 static {
27565 FieldMetaData.addStructMetaDataMap(scannerOpenTs_result.class, metaDataMap);
27566 }
27567
27568 public scannerOpenTs_result() {
27569 }
27570
27571 public scannerOpenTs_result(
27572 int success,
27573 IOError io)
27574 {
27575 this();
27576 this.success = success;
27577 setSuccessIsSet(true);
27578 this.io = io;
27579 }
27580
27581
27582
27583
27584 public scannerOpenTs_result(scannerOpenTs_result other) {
27585 __isset_bit_vector.clear();
27586 __isset_bit_vector.or(other.__isset_bit_vector);
27587 this.success = other.success;
27588 if (other.isSetIo()) {
27589 this.io = new IOError(other.io);
27590 }
27591 }
27592
27593 public scannerOpenTs_result deepCopy() {
27594 return new scannerOpenTs_result(this);
27595 }
27596
27597 @Deprecated
27598 public scannerOpenTs_result clone() {
27599 return new scannerOpenTs_result(this);
27600 }
27601
27602 public int getSuccess() {
27603 return this.success;
27604 }
27605
27606 public scannerOpenTs_result setSuccess(int success) {
27607 this.success = success;
27608 setSuccessIsSet(true);
27609 return this;
27610 }
27611
27612 public void unsetSuccess() {
27613 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
27614 }
27615
27616
27617 public boolean isSetSuccess() {
27618 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
27619 }
27620
27621 public void setSuccessIsSet(boolean value) {
27622 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
27623 }
27624
27625 public IOError getIo() {
27626 return this.io;
27627 }
27628
27629 public scannerOpenTs_result setIo(IOError io) {
27630 this.io = io;
27631 return this;
27632 }
27633
27634 public void unsetIo() {
27635 this.io = null;
27636 }
27637
27638
27639 public boolean isSetIo() {
27640 return this.io != null;
27641 }
27642
27643 public void setIoIsSet(boolean value) {
27644 if (!value) {
27645 this.io = null;
27646 }
27647 }
27648
27649 public void setFieldValue(_Fields field, Object value) {
27650 switch (field) {
27651 case SUCCESS:
27652 if (value == null) {
27653 unsetSuccess();
27654 } else {
27655 setSuccess((Integer)value);
27656 }
27657 break;
27658
27659 case IO:
27660 if (value == null) {
27661 unsetIo();
27662 } else {
27663 setIo((IOError)value);
27664 }
27665 break;
27666
27667 }
27668 }
27669
27670 public void setFieldValue(int fieldID, Object value) {
27671 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27672 }
27673
27674 public Object getFieldValue(_Fields field) {
27675 switch (field) {
27676 case SUCCESS:
27677 return new Integer(getSuccess());
27678
27679 case IO:
27680 return getIo();
27681
27682 }
27683 throw new IllegalStateException();
27684 }
27685
27686 public Object getFieldValue(int fieldId) {
27687 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27688 }
27689
27690
27691 public boolean isSet(_Fields field) {
27692 switch (field) {
27693 case SUCCESS:
27694 return isSetSuccess();
27695 case IO:
27696 return isSetIo();
27697 }
27698 throw new IllegalStateException();
27699 }
27700
27701 public boolean isSet(int fieldID) {
27702 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27703 }
27704
27705 @Override
27706 public boolean equals(Object that) {
27707 if (that == null)
27708 return false;
27709 if (that instanceof scannerOpenTs_result)
27710 return this.equals((scannerOpenTs_result)that);
27711 return false;
27712 }
27713
27714 public boolean equals(scannerOpenTs_result that) {
27715 if (that == null)
27716 return false;
27717
27718 boolean this_present_success = true;
27719 boolean that_present_success = true;
27720 if (this_present_success || that_present_success) {
27721 if (!(this_present_success && that_present_success))
27722 return false;
27723 if (this.success != that.success)
27724 return false;
27725 }
27726
27727 boolean this_present_io = true && this.isSetIo();
27728 boolean that_present_io = true && that.isSetIo();
27729 if (this_present_io || that_present_io) {
27730 if (!(this_present_io && that_present_io))
27731 return false;
27732 if (!this.io.equals(that.io))
27733 return false;
27734 }
27735
27736 return true;
27737 }
27738
27739 @Override
27740 public int hashCode() {
27741 HashCodeBuilder builder = new HashCodeBuilder();
27742
27743 boolean present_success = true;
27744 builder.append(present_success);
27745 if (present_success)
27746 builder.append(success);
27747
27748 boolean present_io = true && (isSetIo());
27749 builder.append(present_io);
27750 if (present_io)
27751 builder.append(io);
27752
27753 return builder.toHashCode();
27754 }
27755
27756 public int compareTo(scannerOpenTs_result other) {
27757 if (!getClass().equals(other.getClass())) {
27758 return getClass().getName().compareTo(other.getClass().getName());
27759 }
27760
27761 int lastComparison = 0;
27762 scannerOpenTs_result typedOther = (scannerOpenTs_result)other;
27763
27764 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
27765 if (lastComparison != 0) {
27766 return lastComparison;
27767 }
27768 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
27769 if (lastComparison != 0) {
27770 return lastComparison;
27771 }
27772 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
27773 if (lastComparison != 0) {
27774 return lastComparison;
27775 }
27776 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
27777 if (lastComparison != 0) {
27778 return lastComparison;
27779 }
27780 return 0;
27781 }
27782
27783 public void read(TProtocol iprot) throws TException {
27784 TField field;
27785 iprot.readStructBegin();
27786 while (true)
27787 {
27788 field = iprot.readFieldBegin();
27789 if (field.type == TType.STOP) {
27790 break;
27791 }
27792 _Fields fieldId = _Fields.findByThriftId(field.id);
27793 if (fieldId == null) {
27794 TProtocolUtil.skip(iprot, field.type);
27795 } else {
27796 switch (fieldId) {
27797 case SUCCESS:
27798 if (field.type == TType.I32) {
27799 this.success = iprot.readI32();
27800 setSuccessIsSet(true);
27801 } else {
27802 TProtocolUtil.skip(iprot, field.type);
27803 }
27804 break;
27805 case IO:
27806 if (field.type == TType.STRUCT) {
27807 this.io = new IOError();
27808 this.io.read(iprot);
27809 } else {
27810 TProtocolUtil.skip(iprot, field.type);
27811 }
27812 break;
27813 }
27814 iprot.readFieldEnd();
27815 }
27816 }
27817 iprot.readStructEnd();
27818
27819
27820 validate();
27821 }
27822
27823 public void write(TProtocol oprot) throws TException {
27824 oprot.writeStructBegin(STRUCT_DESC);
27825
27826 if (this.isSetSuccess()) {
27827 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27828 oprot.writeI32(this.success);
27829 oprot.writeFieldEnd();
27830 } else if (this.isSetIo()) {
27831 oprot.writeFieldBegin(IO_FIELD_DESC);
27832 this.io.write(oprot);
27833 oprot.writeFieldEnd();
27834 }
27835 oprot.writeFieldStop();
27836 oprot.writeStructEnd();
27837 }
27838
27839 @Override
27840 public String toString() {
27841 StringBuilder sb = new StringBuilder("scannerOpenTs_result(");
27842 boolean first = true;
27843
27844 sb.append("success:");
27845 sb.append(this.success);
27846 first = false;
27847 if (!first) sb.append(", ");
27848 sb.append("io:");
27849 if (this.io == null) {
27850 sb.append("null");
27851 } else {
27852 sb.append(this.io);
27853 }
27854 first = false;
27855 sb.append(")");
27856 return sb.toString();
27857 }
27858
27859 public void validate() throws TException {
27860
27861 }
27862
27863 }
27864
27865 public static class scannerOpenWithStopTs_args implements TBase<scannerOpenWithStopTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_args> {
27866 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_args");
27867
27868 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
27869 private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
27870 private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3);
27871 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4);
27872 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)5);
27873
27874
27875
27876
27877 public byte[] tableName;
27878
27879
27880
27881
27882 public byte[] startRow;
27883
27884
27885
27886
27887 public byte[] stopRow;
27888
27889
27890
27891
27892
27893 public List<byte[]> columns;
27894
27895
27896
27897 public long timestamp;
27898
27899
27900 public enum _Fields implements TFieldIdEnum {
27901
27902
27903
27904 TABLE_NAME((short)1, "tableName"),
27905
27906
27907
27908
27909 START_ROW((short)2, "startRow"),
27910
27911
27912
27913
27914 STOP_ROW((short)3, "stopRow"),
27915
27916
27917
27918
27919
27920 COLUMNS((short)4, "columns"),
27921
27922
27923
27924 TIMESTAMP((short)5, "timestamp");
27925
27926 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
27927 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
27928
27929 static {
27930 for (_Fields field : EnumSet.allOf(_Fields.class)) {
27931 byId.put((int)field._thriftId, field);
27932 byName.put(field.getFieldName(), field);
27933 }
27934 }
27935
27936
27937
27938
27939 public static _Fields findByThriftId(int fieldId) {
27940 return byId.get(fieldId);
27941 }
27942
27943
27944
27945
27946
27947 public static _Fields findByThriftIdOrThrow(int fieldId) {
27948 _Fields fields = findByThriftId(fieldId);
27949 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27950 return fields;
27951 }
27952
27953
27954
27955
27956 public static _Fields findByName(String name) {
27957 return byName.get(name);
27958 }
27959
27960 private final short _thriftId;
27961 private final String _fieldName;
27962
27963 _Fields(short thriftId, String fieldName) {
27964 _thriftId = thriftId;
27965 _fieldName = fieldName;
27966 }
27967
27968 public short getThriftFieldId() {
27969 return _thriftId;
27970 }
27971
27972 public String getFieldName() {
27973 return _fieldName;
27974 }
27975 }
27976
27977
27978 private static final int __TIMESTAMP_ISSET_ID = 0;
27979 private BitSet __isset_bit_vector = new BitSet(1);
27980
27981 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27982 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
27983 new FieldValueMetaData(TType.STRING)));
27984 put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
27985 new FieldValueMetaData(TType.STRING)));
27986 put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT,
27987 new FieldValueMetaData(TType.STRING)));
27988 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
27989 new ListMetaData(TType.LIST,
27990 new FieldValueMetaData(TType.STRING))));
27991 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
27992 new FieldValueMetaData(TType.I64)));
27993 }});
27994
27995 static {
27996 FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_args.class, metaDataMap);
27997 }
27998
27999 public scannerOpenWithStopTs_args() {
28000 }
28001
28002 public scannerOpenWithStopTs_args(
28003 byte[] tableName,
28004 byte[] startRow,
28005 byte[] stopRow,
28006 List<byte[]> columns,
28007 long timestamp)
28008 {
28009 this();
28010 this.tableName = tableName;
28011 this.startRow = startRow;
28012 this.stopRow = stopRow;
28013 this.columns = columns;
28014 this.timestamp = timestamp;
28015 setTimestampIsSet(true);
28016 }
28017
28018
28019
28020
28021 public scannerOpenWithStopTs_args(scannerOpenWithStopTs_args other) {
28022 __isset_bit_vector.clear();
28023 __isset_bit_vector.or(other.__isset_bit_vector);
28024 if (other.isSetTableName()) {
28025 this.tableName = other.tableName;
28026 }
28027 if (other.isSetStartRow()) {
28028 this.startRow = other.startRow;
28029 }
28030 if (other.isSetStopRow()) {
28031 this.stopRow = other.stopRow;
28032 }
28033 if (other.isSetColumns()) {
28034 List<byte[]> __this__columns = new ArrayList<byte[]>();
28035 for (byte[] other_element : other.columns) {
28036 __this__columns.add(other_element);
28037 }
28038 this.columns = __this__columns;
28039 }
28040 this.timestamp = other.timestamp;
28041 }
28042
28043 public scannerOpenWithStopTs_args deepCopy() {
28044 return new scannerOpenWithStopTs_args(this);
28045 }
28046
28047 @Deprecated
28048 public scannerOpenWithStopTs_args clone() {
28049 return new scannerOpenWithStopTs_args(this);
28050 }
28051
28052
28053
28054
28055 public byte[] getTableName() {
28056 return this.tableName;
28057 }
28058
28059
28060
28061
28062 public scannerOpenWithStopTs_args setTableName(byte[] tableName) {
28063 this.tableName = tableName;
28064 return this;
28065 }
28066
28067 public void unsetTableName() {
28068 this.tableName = null;
28069 }
28070
28071
28072 public boolean isSetTableName() {
28073 return this.tableName != null;
28074 }
28075
28076 public void setTableNameIsSet(boolean value) {
28077 if (!value) {
28078 this.tableName = null;
28079 }
28080 }
28081
28082
28083
28084
28085
28086 public byte[] getStartRow() {
28087 return this.startRow;
28088 }
28089
28090
28091
28092
28093
28094 public scannerOpenWithStopTs_args setStartRow(byte[] startRow) {
28095 this.startRow = startRow;
28096 return this;
28097 }
28098
28099 public void unsetStartRow() {
28100 this.startRow = null;
28101 }
28102
28103
28104 public boolean isSetStartRow() {
28105 return this.startRow != null;
28106 }
28107
28108 public void setStartRowIsSet(boolean value) {
28109 if (!value) {
28110 this.startRow = null;
28111 }
28112 }
28113
28114
28115
28116
28117
28118 public byte[] getStopRow() {
28119 return this.stopRow;
28120 }
28121
28122
28123
28124
28125
28126 public scannerOpenWithStopTs_args setStopRow(byte[] stopRow) {
28127 this.stopRow = stopRow;
28128 return this;
28129 }
28130
28131 public void unsetStopRow() {
28132 this.stopRow = null;
28133 }
28134
28135
28136 public boolean isSetStopRow() {
28137 return this.stopRow != null;
28138 }
28139
28140 public void setStopRowIsSet(boolean value) {
28141 if (!value) {
28142 this.stopRow = null;
28143 }
28144 }
28145
28146 public int getColumnsSize() {
28147 return (this.columns == null) ? 0 : this.columns.size();
28148 }
28149
28150 public java.util.Iterator<byte[]> getColumnsIterator() {
28151 return (this.columns == null) ? null : this.columns.iterator();
28152 }
28153
28154 public void addToColumns(byte[] elem) {
28155 if (this.columns == null) {
28156 this.columns = new ArrayList<byte[]>();
28157 }
28158 this.columns.add(elem);
28159 }
28160
28161
28162
28163
28164
28165
28166 public List<byte[]> getColumns() {
28167 return this.columns;
28168 }
28169
28170
28171
28172
28173
28174
28175 public scannerOpenWithStopTs_args setColumns(List<byte[]> columns) {
28176 this.columns = columns;
28177 return this;
28178 }
28179
28180 public void unsetColumns() {
28181 this.columns = null;
28182 }
28183
28184
28185 public boolean isSetColumns() {
28186 return this.columns != null;
28187 }
28188
28189 public void setColumnsIsSet(boolean value) {
28190 if (!value) {
28191 this.columns = null;
28192 }
28193 }
28194
28195
28196
28197
28198 public long getTimestamp() {
28199 return this.timestamp;
28200 }
28201
28202
28203
28204
28205 public scannerOpenWithStopTs_args setTimestamp(long timestamp) {
28206 this.timestamp = timestamp;
28207 setTimestampIsSet(true);
28208 return this;
28209 }
28210
28211 public void unsetTimestamp() {
28212 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
28213 }
28214
28215
28216 public boolean isSetTimestamp() {
28217 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
28218 }
28219
28220 public void setTimestampIsSet(boolean value) {
28221 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
28222 }
28223
28224 public void setFieldValue(_Fields field, Object value) {
28225 switch (field) {
28226 case TABLE_NAME:
28227 if (value == null) {
28228 unsetTableName();
28229 } else {
28230 setTableName((byte[])value);
28231 }
28232 break;
28233
28234 case START_ROW:
28235 if (value == null) {
28236 unsetStartRow();
28237 } else {
28238 setStartRow((byte[])value);
28239 }
28240 break;
28241
28242 case STOP_ROW:
28243 if (value == null) {
28244 unsetStopRow();
28245 } else {
28246 setStopRow((byte[])value);
28247 }
28248 break;
28249
28250 case COLUMNS:
28251 if (value == null) {
28252 unsetColumns();
28253 } else {
28254 setColumns((List<byte[]>)value);
28255 }
28256 break;
28257
28258 case TIMESTAMP:
28259 if (value == null) {
28260 unsetTimestamp();
28261 } else {
28262 setTimestamp((Long)value);
28263 }
28264 break;
28265
28266 }
28267 }
28268
28269 public void setFieldValue(int fieldID, Object value) {
28270 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
28271 }
28272
28273 public Object getFieldValue(_Fields field) {
28274 switch (field) {
28275 case TABLE_NAME:
28276 return getTableName();
28277
28278 case START_ROW:
28279 return getStartRow();
28280
28281 case STOP_ROW:
28282 return getStopRow();
28283
28284 case COLUMNS:
28285 return getColumns();
28286
28287 case TIMESTAMP:
28288 return new Long(getTimestamp());
28289
28290 }
28291 throw new IllegalStateException();
28292 }
28293
28294 public Object getFieldValue(int fieldId) {
28295 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
28296 }
28297
28298
28299 public boolean isSet(_Fields field) {
28300 switch (field) {
28301 case TABLE_NAME:
28302 return isSetTableName();
28303 case START_ROW:
28304 return isSetStartRow();
28305 case STOP_ROW:
28306 return isSetStopRow();
28307 case COLUMNS:
28308 return isSetColumns();
28309 case TIMESTAMP:
28310 return isSetTimestamp();
28311 }
28312 throw new IllegalStateException();
28313 }
28314
28315 public boolean isSet(int fieldID) {
28316 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
28317 }
28318
28319 @Override
28320 public boolean equals(Object that) {
28321 if (that == null)
28322 return false;
28323 if (that instanceof scannerOpenWithStopTs_args)
28324 return this.equals((scannerOpenWithStopTs_args)that);
28325 return false;
28326 }
28327
28328 public boolean equals(scannerOpenWithStopTs_args that) {
28329 if (that == null)
28330 return false;
28331
28332 boolean this_present_tableName = true && this.isSetTableName();
28333 boolean that_present_tableName = true && that.isSetTableName();
28334 if (this_present_tableName || that_present_tableName) {
28335 if (!(this_present_tableName && that_present_tableName))
28336 return false;
28337 if (!java.util.Arrays.equals(this.tableName, that.tableName))
28338 return false;
28339 }
28340
28341 boolean this_present_startRow = true && this.isSetStartRow();
28342 boolean that_present_startRow = true && that.isSetStartRow();
28343 if (this_present_startRow || that_present_startRow) {
28344 if (!(this_present_startRow && that_present_startRow))
28345 return false;
28346 if (!java.util.Arrays.equals(this.startRow, that.startRow))
28347 return false;
28348 }
28349
28350 boolean this_present_stopRow = true && this.isSetStopRow();
28351 boolean that_present_stopRow = true && that.isSetStopRow();
28352 if (this_present_stopRow || that_present_stopRow) {
28353 if (!(this_present_stopRow && that_present_stopRow))
28354 return false;
28355 if (!java.util.Arrays.equals(this.stopRow, that.stopRow))
28356 return false;
28357 }
28358
28359 boolean this_present_columns = true && this.isSetColumns();
28360 boolean that_present_columns = true && that.isSetColumns();
28361 if (this_present_columns || that_present_columns) {
28362 if (!(this_present_columns && that_present_columns))
28363 return false;
28364 if (!this.columns.equals(that.columns))
28365 return false;
28366 }
28367
28368 boolean this_present_timestamp = true;
28369 boolean that_present_timestamp = true;
28370 if (this_present_timestamp || that_present_timestamp) {
28371 if (!(this_present_timestamp && that_present_timestamp))
28372 return false;
28373 if (this.timestamp != that.timestamp)
28374 return false;
28375 }
28376
28377 return true;
28378 }
28379
28380 @Override
28381 public int hashCode() {
28382 HashCodeBuilder builder = new HashCodeBuilder();
28383
28384 boolean present_tableName = true && (isSetTableName());
28385 builder.append(present_tableName);
28386 if (present_tableName)
28387 builder.append(tableName);
28388
28389 boolean present_startRow = true && (isSetStartRow());
28390 builder.append(present_startRow);
28391 if (present_startRow)
28392 builder.append(startRow);
28393
28394 boolean present_stopRow = true && (isSetStopRow());
28395 builder.append(present_stopRow);
28396 if (present_stopRow)
28397 builder.append(stopRow);
28398
28399 boolean present_columns = true && (isSetColumns());
28400 builder.append(present_columns);
28401 if (present_columns)
28402 builder.append(columns);
28403
28404 boolean present_timestamp = true;
28405 builder.append(present_timestamp);
28406 if (present_timestamp)
28407 builder.append(timestamp);
28408
28409 return builder.toHashCode();
28410 }
28411
28412 public int compareTo(scannerOpenWithStopTs_args other) {
28413 if (!getClass().equals(other.getClass())) {
28414 return getClass().getName().compareTo(other.getClass().getName());
28415 }
28416
28417 int lastComparison = 0;
28418 scannerOpenWithStopTs_args typedOther = (scannerOpenWithStopTs_args)other;
28419
28420 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
28421 if (lastComparison != 0) {
28422 return lastComparison;
28423 }
28424 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
28425 if (lastComparison != 0) {
28426 return lastComparison;
28427 }
28428 lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
28429 if (lastComparison != 0) {
28430 return lastComparison;
28431 }
28432 lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
28433 if (lastComparison != 0) {
28434 return lastComparison;
28435 }
28436 lastComparison = Boolean.valueOf(isSetStopRow()).compareTo(isSetStopRow());
28437 if (lastComparison != 0) {
28438 return lastComparison;
28439 }
28440 lastComparison = TBaseHelper.compareTo(stopRow, typedOther.stopRow);
28441 if (lastComparison != 0) {
28442 return lastComparison;
28443 }
28444 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
28445 if (lastComparison != 0) {
28446 return lastComparison;
28447 }
28448 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
28449 if (lastComparison != 0) {
28450 return lastComparison;
28451 }
28452 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
28453 if (lastComparison != 0) {
28454 return lastComparison;
28455 }
28456 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
28457 if (lastComparison != 0) {
28458 return lastComparison;
28459 }
28460 return 0;
28461 }
28462
28463 public void read(TProtocol iprot) throws TException {
28464 TField field;
28465 iprot.readStructBegin();
28466 while (true)
28467 {
28468 field = iprot.readFieldBegin();
28469 if (field.type == TType.STOP) {
28470 break;
28471 }
28472 _Fields fieldId = _Fields.findByThriftId(field.id);
28473 if (fieldId == null) {
28474 TProtocolUtil.skip(iprot, field.type);
28475 } else {
28476 switch (fieldId) {
28477 case TABLE_NAME:
28478 if (field.type == TType.STRING) {
28479 this.tableName = iprot.readBinary();
28480 } else {
28481 TProtocolUtil.skip(iprot, field.type);
28482 }
28483 break;
28484 case START_ROW:
28485 if (field.type == TType.STRING) {
28486 this.startRow = iprot.readBinary();
28487 } else {
28488 TProtocolUtil.skip(iprot, field.type);
28489 }
28490 break;
28491 case STOP_ROW:
28492 if (field.type == TType.STRING) {
28493 this.stopRow = iprot.readBinary();
28494 } else {
28495 TProtocolUtil.skip(iprot, field.type);
28496 }
28497 break;
28498 case COLUMNS:
28499 if (field.type == TType.LIST) {
28500 {
28501 TList _list94 = iprot.readListBegin();
28502 this.columns = new ArrayList<byte[]>(_list94.size);
28503 for (int _i95 = 0; _i95 < _list94.size; ++_i95)
28504 {
28505 byte[] _elem96;
28506 _elem96 = iprot.readBinary();
28507 this.columns.add(_elem96);
28508 }
28509 iprot.readListEnd();
28510 }
28511 } else {
28512 TProtocolUtil.skip(iprot, field.type);
28513 }
28514 break;
28515 case TIMESTAMP:
28516 if (field.type == TType.I64) {
28517 this.timestamp = iprot.readI64();
28518 setTimestampIsSet(true);
28519 } else {
28520 TProtocolUtil.skip(iprot, field.type);
28521 }
28522 break;
28523 }
28524 iprot.readFieldEnd();
28525 }
28526 }
28527 iprot.readStructEnd();
28528
28529
28530 validate();
28531 }
28532
28533 public void write(TProtocol oprot) throws TException {
28534 validate();
28535
28536 oprot.writeStructBegin(STRUCT_DESC);
28537 if (this.tableName != null) {
28538 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
28539 oprot.writeBinary(this.tableName);
28540 oprot.writeFieldEnd();
28541 }
28542 if (this.startRow != null) {
28543 oprot.writeFieldBegin(START_ROW_FIELD_DESC);
28544 oprot.writeBinary(this.startRow);
28545 oprot.writeFieldEnd();
28546 }
28547 if (this.stopRow != null) {
28548 oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
28549 oprot.writeBinary(this.stopRow);
28550 oprot.writeFieldEnd();
28551 }
28552 if (this.columns != null) {
28553 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
28554 {
28555 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
28556 for (byte[] _iter97 : this.columns)
28557 {
28558 oprot.writeBinary(_iter97);
28559 }
28560 oprot.writeListEnd();
28561 }
28562 oprot.writeFieldEnd();
28563 }
28564 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
28565 oprot.writeI64(this.timestamp);
28566 oprot.writeFieldEnd();
28567 oprot.writeFieldStop();
28568 oprot.writeStructEnd();
28569 }
28570
28571 @Override
28572 public String toString() {
28573 StringBuilder sb = new StringBuilder("scannerOpenWithStopTs_args(");
28574 boolean first = true;
28575
28576 sb.append("tableName:");
28577 if (this.tableName == null) {
28578 sb.append("null");
28579 } else {
28580 sb.append(this.tableName);
28581 }
28582 first = false;
28583 if (!first) sb.append(", ");
28584 sb.append("startRow:");
28585 if (this.startRow == null) {
28586 sb.append("null");
28587 } else {
28588 sb.append(this.startRow);
28589 }
28590 first = false;
28591 if (!first) sb.append(", ");
28592 sb.append("stopRow:");
28593 if (this.stopRow == null) {
28594 sb.append("null");
28595 } else {
28596 sb.append(this.stopRow);
28597 }
28598 first = false;
28599 if (!first) sb.append(", ");
28600 sb.append("columns:");
28601 if (this.columns == null) {
28602 sb.append("null");
28603 } else {
28604 sb.append(this.columns);
28605 }
28606 first = false;
28607 if (!first) sb.append(", ");
28608 sb.append("timestamp:");
28609 sb.append(this.timestamp);
28610 first = false;
28611 sb.append(")");
28612 return sb.toString();
28613 }
28614
28615 public void validate() throws TException {
28616
28617 }
28618
28619 }
28620
28621 public static class scannerOpenWithStopTs_result implements TBase<scannerOpenWithStopTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_result> {
28622 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_result");
28623
28624 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
28625 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
28626
28627 public int success;
28628 public IOError io;
28629
28630
28631 public enum _Fields implements TFieldIdEnum {
28632 SUCCESS((short)0, "success"),
28633 IO((short)1, "io");
28634
28635 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
28636 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
28637
28638 static {
28639 for (_Fields field : EnumSet.allOf(_Fields.class)) {
28640 byId.put((int)field._thriftId, field);
28641 byName.put(field.getFieldName(), field);
28642 }
28643 }
28644
28645
28646
28647
28648 public static _Fields findByThriftId(int fieldId) {
28649 return byId.get(fieldId);
28650 }
28651
28652
28653
28654
28655
28656 public static _Fields findByThriftIdOrThrow(int fieldId) {
28657 _Fields fields = findByThriftId(fieldId);
28658 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
28659 return fields;
28660 }
28661
28662
28663
28664
28665 public static _Fields findByName(String name) {
28666 return byName.get(name);
28667 }
28668
28669 private final short _thriftId;
28670 private final String _fieldName;
28671
28672 _Fields(short thriftId, String fieldName) {
28673 _thriftId = thriftId;
28674 _fieldName = fieldName;
28675 }
28676
28677 public short getThriftFieldId() {
28678 return _thriftId;
28679 }
28680
28681 public String getFieldName() {
28682 return _fieldName;
28683 }
28684 }
28685
28686
28687 private static final int __SUCCESS_ISSET_ID = 0;
28688 private BitSet __isset_bit_vector = new BitSet(1);
28689
28690 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
28691 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
28692 new FieldValueMetaData(TType.I32)));
28693 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
28694 new FieldValueMetaData(TType.STRUCT)));
28695 }});
28696
28697 static {
28698 FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_result.class, metaDataMap);
28699 }
28700
28701 public scannerOpenWithStopTs_result() {
28702 }
28703
28704 public scannerOpenWithStopTs_result(
28705 int success,
28706 IOError io)
28707 {
28708 this();
28709 this.success = success;
28710 setSuccessIsSet(true);
28711 this.io = io;
28712 }
28713
28714
28715
28716
28717 public scannerOpenWithStopTs_result(scannerOpenWithStopTs_result other) {
28718 __isset_bit_vector.clear();
28719 __isset_bit_vector.or(other.__isset_bit_vector);
28720 this.success = other.success;
28721 if (other.isSetIo()) {
28722 this.io = new IOError(other.io);
28723 }
28724 }
28725
28726 public scannerOpenWithStopTs_result deepCopy() {
28727 return new scannerOpenWithStopTs_result(this);
28728 }
28729
28730 @Deprecated
28731 public scannerOpenWithStopTs_result clone() {
28732 return new scannerOpenWithStopTs_result(this);
28733 }
28734
28735 public int getSuccess() {
28736 return this.success;
28737 }
28738
28739 public scannerOpenWithStopTs_result setSuccess(int success) {
28740 this.success = success;
28741 setSuccessIsSet(true);
28742 return this;
28743 }
28744
28745 public void unsetSuccess() {
28746 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
28747 }
28748
28749
28750 public boolean isSetSuccess() {
28751 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
28752 }
28753
28754 public void setSuccessIsSet(boolean value) {
28755 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
28756 }
28757
28758 public IOError getIo() {
28759 return this.io;
28760 }
28761
28762 public scannerOpenWithStopTs_result setIo(IOError io) {
28763 this.io = io;
28764 return this;
28765 }
28766
28767 public void unsetIo() {
28768 this.io = null;
28769 }
28770
28771
28772 public boolean isSetIo() {
28773 return this.io != null;
28774 }
28775
28776 public void setIoIsSet(boolean value) {
28777 if (!value) {
28778 this.io = null;
28779 }
28780 }
28781
28782 public void setFieldValue(_Fields field, Object value) {
28783 switch (field) {
28784 case SUCCESS:
28785 if (value == null) {
28786 unsetSuccess();
28787 } else {
28788 setSuccess((Integer)value);
28789 }
28790 break;
28791
28792 case IO:
28793 if (value == null) {
28794 unsetIo();
28795 } else {
28796 setIo((IOError)value);
28797 }
28798 break;
28799
28800 }
28801 }
28802
28803 public void setFieldValue(int fieldID, Object value) {
28804 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
28805 }
28806
28807 public Object getFieldValue(_Fields field) {
28808 switch (field) {
28809 case SUCCESS:
28810 return new Integer(getSuccess());
28811
28812 case IO:
28813 return getIo();
28814
28815 }
28816 throw new IllegalStateException();
28817 }
28818
28819 public Object getFieldValue(int fieldId) {
28820 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
28821 }
28822
28823
28824 public boolean isSet(_Fields field) {
28825 switch (field) {
28826 case SUCCESS:
28827 return isSetSuccess();
28828 case IO:
28829 return isSetIo();
28830 }
28831 throw new IllegalStateException();
28832 }
28833
28834 public boolean isSet(int fieldID) {
28835 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
28836 }
28837
28838 @Override
28839 public boolean equals(Object that) {
28840 if (that == null)
28841 return false;
28842 if (that instanceof scannerOpenWithStopTs_result)
28843 return this.equals((scannerOpenWithStopTs_result)that);
28844 return false;
28845 }
28846
28847 public boolean equals(scannerOpenWithStopTs_result that) {
28848 if (that == null)
28849 return false;
28850
28851 boolean this_present_success = true;
28852 boolean that_present_success = true;
28853 if (this_present_success || that_present_success) {
28854 if (!(this_present_success && that_present_success))
28855 return false;
28856 if (this.success != that.success)
28857 return false;
28858 }
28859
28860 boolean this_present_io = true && this.isSetIo();
28861 boolean that_present_io = true && that.isSetIo();
28862 if (this_present_io || that_present_io) {
28863 if (!(this_present_io && that_present_io))
28864 return false;
28865 if (!this.io.equals(that.io))
28866 return false;
28867 }
28868
28869 return true;
28870 }
28871
28872 @Override
28873 public int hashCode() {
28874 HashCodeBuilder builder = new HashCodeBuilder();
28875
28876 boolean present_success = true;
28877 builder.append(present_success);
28878 if (present_success)
28879 builder.append(success);
28880
28881 boolean present_io = true && (isSetIo());
28882 builder.append(present_io);
28883 if (present_io)
28884 builder.append(io);
28885
28886 return builder.toHashCode();
28887 }
28888
28889 public int compareTo(scannerOpenWithStopTs_result other) {
28890 if (!getClass().equals(other.getClass())) {
28891 return getClass().getName().compareTo(other.getClass().getName());
28892 }
28893
28894 int lastComparison = 0;
28895 scannerOpenWithStopTs_result typedOther = (scannerOpenWithStopTs_result)other;
28896
28897 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
28898 if (lastComparison != 0) {
28899 return lastComparison;
28900 }
28901 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
28902 if (lastComparison != 0) {
28903 return lastComparison;
28904 }
28905 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
28906 if (lastComparison != 0) {
28907 return lastComparison;
28908 }
28909 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
28910 if (lastComparison != 0) {
28911 return lastComparison;
28912 }
28913 return 0;
28914 }
28915
28916 public void read(TProtocol iprot) throws TException {
28917 TField field;
28918 iprot.readStructBegin();
28919 while (true)
28920 {
28921 field = iprot.readFieldBegin();
28922 if (field.type == TType.STOP) {
28923 break;
28924 }
28925 _Fields fieldId = _Fields.findByThriftId(field.id);
28926 if (fieldId == null) {
28927 TProtocolUtil.skip(iprot, field.type);
28928 } else {
28929 switch (fieldId) {
28930 case SUCCESS:
28931 if (field.type == TType.I32) {
28932 this.success = iprot.readI32();
28933 setSuccessIsSet(true);
28934 } else {
28935 TProtocolUtil.skip(iprot, field.type);
28936 }
28937 break;
28938 case IO:
28939 if (field.type == TType.STRUCT) {
28940 this.io = new IOError();
28941 this.io.read(iprot);
28942 } else {
28943 TProtocolUtil.skip(iprot, field.type);
28944 }
28945 break;
28946 }
28947 iprot.readFieldEnd();
28948 }
28949 }
28950 iprot.readStructEnd();
28951
28952
28953 validate();
28954 }
28955
28956 public void write(TProtocol oprot) throws TException {
28957 oprot.writeStructBegin(STRUCT_DESC);
28958
28959 if (this.isSetSuccess()) {
28960 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28961 oprot.writeI32(this.success);
28962 oprot.writeFieldEnd();
28963 } else if (this.isSetIo()) {
28964 oprot.writeFieldBegin(IO_FIELD_DESC);
28965 this.io.write(oprot);
28966 oprot.writeFieldEnd();
28967 }
28968 oprot.writeFieldStop();
28969 oprot.writeStructEnd();
28970 }
28971
28972 @Override
28973 public String toString() {
28974 StringBuilder sb = new StringBuilder("scannerOpenWithStopTs_result(");
28975 boolean first = true;
28976
28977 sb.append("success:");
28978 sb.append(this.success);
28979 first = false;
28980 if (!first) sb.append(", ");
28981 sb.append("io:");
28982 if (this.io == null) {
28983 sb.append("null");
28984 } else {
28985 sb.append(this.io);
28986 }
28987 first = false;
28988 sb.append(")");
28989 return sb.toString();
28990 }
28991
28992 public void validate() throws TException {
28993
28994 }
28995
28996 }
28997
28998 public static class scannerGet_args implements TBase<scannerGet_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGet_args> {
28999 private static final TStruct STRUCT_DESC = new TStruct("scannerGet_args");
29000
29001 private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
29002
29003
29004
29005
29006 public int id;
29007
29008
29009 public enum _Fields implements TFieldIdEnum {
29010
29011
29012
29013 ID((short)1, "id");
29014
29015 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29016 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29017
29018 static {
29019 for (_Fields field : EnumSet.allOf(_Fields.class)) {
29020 byId.put((int)field._thriftId, field);
29021 byName.put(field.getFieldName(), field);
29022 }
29023 }
29024
29025
29026
29027
29028 public static _Fields findByThriftId(int fieldId) {
29029 return byId.get(fieldId);
29030 }
29031
29032
29033
29034
29035
29036 public static _Fields findByThriftIdOrThrow(int fieldId) {
29037 _Fields fields = findByThriftId(fieldId);
29038 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29039 return fields;
29040 }
29041
29042
29043
29044
29045 public static _Fields findByName(String name) {
29046 return byName.get(name);
29047 }
29048
29049 private final short _thriftId;
29050 private final String _fieldName;
29051
29052 _Fields(short thriftId, String fieldName) {
29053 _thriftId = thriftId;
29054 _fieldName = fieldName;
29055 }
29056
29057 public short getThriftFieldId() {
29058 return _thriftId;
29059 }
29060
29061 public String getFieldName() {
29062 return _fieldName;
29063 }
29064 }
29065
29066
29067 private static final int __ID_ISSET_ID = 0;
29068 private BitSet __isset_bit_vector = new BitSet(1);
29069
29070 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29071 put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
29072 new FieldValueMetaData(TType.I32)));
29073 }});
29074
29075 static {
29076 FieldMetaData.addStructMetaDataMap(scannerGet_args.class, metaDataMap);
29077 }
29078
29079 public scannerGet_args() {
29080 }
29081
29082 public scannerGet_args(
29083 int id)
29084 {
29085 this();
29086 this.id = id;
29087 setIdIsSet(true);
29088 }
29089
29090
29091
29092
29093 public scannerGet_args(scannerGet_args other) {
29094 __isset_bit_vector.clear();
29095 __isset_bit_vector.or(other.__isset_bit_vector);
29096 this.id = other.id;
29097 }
29098
29099 public scannerGet_args deepCopy() {
29100 return new scannerGet_args(this);
29101 }
29102
29103 @Deprecated
29104 public scannerGet_args clone() {
29105 return new scannerGet_args(this);
29106 }
29107
29108
29109
29110
29111 public int getId() {
29112 return this.id;
29113 }
29114
29115
29116
29117
29118 public scannerGet_args setId(int id) {
29119 this.id = id;
29120 setIdIsSet(true);
29121 return this;
29122 }
29123
29124 public void unsetId() {
29125 __isset_bit_vector.clear(__ID_ISSET_ID);
29126 }
29127
29128
29129 public boolean isSetId() {
29130 return __isset_bit_vector.get(__ID_ISSET_ID);
29131 }
29132
29133 public void setIdIsSet(boolean value) {
29134 __isset_bit_vector.set(__ID_ISSET_ID, value);
29135 }
29136
29137 public void setFieldValue(_Fields field, Object value) {
29138 switch (field) {
29139 case ID:
29140 if (value == null) {
29141 unsetId();
29142 } else {
29143 setId((Integer)value);
29144 }
29145 break;
29146
29147 }
29148 }
29149
29150 public void setFieldValue(int fieldID, Object value) {
29151 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29152 }
29153
29154 public Object getFieldValue(_Fields field) {
29155 switch (field) {
29156 case ID:
29157 return new Integer(getId());
29158
29159 }
29160 throw new IllegalStateException();
29161 }
29162
29163 public Object getFieldValue(int fieldId) {
29164 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29165 }
29166
29167
29168 public boolean isSet(_Fields field) {
29169 switch (field) {
29170 case ID:
29171 return isSetId();
29172 }
29173 throw new IllegalStateException();
29174 }
29175
29176 public boolean isSet(int fieldID) {
29177 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
29178 }
29179
29180 @Override
29181 public boolean equals(Object that) {
29182 if (that == null)
29183 return false;
29184 if (that instanceof scannerGet_args)
29185 return this.equals((scannerGet_args)that);
29186 return false;
29187 }
29188
29189 public boolean equals(scannerGet_args that) {
29190 if (that == null)
29191 return false;
29192
29193 boolean this_present_id = true;
29194 boolean that_present_id = true;
29195 if (this_present_id || that_present_id) {
29196 if (!(this_present_id && that_present_id))
29197 return false;
29198 if (this.id != that.id)
29199 return false;
29200 }
29201
29202 return true;
29203 }
29204
29205 @Override
29206 public int hashCode() {
29207 HashCodeBuilder builder = new HashCodeBuilder();
29208
29209 boolean present_id = true;
29210 builder.append(present_id);
29211 if (present_id)
29212 builder.append(id);
29213
29214 return builder.toHashCode();
29215 }
29216
29217 public int compareTo(scannerGet_args other) {
29218 if (!getClass().equals(other.getClass())) {
29219 return getClass().getName().compareTo(other.getClass().getName());
29220 }
29221
29222 int lastComparison = 0;
29223 scannerGet_args typedOther = (scannerGet_args)other;
29224
29225 lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
29226 if (lastComparison != 0) {
29227 return lastComparison;
29228 }
29229 lastComparison = TBaseHelper.compareTo(id, typedOther.id);
29230 if (lastComparison != 0) {
29231 return lastComparison;
29232 }
29233 return 0;
29234 }
29235
29236 public void read(TProtocol iprot) throws TException {
29237 TField field;
29238 iprot.readStructBegin();
29239 while (true)
29240 {
29241 field = iprot.readFieldBegin();
29242 if (field.type == TType.STOP) {
29243 break;
29244 }
29245 _Fields fieldId = _Fields.findByThriftId(field.id);
29246 if (fieldId == null) {
29247 TProtocolUtil.skip(iprot, field.type);
29248 } else {
29249 switch (fieldId) {
29250 case ID:
29251 if (field.type == TType.I32) {
29252 this.id = iprot.readI32();
29253 setIdIsSet(true);
29254 } else {
29255 TProtocolUtil.skip(iprot, field.type);
29256 }
29257 break;
29258 }
29259 iprot.readFieldEnd();
29260 }
29261 }
29262 iprot.readStructEnd();
29263
29264
29265 validate();
29266 }
29267
29268 public void write(TProtocol oprot) throws TException {
29269 validate();
29270
29271 oprot.writeStructBegin(STRUCT_DESC);
29272 oprot.writeFieldBegin(ID_FIELD_DESC);
29273 oprot.writeI32(this.id);
29274 oprot.writeFieldEnd();
29275 oprot.writeFieldStop();
29276 oprot.writeStructEnd();
29277 }
29278
29279 @Override
29280 public String toString() {
29281 StringBuilder sb = new StringBuilder("scannerGet_args(");
29282 boolean first = true;
29283
29284 sb.append("id:");
29285 sb.append(this.id);
29286 first = false;
29287 sb.append(")");
29288 return sb.toString();
29289 }
29290
29291 public void validate() throws TException {
29292
29293 }
29294
29295 }
29296
29297 public static class scannerGet_result implements TBase<scannerGet_result._Fields>, java.io.Serializable, Cloneable {
29298 private static final TStruct STRUCT_DESC = new TStruct("scannerGet_result");
29299
29300 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
29301 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
29302 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
29303
29304 public List<TRowResult> success;
29305 public IOError io;
29306 public IllegalArgument ia;
29307
29308
29309 public enum _Fields implements TFieldIdEnum {
29310 SUCCESS((short)0, "success"),
29311 IO((short)1, "io"),
29312 IA((short)2, "ia");
29313
29314 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29315 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29316
29317 static {
29318 for (_Fields field : EnumSet.allOf(_Fields.class)) {
29319 byId.put((int)field._thriftId, field);
29320 byName.put(field.getFieldName(), field);
29321 }
29322 }
29323
29324
29325
29326
29327 public static _Fields findByThriftId(int fieldId) {
29328 return byId.get(fieldId);
29329 }
29330
29331
29332
29333
29334
29335 public static _Fields findByThriftIdOrThrow(int fieldId) {
29336 _Fields fields = findByThriftId(fieldId);
29337 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29338 return fields;
29339 }
29340
29341
29342
29343
29344 public static _Fields findByName(String name) {
29345 return byName.get(name);
29346 }
29347
29348 private final short _thriftId;
29349 private final String _fieldName;
29350
29351 _Fields(short thriftId, String fieldName) {
29352 _thriftId = thriftId;
29353 _fieldName = fieldName;
29354 }
29355
29356 public short getThriftFieldId() {
29357 return _thriftId;
29358 }
29359
29360 public String getFieldName() {
29361 return _fieldName;
29362 }
29363 }
29364
29365
29366
29367 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29368 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
29369 new ListMetaData(TType.LIST,
29370 new StructMetaData(TType.STRUCT, TRowResult.class))));
29371 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
29372 new FieldValueMetaData(TType.STRUCT)));
29373 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
29374 new FieldValueMetaData(TType.STRUCT)));
29375 }});
29376
29377 static {
29378 FieldMetaData.addStructMetaDataMap(scannerGet_result.class, metaDataMap);
29379 }
29380
29381 public scannerGet_result() {
29382 }
29383
29384 public scannerGet_result(
29385 List<TRowResult> success,
29386 IOError io,
29387 IllegalArgument ia)
29388 {
29389 this();
29390 this.success = success;
29391 this.io = io;
29392 this.ia = ia;
29393 }
29394
29395
29396
29397
29398 public scannerGet_result(scannerGet_result other) {
29399 if (other.isSetSuccess()) {
29400 List<TRowResult> __this__success = new ArrayList<TRowResult>();
29401 for (TRowResult other_element : other.success) {
29402 __this__success.add(new TRowResult(other_element));
29403 }
29404 this.success = __this__success;
29405 }
29406 if (other.isSetIo()) {
29407 this.io = new IOError(other.io);
29408 }
29409 if (other.isSetIa()) {
29410 this.ia = new IllegalArgument(other.ia);
29411 }
29412 }
29413
29414 public scannerGet_result deepCopy() {
29415 return new scannerGet_result(this);
29416 }
29417
29418 @Deprecated
29419 public scannerGet_result clone() {
29420 return new scannerGet_result(this);
29421 }
29422
29423 public int getSuccessSize() {
29424 return (this.success == null) ? 0 : this.success.size();
29425 }
29426
29427 public java.util.Iterator<TRowResult> getSuccessIterator() {
29428 return (this.success == null) ? null : this.success.iterator();
29429 }
29430
29431 public void addToSuccess(TRowResult elem) {
29432 if (this.success == null) {
29433 this.success = new ArrayList<TRowResult>();
29434 }
29435 this.success.add(elem);
29436 }
29437
29438 public List<TRowResult> getSuccess() {
29439 return this.success;
29440 }
29441
29442 public scannerGet_result setSuccess(List<TRowResult> success) {
29443 this.success = success;
29444 return this;
29445 }
29446
29447 public void unsetSuccess() {
29448 this.success = null;
29449 }
29450
29451
29452 public boolean isSetSuccess() {
29453 return this.success != null;
29454 }
29455
29456 public void setSuccessIsSet(boolean value) {
29457 if (!value) {
29458 this.success = null;
29459 }
29460 }
29461
29462 public IOError getIo() {
29463 return this.io;
29464 }
29465
29466 public scannerGet_result setIo(IOError io) {
29467 this.io = io;
29468 return this;
29469 }
29470
29471 public void unsetIo() {
29472 this.io = null;
29473 }
29474
29475
29476 public boolean isSetIo() {
29477 return this.io != null;
29478 }
29479
29480 public void setIoIsSet(boolean value) {
29481 if (!value) {
29482 this.io = null;
29483 }
29484 }
29485
29486 public IllegalArgument getIa() {
29487 return this.ia;
29488 }
29489
29490 public scannerGet_result setIa(IllegalArgument ia) {
29491 this.ia = ia;
29492 return this;
29493 }
29494
29495 public void unsetIa() {
29496 this.ia = null;
29497 }
29498
29499
29500 public boolean isSetIa() {
29501 return this.ia != null;
29502 }
29503
29504 public void setIaIsSet(boolean value) {
29505 if (!value) {
29506 this.ia = null;
29507 }
29508 }
29509
29510 public void setFieldValue(_Fields field, Object value) {
29511 switch (field) {
29512 case SUCCESS:
29513 if (value == null) {
29514 unsetSuccess();
29515 } else {
29516 setSuccess((List<TRowResult>)value);
29517 }
29518 break;
29519
29520 case IO:
29521 if (value == null) {
29522 unsetIo();
29523 } else {
29524 setIo((IOError)value);
29525 }
29526 break;
29527
29528 case IA:
29529 if (value == null) {
29530 unsetIa();
29531 } else {
29532 setIa((IllegalArgument)value);
29533 }
29534 break;
29535
29536 }
29537 }
29538
29539 public void setFieldValue(int fieldID, Object value) {
29540 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29541 }
29542
29543 public Object getFieldValue(_Fields field) {
29544 switch (field) {
29545 case SUCCESS:
29546 return getSuccess();
29547
29548 case IO:
29549 return getIo();
29550
29551 case IA:
29552 return getIa();
29553
29554 }
29555 throw new IllegalStateException();
29556 }
29557
29558 public Object getFieldValue(int fieldId) {
29559 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29560 }
29561
29562
29563 public boolean isSet(_Fields field) {
29564 switch (field) {
29565 case SUCCESS:
29566 return isSetSuccess();
29567 case IO:
29568 return isSetIo();
29569 case IA:
29570 return isSetIa();
29571 }
29572 throw new IllegalStateException();
29573 }
29574
29575 public boolean isSet(int fieldID) {
29576 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
29577 }
29578
29579 @Override
29580 public boolean equals(Object that) {
29581 if (that == null)
29582 return false;
29583 if (that instanceof scannerGet_result)
29584 return this.equals((scannerGet_result)that);
29585 return false;
29586 }
29587
29588 public boolean equals(scannerGet_result that) {
29589 if (that == null)
29590 return false;
29591
29592 boolean this_present_success = true && this.isSetSuccess();
29593 boolean that_present_success = true && that.isSetSuccess();
29594 if (this_present_success || that_present_success) {
29595 if (!(this_present_success && that_present_success))
29596 return false;
29597 if (!this.success.equals(that.success))
29598 return false;
29599 }
29600
29601 boolean this_present_io = true && this.isSetIo();
29602 boolean that_present_io = true && that.isSetIo();
29603 if (this_present_io || that_present_io) {
29604 if (!(this_present_io && that_present_io))
29605 return false;
29606 if (!this.io.equals(that.io))
29607 return false;
29608 }
29609
29610 boolean this_present_ia = true && this.isSetIa();
29611 boolean that_present_ia = true && that.isSetIa();
29612 if (this_present_ia || that_present_ia) {
29613 if (!(this_present_ia && that_present_ia))
29614 return false;
29615 if (!this.ia.equals(that.ia))
29616 return false;
29617 }
29618
29619 return true;
29620 }
29621
29622 @Override
29623 public int hashCode() {
29624 HashCodeBuilder builder = new HashCodeBuilder();
29625
29626 boolean present_success = true && (isSetSuccess());
29627 builder.append(present_success);
29628 if (present_success)
29629 builder.append(success);
29630
29631 boolean present_io = true && (isSetIo());
29632 builder.append(present_io);
29633 if (present_io)
29634 builder.append(io);
29635
29636 boolean present_ia = true && (isSetIa());
29637 builder.append(present_ia);
29638 if (present_ia)
29639 builder.append(ia);
29640
29641 return builder.toHashCode();
29642 }
29643
29644 public void read(TProtocol iprot) throws TException {
29645 TField field;
29646 iprot.readStructBegin();
29647 while (true)
29648 {
29649 field = iprot.readFieldBegin();
29650 if (field.type == TType.STOP) {
29651 break;
29652 }
29653 _Fields fieldId = _Fields.findByThriftId(field.id);
29654 if (fieldId == null) {
29655 TProtocolUtil.skip(iprot, field.type);
29656 } else {
29657 switch (fieldId) {
29658 case SUCCESS:
29659 if (field.type == TType.LIST) {
29660 {
29661 TList _list98 = iprot.readListBegin();
29662 this.success = new ArrayList<TRowResult>(_list98.size);
29663 for (int _i99 = 0; _i99 < _list98.size; ++_i99)
29664 {
29665 TRowResult _elem100;
29666 _elem100 = new TRowResult();
29667 _elem100.read(iprot);
29668 this.success.add(_elem100);
29669 }
29670 iprot.readListEnd();
29671 }
29672 } else {
29673 TProtocolUtil.skip(iprot, field.type);
29674 }
29675 break;
29676 case IO:
29677 if (field.type == TType.STRUCT) {
29678 this.io = new IOError();
29679 this.io.read(iprot);
29680 } else {
29681 TProtocolUtil.skip(iprot, field.type);
29682 }
29683 break;
29684 case IA:
29685 if (field.type == TType.STRUCT) {
29686 this.ia = new IllegalArgument();
29687 this.ia.read(iprot);
29688 } else {
29689 TProtocolUtil.skip(iprot, field.type);
29690 }
29691 break;
29692 }
29693 iprot.readFieldEnd();
29694 }
29695 }
29696 iprot.readStructEnd();
29697
29698
29699 validate();
29700 }
29701
29702 public void write(TProtocol oprot) throws TException {
29703 oprot.writeStructBegin(STRUCT_DESC);
29704
29705 if (this.isSetSuccess()) {
29706 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29707 {
29708 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
29709 for (TRowResult _iter101 : this.success)
29710 {
29711 _iter101.write(oprot);
29712 }
29713 oprot.writeListEnd();
29714 }
29715 oprot.writeFieldEnd();
29716 } else if (this.isSetIo()) {
29717 oprot.writeFieldBegin(IO_FIELD_DESC);
29718 this.io.write(oprot);
29719 oprot.writeFieldEnd();
29720 } else if (this.isSetIa()) {
29721 oprot.writeFieldBegin(IA_FIELD_DESC);
29722 this.ia.write(oprot);
29723 oprot.writeFieldEnd();
29724 }
29725 oprot.writeFieldStop();
29726 oprot.writeStructEnd();
29727 }
29728
29729 @Override
29730 public String toString() {
29731 StringBuilder sb = new StringBuilder("scannerGet_result(");
29732 boolean first = true;
29733
29734 sb.append("success:");
29735 if (this.success == null) {
29736 sb.append("null");
29737 } else {
29738 sb.append(this.success);
29739 }
29740 first = false;
29741 if (!first) sb.append(", ");
29742 sb.append("io:");
29743 if (this.io == null) {
29744 sb.append("null");
29745 } else {
29746 sb.append(this.io);
29747 }
29748 first = false;
29749 if (!first) sb.append(", ");
29750 sb.append("ia:");
29751 if (this.ia == null) {
29752 sb.append("null");
29753 } else {
29754 sb.append(this.ia);
29755 }
29756 first = false;
29757 sb.append(")");
29758 return sb.toString();
29759 }
29760
29761 public void validate() throws TException {
29762
29763 }
29764
29765 }
29766
29767 public static class scannerGetList_args implements TBase<scannerGetList_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGetList_args> {
29768 private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_args");
29769
29770 private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
29771 private static final TField NB_ROWS_FIELD_DESC = new TField("nbRows", TType.I32, (short)2);
29772
29773
29774
29775
29776 public int id;
29777
29778
29779
29780 public int nbRows;
29781
29782
29783 public enum _Fields implements TFieldIdEnum {
29784
29785
29786
29787 ID((short)1, "id"),
29788
29789
29790
29791 NB_ROWS((short)2, "nbRows");
29792
29793 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29794 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29795
29796 static {
29797 for (_Fields field : EnumSet.allOf(_Fields.class)) {
29798 byId.put((int)field._thriftId, field);
29799 byName.put(field.getFieldName(), field);
29800 }
29801 }
29802
29803
29804
29805
29806 public static _Fields findByThriftId(int fieldId) {
29807 return byId.get(fieldId);
29808 }
29809
29810
29811
29812
29813
29814 public static _Fields findByThriftIdOrThrow(int fieldId) {
29815 _Fields fields = findByThriftId(fieldId);
29816 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29817 return fields;
29818 }
29819
29820
29821
29822
29823 public static _Fields findByName(String name) {
29824 return byName.get(name);
29825 }
29826
29827 private final short _thriftId;
29828 private final String _fieldName;
29829
29830 _Fields(short thriftId, String fieldName) {
29831 _thriftId = thriftId;
29832 _fieldName = fieldName;
29833 }
29834
29835 public short getThriftFieldId() {
29836 return _thriftId;
29837 }
29838
29839 public String getFieldName() {
29840 return _fieldName;
29841 }
29842 }
29843
29844
29845 private static final int __ID_ISSET_ID = 0;
29846 private static final int __NBROWS_ISSET_ID = 1;
29847 private BitSet __isset_bit_vector = new BitSet(2);
29848
29849 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29850 put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
29851 new FieldValueMetaData(TType.I32)));
29852 put(_Fields.NB_ROWS, new FieldMetaData("nbRows", TFieldRequirementType.DEFAULT,
29853 new FieldValueMetaData(TType.I32)));
29854 }});
29855
29856 static {
29857 FieldMetaData.addStructMetaDataMap(scannerGetList_args.class, metaDataMap);
29858 }
29859
29860 public scannerGetList_args() {
29861 }
29862
29863 public scannerGetList_args(
29864 int id,
29865 int nbRows)
29866 {
29867 this();
29868 this.id = id;
29869 setIdIsSet(true);
29870 this.nbRows = nbRows;
29871 setNbRowsIsSet(true);
29872 }
29873
29874
29875
29876
29877 public scannerGetList_args(scannerGetList_args other) {
29878 __isset_bit_vector.clear();
29879 __isset_bit_vector.or(other.__isset_bit_vector);
29880 this.id = other.id;
29881 this.nbRows = other.nbRows;
29882 }
29883
29884 public scannerGetList_args deepCopy() {
29885 return new scannerGetList_args(this);
29886 }
29887
29888 @Deprecated
29889 public scannerGetList_args clone() {
29890 return new scannerGetList_args(this);
29891 }
29892
29893
29894
29895
29896 public int getId() {
29897 return this.id;
29898 }
29899
29900
29901
29902
29903 public scannerGetList_args setId(int id) {
29904 this.id = id;
29905 setIdIsSet(true);
29906 return this;
29907 }
29908
29909 public void unsetId() {
29910 __isset_bit_vector.clear(__ID_ISSET_ID);
29911 }
29912
29913
29914 public boolean isSetId() {
29915 return __isset_bit_vector.get(__ID_ISSET_ID);
29916 }
29917
29918 public void setIdIsSet(boolean value) {
29919 __isset_bit_vector.set(__ID_ISSET_ID, value);
29920 }
29921
29922
29923
29924
29925 public int getNbRows() {
29926 return this.nbRows;
29927 }
29928
29929
29930
29931
29932 public scannerGetList_args setNbRows(int nbRows) {
29933 this.nbRows = nbRows;
29934 setNbRowsIsSet(true);
29935 return this;
29936 }
29937
29938 public void unsetNbRows() {
29939 __isset_bit_vector.clear(__NBROWS_ISSET_ID);
29940 }
29941
29942
29943 public boolean isSetNbRows() {
29944 return __isset_bit_vector.get(__NBROWS_ISSET_ID);
29945 }
29946
29947 public void setNbRowsIsSet(boolean value) {
29948 __isset_bit_vector.set(__NBROWS_ISSET_ID, value);
29949 }
29950
29951 public void setFieldValue(_Fields field, Object value) {
29952 switch (field) {
29953 case ID:
29954 if (value == null) {
29955 unsetId();
29956 } else {
29957 setId((Integer)value);
29958 }
29959 break;
29960
29961 case NB_ROWS:
29962 if (value == null) {
29963 unsetNbRows();
29964 } else {
29965 setNbRows((Integer)value);
29966 }
29967 break;
29968
29969 }
29970 }
29971
29972 public void setFieldValue(int fieldID, Object value) {
29973 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29974 }
29975
29976 public Object getFieldValue(_Fields field) {
29977 switch (field) {
29978 case ID:
29979 return new Integer(getId());
29980
29981 case NB_ROWS:
29982 return new Integer(getNbRows());
29983
29984 }
29985 throw new IllegalStateException();
29986 }
29987
29988 public Object getFieldValue(int fieldId) {
29989 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29990 }
29991
29992
29993 public boolean isSet(_Fields field) {
29994 switch (field) {
29995 case ID:
29996 return isSetId();
29997 case NB_ROWS:
29998 return isSetNbRows();
29999 }
30000 throw new IllegalStateException();
30001 }
30002
30003 public boolean isSet(int fieldID) {
30004 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30005 }
30006
30007 @Override
30008 public boolean equals(Object that) {
30009 if (that == null)
30010 return false;
30011 if (that instanceof scannerGetList_args)
30012 return this.equals((scannerGetList_args)that);
30013 return false;
30014 }
30015
30016 public boolean equals(scannerGetList_args that) {
30017 if (that == null)
30018 return false;
30019
30020 boolean this_present_id = true;
30021 boolean that_present_id = true;
30022 if (this_present_id || that_present_id) {
30023 if (!(this_present_id && that_present_id))
30024 return false;
30025 if (this.id != that.id)
30026 return false;
30027 }
30028
30029 boolean this_present_nbRows = true;
30030 boolean that_present_nbRows = true;
30031 if (this_present_nbRows || that_present_nbRows) {
30032 if (!(this_present_nbRows && that_present_nbRows))
30033 return false;
30034 if (this.nbRows != that.nbRows)
30035 return false;
30036 }
30037
30038 return true;
30039 }
30040
30041 @Override
30042 public int hashCode() {
30043 HashCodeBuilder builder = new HashCodeBuilder();
30044
30045 boolean present_id = true;
30046 builder.append(present_id);
30047 if (present_id)
30048 builder.append(id);
30049
30050 boolean present_nbRows = true;
30051 builder.append(present_nbRows);
30052 if (present_nbRows)
30053 builder.append(nbRows);
30054
30055 return builder.toHashCode();
30056 }
30057
30058 public int compareTo(scannerGetList_args other) {
30059 if (!getClass().equals(other.getClass())) {
30060 return getClass().getName().compareTo(other.getClass().getName());
30061 }
30062
30063 int lastComparison = 0;
30064 scannerGetList_args typedOther = (scannerGetList_args)other;
30065
30066 lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
30067 if (lastComparison != 0) {
30068 return lastComparison;
30069 }
30070 lastComparison = TBaseHelper.compareTo(id, typedOther.id);
30071 if (lastComparison != 0) {
30072 return lastComparison;
30073 }
30074 lastComparison = Boolean.valueOf(isSetNbRows()).compareTo(isSetNbRows());
30075 if (lastComparison != 0) {
30076 return lastComparison;
30077 }
30078 lastComparison = TBaseHelper.compareTo(nbRows, typedOther.nbRows);
30079 if (lastComparison != 0) {
30080 return lastComparison;
30081 }
30082 return 0;
30083 }
30084
30085 public void read(TProtocol iprot) throws TException {
30086 TField field;
30087 iprot.readStructBegin();
30088 while (true)
30089 {
30090 field = iprot.readFieldBegin();
30091 if (field.type == TType.STOP) {
30092 break;
30093 }
30094 _Fields fieldId = _Fields.findByThriftId(field.id);
30095 if (fieldId == null) {
30096 TProtocolUtil.skip(iprot, field.type);
30097 } else {
30098 switch (fieldId) {
30099 case ID:
30100 if (field.type == TType.I32) {
30101 this.id = iprot.readI32();
30102 setIdIsSet(true);
30103 } else {
30104 TProtocolUtil.skip(iprot, field.type);
30105 }
30106 break;
30107 case NB_ROWS:
30108 if (field.type == TType.I32) {
30109 this.nbRows = iprot.readI32();
30110 setNbRowsIsSet(true);
30111 } else {
30112 TProtocolUtil.skip(iprot, field.type);
30113 }
30114 break;
30115 }
30116 iprot.readFieldEnd();
30117 }
30118 }
30119 iprot.readStructEnd();
30120
30121
30122 validate();
30123 }
30124
30125 public void write(TProtocol oprot) throws TException {
30126 validate();
30127
30128 oprot.writeStructBegin(STRUCT_DESC);
30129 oprot.writeFieldBegin(ID_FIELD_DESC);
30130 oprot.writeI32(this.id);
30131 oprot.writeFieldEnd();
30132 oprot.writeFieldBegin(NB_ROWS_FIELD_DESC);
30133 oprot.writeI32(this.nbRows);
30134 oprot.writeFieldEnd();
30135 oprot.writeFieldStop();
30136 oprot.writeStructEnd();
30137 }
30138
30139 @Override
30140 public String toString() {
30141 StringBuilder sb = new StringBuilder("scannerGetList_args(");
30142 boolean first = true;
30143
30144 sb.append("id:");
30145 sb.append(this.id);
30146 first = false;
30147 if (!first) sb.append(", ");
30148 sb.append("nbRows:");
30149 sb.append(this.nbRows);
30150 first = false;
30151 sb.append(")");
30152 return sb.toString();
30153 }
30154
30155 public void validate() throws TException {
30156
30157 }
30158
30159 }
30160
30161 public static class scannerGetList_result implements TBase<scannerGetList_result._Fields>, java.io.Serializable, Cloneable {
30162 private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_result");
30163
30164 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
30165 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
30166 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
30167
30168 public List<TRowResult> success;
30169 public IOError io;
30170 public IllegalArgument ia;
30171
30172
30173 public enum _Fields implements TFieldIdEnum {
30174 SUCCESS((short)0, "success"),
30175 IO((short)1, "io"),
30176 IA((short)2, "ia");
30177
30178 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30179 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30180
30181 static {
30182 for (_Fields field : EnumSet.allOf(_Fields.class)) {
30183 byId.put((int)field._thriftId, field);
30184 byName.put(field.getFieldName(), field);
30185 }
30186 }
30187
30188
30189
30190
30191 public static _Fields findByThriftId(int fieldId) {
30192 return byId.get(fieldId);
30193 }
30194
30195
30196
30197
30198
30199 public static _Fields findByThriftIdOrThrow(int fieldId) {
30200 _Fields fields = findByThriftId(fieldId);
30201 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30202 return fields;
30203 }
30204
30205
30206
30207
30208 public static _Fields findByName(String name) {
30209 return byName.get(name);
30210 }
30211
30212 private final short _thriftId;
30213 private final String _fieldName;
30214
30215 _Fields(short thriftId, String fieldName) {
30216 _thriftId = thriftId;
30217 _fieldName = fieldName;
30218 }
30219
30220 public short getThriftFieldId() {
30221 return _thriftId;
30222 }
30223
30224 public String getFieldName() {
30225 return _fieldName;
30226 }
30227 }
30228
30229
30230
30231 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30232 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
30233 new ListMetaData(TType.LIST,
30234 new StructMetaData(TType.STRUCT, TRowResult.class))));
30235 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
30236 new FieldValueMetaData(TType.STRUCT)));
30237 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
30238 new FieldValueMetaData(TType.STRUCT)));
30239 }});
30240
30241 static {
30242 FieldMetaData.addStructMetaDataMap(scannerGetList_result.class, metaDataMap);
30243 }
30244
30245 public scannerGetList_result() {
30246 }
30247
30248 public scannerGetList_result(
30249 List<TRowResult> success,
30250 IOError io,
30251 IllegalArgument ia)
30252 {
30253 this();
30254 this.success = success;
30255 this.io = io;
30256 this.ia = ia;
30257 }
30258
30259
30260
30261
30262 public scannerGetList_result(scannerGetList_result other) {
30263 if (other.isSetSuccess()) {
30264 List<TRowResult> __this__success = new ArrayList<TRowResult>();
30265 for (TRowResult other_element : other.success) {
30266 __this__success.add(new TRowResult(other_element));
30267 }
30268 this.success = __this__success;
30269 }
30270 if (other.isSetIo()) {
30271 this.io = new IOError(other.io);
30272 }
30273 if (other.isSetIa()) {
30274 this.ia = new IllegalArgument(other.ia);
30275 }
30276 }
30277
30278 public scannerGetList_result deepCopy() {
30279 return new scannerGetList_result(this);
30280 }
30281
30282 @Deprecated
30283 public scannerGetList_result clone() {
30284 return new scannerGetList_result(this);
30285 }
30286
30287 public int getSuccessSize() {
30288 return (this.success == null) ? 0 : this.success.size();
30289 }
30290
30291 public java.util.Iterator<TRowResult> getSuccessIterator() {
30292 return (this.success == null) ? null : this.success.iterator();
30293 }
30294
30295 public void addToSuccess(TRowResult elem) {
30296 if (this.success == null) {
30297 this.success = new ArrayList<TRowResult>();
30298 }
30299 this.success.add(elem);
30300 }
30301
30302 public List<TRowResult> getSuccess() {
30303 return this.success;
30304 }
30305
30306 public scannerGetList_result setSuccess(List<TRowResult> success) {
30307 this.success = success;
30308 return this;
30309 }
30310
30311 public void unsetSuccess() {
30312 this.success = null;
30313 }
30314
30315
30316 public boolean isSetSuccess() {
30317 return this.success != null;
30318 }
30319
30320 public void setSuccessIsSet(boolean value) {
30321 if (!value) {
30322 this.success = null;
30323 }
30324 }
30325
30326 public IOError getIo() {
30327 return this.io;
30328 }
30329
30330 public scannerGetList_result setIo(IOError io) {
30331 this.io = io;
30332 return this;
30333 }
30334
30335 public void unsetIo() {
30336 this.io = null;
30337 }
30338
30339
30340 public boolean isSetIo() {
30341 return this.io != null;
30342 }
30343
30344 public void setIoIsSet(boolean value) {
30345 if (!value) {
30346 this.io = null;
30347 }
30348 }
30349
30350 public IllegalArgument getIa() {
30351 return this.ia;
30352 }
30353
30354 public scannerGetList_result setIa(IllegalArgument ia) {
30355 this.ia = ia;
30356 return this;
30357 }
30358
30359 public void unsetIa() {
30360 this.ia = null;
30361 }
30362
30363
30364 public boolean isSetIa() {
30365 return this.ia != null;
30366 }
30367
30368 public void setIaIsSet(boolean value) {
30369 if (!value) {
30370 this.ia = null;
30371 }
30372 }
30373
30374 public void setFieldValue(_Fields field, Object value) {
30375 switch (field) {
30376 case SUCCESS:
30377 if (value == null) {
30378 unsetSuccess();
30379 } else {
30380 setSuccess((List<TRowResult>)value);
30381 }
30382 break;
30383
30384 case IO:
30385 if (value == null) {
30386 unsetIo();
30387 } else {
30388 setIo((IOError)value);
30389 }
30390 break;
30391
30392 case IA:
30393 if (value == null) {
30394 unsetIa();
30395 } else {
30396 setIa((IllegalArgument)value);
30397 }
30398 break;
30399
30400 }
30401 }
30402
30403 public void setFieldValue(int fieldID, Object value) {
30404 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
30405 }
30406
30407 public Object getFieldValue(_Fields field) {
30408 switch (field) {
30409 case SUCCESS:
30410 return getSuccess();
30411
30412 case IO:
30413 return getIo();
30414
30415 case IA:
30416 return getIa();
30417
30418 }
30419 throw new IllegalStateException();
30420 }
30421
30422 public Object getFieldValue(int fieldId) {
30423 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
30424 }
30425
30426
30427 public boolean isSet(_Fields field) {
30428 switch (field) {
30429 case SUCCESS:
30430 return isSetSuccess();
30431 case IO:
30432 return isSetIo();
30433 case IA:
30434 return isSetIa();
30435 }
30436 throw new IllegalStateException();
30437 }
30438
30439 public boolean isSet(int fieldID) {
30440 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30441 }
30442
30443 @Override
30444 public boolean equals(Object that) {
30445 if (that == null)
30446 return false;
30447 if (that instanceof scannerGetList_result)
30448 return this.equals((scannerGetList_result)that);
30449 return false;
30450 }
30451
30452 public boolean equals(scannerGetList_result that) {
30453 if (that == null)
30454 return false;
30455
30456 boolean this_present_success = true && this.isSetSuccess();
30457 boolean that_present_success = true && that.isSetSuccess();
30458 if (this_present_success || that_present_success) {
30459 if (!(this_present_success && that_present_success))
30460 return false;
30461 if (!this.success.equals(that.success))
30462 return false;
30463 }
30464
30465 boolean this_present_io = true && this.isSetIo();
30466 boolean that_present_io = true && that.isSetIo();
30467 if (this_present_io || that_present_io) {
30468 if (!(this_present_io && that_present_io))
30469 return false;
30470 if (!this.io.equals(that.io))
30471 return false;
30472 }
30473
30474 boolean this_present_ia = true && this.isSetIa();
30475 boolean that_present_ia = true && that.isSetIa();
30476 if (this_present_ia || that_present_ia) {
30477 if (!(this_present_ia && that_present_ia))
30478 return false;
30479 if (!this.ia.equals(that.ia))
30480 return false;
30481 }
30482
30483 return true;
30484 }
30485
30486 @Override
30487 public int hashCode() {
30488 HashCodeBuilder builder = new HashCodeBuilder();
30489
30490 boolean present_success = true && (isSetSuccess());
30491 builder.append(present_success);
30492 if (present_success)
30493 builder.append(success);
30494
30495 boolean present_io = true && (isSetIo());
30496 builder.append(present_io);
30497 if (present_io)
30498 builder.append(io);
30499
30500 boolean present_ia = true && (isSetIa());
30501 builder.append(present_ia);
30502 if (present_ia)
30503 builder.append(ia);
30504
30505 return builder.toHashCode();
30506 }
30507
30508 public void read(TProtocol iprot) throws TException {
30509 TField field;
30510 iprot.readStructBegin();
30511 while (true)
30512 {
30513 field = iprot.readFieldBegin();
30514 if (field.type == TType.STOP) {
30515 break;
30516 }
30517 _Fields fieldId = _Fields.findByThriftId(field.id);
30518 if (fieldId == null) {
30519 TProtocolUtil.skip(iprot, field.type);
30520 } else {
30521 switch (fieldId) {
30522 case SUCCESS:
30523 if (field.type == TType.LIST) {
30524 {
30525 TList _list102 = iprot.readListBegin();
30526 this.success = new ArrayList<TRowResult>(_list102.size);
30527 for (int _i103 = 0; _i103 < _list102.size; ++_i103)
30528 {
30529 TRowResult _elem104;
30530 _elem104 = new TRowResult();
30531 _elem104.read(iprot);
30532 this.success.add(_elem104);
30533 }
30534 iprot.readListEnd();
30535 }
30536 } else {
30537 TProtocolUtil.skip(iprot, field.type);
30538 }
30539 break;
30540 case IO:
30541 if (field.type == TType.STRUCT) {
30542 this.io = new IOError();
30543 this.io.read(iprot);
30544 } else {
30545 TProtocolUtil.skip(iprot, field.type);
30546 }
30547 break;
30548 case IA:
30549 if (field.type == TType.STRUCT) {
30550 this.ia = new IllegalArgument();
30551 this.ia.read(iprot);
30552 } else {
30553 TProtocolUtil.skip(iprot, field.type);
30554 }
30555 break;
30556 }
30557 iprot.readFieldEnd();
30558 }
30559 }
30560 iprot.readStructEnd();
30561
30562
30563 validate();
30564 }
30565
30566 public void write(TProtocol oprot) throws TException {
30567 oprot.writeStructBegin(STRUCT_DESC);
30568
30569 if (this.isSetSuccess()) {
30570 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30571 {
30572 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
30573 for (TRowResult _iter105 : this.success)
30574 {
30575 _iter105.write(oprot);
30576 }
30577 oprot.writeListEnd();
30578 }
30579 oprot.writeFieldEnd();
30580 } else if (this.isSetIo()) {
30581 oprot.writeFieldBegin(IO_FIELD_DESC);
30582 this.io.write(oprot);
30583 oprot.writeFieldEnd();
30584 } else if (this.isSetIa()) {
30585 oprot.writeFieldBegin(IA_FIELD_DESC);
30586 this.ia.write(oprot);
30587 oprot.writeFieldEnd();
30588 }
30589 oprot.writeFieldStop();
30590 oprot.writeStructEnd();
30591 }
30592
30593 @Override
30594 public String toString() {
30595 StringBuilder sb = new StringBuilder("scannerGetList_result(");
30596 boolean first = true;
30597
30598 sb.append("success:");
30599 if (this.success == null) {
30600 sb.append("null");
30601 } else {
30602 sb.append(this.success);
30603 }
30604 first = false;
30605 if (!first) sb.append(", ");
30606 sb.append("io:");
30607 if (this.io == null) {
30608 sb.append("null");
30609 } else {
30610 sb.append(this.io);
30611 }
30612 first = false;
30613 if (!first) sb.append(", ");
30614 sb.append("ia:");
30615 if (this.ia == null) {
30616 sb.append("null");
30617 } else {
30618 sb.append(this.ia);
30619 }
30620 first = false;
30621 sb.append(")");
30622 return sb.toString();
30623 }
30624
30625 public void validate() throws TException {
30626
30627 }
30628
30629 }
30630
30631 public static class scannerClose_args implements TBase<scannerClose_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_args> {
30632 private static final TStruct STRUCT_DESC = new TStruct("scannerClose_args");
30633
30634 private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
30635
30636
30637
30638
30639 public int id;
30640
30641
30642 public enum _Fields implements TFieldIdEnum {
30643
30644
30645
30646 ID((short)1, "id");
30647
30648 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30649 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30650
30651 static {
30652 for (_Fields field : EnumSet.allOf(_Fields.class)) {
30653 byId.put((int)field._thriftId, field);
30654 byName.put(field.getFieldName(), field);
30655 }
30656 }
30657
30658
30659
30660
30661 public static _Fields findByThriftId(int fieldId) {
30662 return byId.get(fieldId);
30663 }
30664
30665
30666
30667
30668
30669 public static _Fields findByThriftIdOrThrow(int fieldId) {
30670 _Fields fields = findByThriftId(fieldId);
30671 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30672 return fields;
30673 }
30674
30675
30676
30677
30678 public static _Fields findByName(String name) {
30679 return byName.get(name);
30680 }
30681
30682 private final short _thriftId;
30683 private final String _fieldName;
30684
30685 _Fields(short thriftId, String fieldName) {
30686 _thriftId = thriftId;
30687 _fieldName = fieldName;
30688 }
30689
30690 public short getThriftFieldId() {
30691 return _thriftId;
30692 }
30693
30694 public String getFieldName() {
30695 return _fieldName;
30696 }
30697 }
30698
30699
30700 private static final int __ID_ISSET_ID = 0;
30701 private BitSet __isset_bit_vector = new BitSet(1);
30702
30703 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30704 put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
30705 new FieldValueMetaData(TType.I32)));
30706 }});
30707
30708 static {
30709 FieldMetaData.addStructMetaDataMap(scannerClose_args.class, metaDataMap);
30710 }
30711
30712 public scannerClose_args() {
30713 }
30714
30715 public scannerClose_args(
30716 int id)
30717 {
30718 this();
30719 this.id = id;
30720 setIdIsSet(true);
30721 }
30722
30723
30724
30725
30726 public scannerClose_args(scannerClose_args other) {
30727 __isset_bit_vector.clear();
30728 __isset_bit_vector.or(other.__isset_bit_vector);
30729 this.id = other.id;
30730 }
30731
30732 public scannerClose_args deepCopy() {
30733 return new scannerClose_args(this);
30734 }
30735
30736 @Deprecated
30737 public scannerClose_args clone() {
30738 return new scannerClose_args(this);
30739 }
30740
30741
30742
30743
30744 public int getId() {
30745 return this.id;
30746 }
30747
30748
30749
30750
30751 public scannerClose_args setId(int id) {
30752 this.id = id;
30753 setIdIsSet(true);
30754 return this;
30755 }
30756
30757 public void unsetId() {
30758 __isset_bit_vector.clear(__ID_ISSET_ID);
30759 }
30760
30761
30762 public boolean isSetId() {
30763 return __isset_bit_vector.get(__ID_ISSET_ID);
30764 }
30765
30766 public void setIdIsSet(boolean value) {
30767 __isset_bit_vector.set(__ID_ISSET_ID, value);
30768 }
30769
30770 public void setFieldValue(_Fields field, Object value) {
30771 switch (field) {
30772 case ID:
30773 if (value == null) {
30774 unsetId();
30775 } else {
30776 setId((Integer)value);
30777 }
30778 break;
30779
30780 }
30781 }
30782
30783 public void setFieldValue(int fieldID, Object value) {
30784 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
30785 }
30786
30787 public Object getFieldValue(_Fields field) {
30788 switch (field) {
30789 case ID:
30790 return new Integer(getId());
30791
30792 }
30793 throw new IllegalStateException();
30794 }
30795
30796 public Object getFieldValue(int fieldId) {
30797 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
30798 }
30799
30800
30801 public boolean isSet(_Fields field) {
30802 switch (field) {
30803 case ID:
30804 return isSetId();
30805 }
30806 throw new IllegalStateException();
30807 }
30808
30809 public boolean isSet(int fieldID) {
30810 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30811 }
30812
30813 @Override
30814 public boolean equals(Object that) {
30815 if (that == null)
30816 return false;
30817 if (that instanceof scannerClose_args)
30818 return this.equals((scannerClose_args)that);
30819 return false;
30820 }
30821
30822 public boolean equals(scannerClose_args that) {
30823 if (that == null)
30824 return false;
30825
30826 boolean this_present_id = true;
30827 boolean that_present_id = true;
30828 if (this_present_id || that_present_id) {
30829 if (!(this_present_id && that_present_id))
30830 return false;
30831 if (this.id != that.id)
30832 return false;
30833 }
30834
30835 return true;
30836 }
30837
30838 @Override
30839 public int hashCode() {
30840 HashCodeBuilder builder = new HashCodeBuilder();
30841
30842 boolean present_id = true;
30843 builder.append(present_id);
30844 if (present_id)
30845 builder.append(id);
30846
30847 return builder.toHashCode();
30848 }
30849
30850 public int compareTo(scannerClose_args other) {
30851 if (!getClass().equals(other.getClass())) {
30852 return getClass().getName().compareTo(other.getClass().getName());
30853 }
30854
30855 int lastComparison = 0;
30856 scannerClose_args typedOther = (scannerClose_args)other;
30857
30858 lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
30859 if (lastComparison != 0) {
30860 return lastComparison;
30861 }
30862 lastComparison = TBaseHelper.compareTo(id, typedOther.id);
30863 if (lastComparison != 0) {
30864 return lastComparison;
30865 }
30866 return 0;
30867 }
30868
30869 public void read(TProtocol iprot) throws TException {
30870 TField field;
30871 iprot.readStructBegin();
30872 while (true)
30873 {
30874 field = iprot.readFieldBegin();
30875 if (field.type == TType.STOP) {
30876 break;
30877 }
30878 _Fields fieldId = _Fields.findByThriftId(field.id);
30879 if (fieldId == null) {
30880 TProtocolUtil.skip(iprot, field.type);
30881 } else {
30882 switch (fieldId) {
30883 case ID:
30884 if (field.type == TType.I32) {
30885 this.id = iprot.readI32();
30886 setIdIsSet(true);
30887 } else {
30888 TProtocolUtil.skip(iprot, field.type);
30889 }
30890 break;
30891 }
30892 iprot.readFieldEnd();
30893 }
30894 }
30895 iprot.readStructEnd();
30896
30897
30898 validate();
30899 }
30900
30901 public void write(TProtocol oprot) throws TException {
30902 validate();
30903
30904 oprot.writeStructBegin(STRUCT_DESC);
30905 oprot.writeFieldBegin(ID_FIELD_DESC);
30906 oprot.writeI32(this.id);
30907 oprot.writeFieldEnd();
30908 oprot.writeFieldStop();
30909 oprot.writeStructEnd();
30910 }
30911
30912 @Override
30913 public String toString() {
30914 StringBuilder sb = new StringBuilder("scannerClose_args(");
30915 boolean first = true;
30916
30917 sb.append("id:");
30918 sb.append(this.id);
30919 first = false;
30920 sb.append(")");
30921 return sb.toString();
30922 }
30923
30924 public void validate() throws TException {
30925
30926 }
30927
30928 }
30929
30930 public static class scannerClose_result implements TBase<scannerClose_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_result> {
30931 private static final TStruct STRUCT_DESC = new TStruct("scannerClose_result");
30932
30933 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
30934 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
30935
30936 public IOError io;
30937 public IllegalArgument ia;
30938
30939
30940 public enum _Fields implements TFieldIdEnum {
30941 IO((short)1, "io"),
30942 IA((short)2, "ia");
30943
30944 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30945 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30946
30947 static {
30948 for (_Fields field : EnumSet.allOf(_Fields.class)) {
30949 byId.put((int)field._thriftId, field);
30950 byName.put(field.getFieldName(), field);
30951 }
30952 }
30953
30954
30955
30956
30957 public static _Fields findByThriftId(int fieldId) {
30958 return byId.get(fieldId);
30959 }
30960
30961
30962
30963
30964
30965 public static _Fields findByThriftIdOrThrow(int fieldId) {
30966 _Fields fields = findByThriftId(fieldId);
30967 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30968 return fields;
30969 }
30970
30971
30972
30973
30974 public static _Fields findByName(String name) {
30975 return byName.get(name);
30976 }
30977
30978 private final short _thriftId;
30979 private final String _fieldName;
30980
30981 _Fields(short thriftId, String fieldName) {
30982 _thriftId = thriftId;
30983 _fieldName = fieldName;
30984 }
30985
30986 public short getThriftFieldId() {
30987 return _thriftId;
30988 }
30989
30990 public String getFieldName() {
30991 return _fieldName;
30992 }
30993 }
30994
30995
30996
30997 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30998 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
30999 new FieldValueMetaData(TType.STRUCT)));
31000 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
31001 new FieldValueMetaData(TType.STRUCT)));
31002 }});
31003
31004 static {
31005 FieldMetaData.addStructMetaDataMap(scannerClose_result.class, metaDataMap);
31006 }
31007
31008 public scannerClose_result() {
31009 }
31010
31011 public scannerClose_result(
31012 IOError io,
31013 IllegalArgument ia)
31014 {
31015 this();
31016 this.io = io;
31017 this.ia = ia;
31018 }
31019
31020
31021
31022
31023 public scannerClose_result(scannerClose_result other) {
31024 if (other.isSetIo()) {
31025 this.io = new IOError(other.io);
31026 }
31027 if (other.isSetIa()) {
31028 this.ia = new IllegalArgument(other.ia);
31029 }
31030 }
31031
31032 public scannerClose_result deepCopy() {
31033 return new scannerClose_result(this);
31034 }
31035
31036 @Deprecated
31037 public scannerClose_result clone() {
31038 return new scannerClose_result(this);
31039 }
31040
31041 public IOError getIo() {
31042 return this.io;
31043 }
31044
31045 public scannerClose_result setIo(IOError io) {
31046 this.io = io;
31047 return this;
31048 }
31049
31050 public void unsetIo() {
31051 this.io = null;
31052 }
31053
31054
31055 public boolean isSetIo() {
31056 return this.io != null;
31057 }
31058
31059 public void setIoIsSet(boolean value) {
31060 if (!value) {
31061 this.io = null;
31062 }
31063 }
31064
31065 public IllegalArgument getIa() {
31066 return this.ia;
31067 }
31068
31069 public scannerClose_result setIa(IllegalArgument ia) {
31070 this.ia = ia;
31071 return this;
31072 }
31073
31074 public void unsetIa() {
31075 this.ia = null;
31076 }
31077
31078
31079 public boolean isSetIa() {
31080 return this.ia != null;
31081 }
31082
31083 public void setIaIsSet(boolean value) {
31084 if (!value) {
31085 this.ia = null;
31086 }
31087 }
31088
31089 public void setFieldValue(_Fields field, Object value) {
31090 switch (field) {
31091 case IO:
31092 if (value == null) {
31093 unsetIo();
31094 } else {
31095 setIo((IOError)value);
31096 }
31097 break;
31098
31099 case IA:
31100 if (value == null) {
31101 unsetIa();
31102 } else {
31103 setIa((IllegalArgument)value);
31104 }
31105 break;
31106
31107 }
31108 }
31109
31110 public void setFieldValue(int fieldID, Object value) {
31111 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
31112 }
31113
31114 public Object getFieldValue(_Fields field) {
31115 switch (field) {
31116 case IO:
31117 return getIo();
31118
31119 case IA:
31120 return getIa();
31121
31122 }
31123 throw new IllegalStateException();
31124 }
31125
31126 public Object getFieldValue(int fieldId) {
31127 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
31128 }
31129
31130
31131 public boolean isSet(_Fields field) {
31132 switch (field) {
31133 case IO:
31134 return isSetIo();
31135 case IA:
31136 return isSetIa();
31137 }
31138 throw new IllegalStateException();
31139 }
31140
31141 public boolean isSet(int fieldID) {
31142 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
31143 }
31144
31145 @Override
31146 public boolean equals(Object that) {
31147 if (that == null)
31148 return false;
31149 if (that instanceof scannerClose_result)
31150 return this.equals((scannerClose_result)that);
31151 return false;
31152 }
31153
31154 public boolean equals(scannerClose_result that) {
31155 if (that == null)
31156 return false;
31157
31158 boolean this_present_io = true && this.isSetIo();
31159 boolean that_present_io = true && that.isSetIo();
31160 if (this_present_io || that_present_io) {
31161 if (!(this_present_io && that_present_io))
31162 return false;
31163 if (!this.io.equals(that.io))
31164 return false;
31165 }
31166
31167 boolean this_present_ia = true && this.isSetIa();
31168 boolean that_present_ia = true && that.isSetIa();
31169 if (this_present_ia || that_present_ia) {
31170 if (!(this_present_ia && that_present_ia))
31171 return false;
31172 if (!this.ia.equals(that.ia))
31173 return false;
31174 }
31175
31176 return true;
31177 }
31178
31179 @Override
31180 public int hashCode() {
31181 HashCodeBuilder builder = new HashCodeBuilder();
31182
31183 boolean present_io = true && (isSetIo());
31184 builder.append(present_io);
31185 if (present_io)
31186 builder.append(io);
31187
31188 boolean present_ia = true && (isSetIa());
31189 builder.append(present_ia);
31190 if (present_ia)
31191 builder.append(ia);
31192
31193 return builder.toHashCode();
31194 }
31195
31196 public int compareTo(scannerClose_result other) {
31197 if (!getClass().equals(other.getClass())) {
31198 return getClass().getName().compareTo(other.getClass().getName());
31199 }
31200
31201 int lastComparison = 0;
31202 scannerClose_result typedOther = (scannerClose_result)other;
31203
31204 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
31205 if (lastComparison != 0) {
31206 return lastComparison;
31207 }
31208 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
31209 if (lastComparison != 0) {
31210 return lastComparison;
31211 }
31212 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
31213 if (lastComparison != 0) {
31214 return lastComparison;
31215 }
31216 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
31217 if (lastComparison != 0) {
31218 return lastComparison;
31219 }
31220 return 0;
31221 }
31222
31223 public void read(TProtocol iprot) throws TException {
31224 TField field;
31225 iprot.readStructBegin();
31226 while (true)
31227 {
31228 field = iprot.readFieldBegin();
31229 if (field.type == TType.STOP) {
31230 break;
31231 }
31232 _Fields fieldId = _Fields.findByThriftId(field.id);
31233 if (fieldId == null) {
31234 TProtocolUtil.skip(iprot, field.type);
31235 } else {
31236 switch (fieldId) {
31237 case IO:
31238 if (field.type == TType.STRUCT) {
31239 this.io = new IOError();
31240 this.io.read(iprot);
31241 } else {
31242 TProtocolUtil.skip(iprot, field.type);
31243 }
31244 break;
31245 case IA:
31246 if (field.type == TType.STRUCT) {
31247 this.ia = new IllegalArgument();
31248 this.ia.read(iprot);
31249 } else {
31250 TProtocolUtil.skip(iprot, field.type);
31251 }
31252 break;
31253 }
31254 iprot.readFieldEnd();
31255 }
31256 }
31257 iprot.readStructEnd();
31258
31259
31260 validate();
31261 }
31262
31263 public void write(TProtocol oprot) throws TException {
31264 oprot.writeStructBegin(STRUCT_DESC);
31265
31266 if (this.isSetIo()) {
31267 oprot.writeFieldBegin(IO_FIELD_DESC);
31268 this.io.write(oprot);
31269 oprot.writeFieldEnd();
31270 } else if (this.isSetIa()) {
31271 oprot.writeFieldBegin(IA_FIELD_DESC);
31272 this.ia.write(oprot);
31273 oprot.writeFieldEnd();
31274 }
31275 oprot.writeFieldStop();
31276 oprot.writeStructEnd();
31277 }
31278
31279 @Override
31280 public String toString() {
31281 StringBuilder sb = new StringBuilder("scannerClose_result(");
31282 boolean first = true;
31283
31284 sb.append("io:");
31285 if (this.io == null) {
31286 sb.append("null");
31287 } else {
31288 sb.append(this.io);
31289 }
31290 first = false;
31291 if (!first) sb.append(", ");
31292 sb.append("ia:");
31293 if (this.ia == null) {
31294 sb.append("null");
31295 } else {
31296 sb.append(this.ia);
31297 }
31298 first = false;
31299 sb.append(")");
31300 return sb.toString();
31301 }
31302
31303 public void validate() throws TException {
31304
31305 }
31306
31307 }
31308
31309 }