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
74 public List<byte[]> getTableNames() throws IOError, TException;
75
76
77
78
79
80
81
82
83 public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException;
84
85
86
87
88
89
90
91
92 public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException;
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108 public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException;
109
110
111
112
113
114
115
116
117
118 public void deleteTable(byte[] tableName) throws IOError, TException;
119
120
121
122
123
124
125
126
127
128
129
130
131
132 public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148 public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException;
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167 public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException;
168
169
170
171
172
173
174
175
176
177
178
179 public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException;
180
181
182
183
184
185
186
187
188
189
190
191
192
193 public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException;
194
195
196
197
198
199
200
201
202
203
204
205
206
207 public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223 public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException;
224
225
226
227
228
229
230
231
232
233
234
235 public List<TRowResult> getRows(byte[] tableName, List<byte[]> rows) throws IOError, TException;
236
237
238
239
240
241
242
243
244
245
246
247
248
249 public List<TRowResult> getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns) throws IOError, TException;
250
251
252
253
254
255
256
257
258
259
260
261
262
263 public List<TRowResult> getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws IOError, TException;
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279 public List<TRowResult> getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp) throws IOError, TException;
280
281
282
283
284
285
286
287
288
289
290
291
292
293 public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException;
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309 public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException;
310
311
312
313
314
315
316
317
318
319
320
321 public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException;
322
323
324
325
326
327
328
329
330
331
332
333
334
335 public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException;
336
337
338
339
340
341
342
343
344
345
346
347
348 public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException;
349
350
351
352
353
354
355
356
357
358
359 public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
360
361
362
363
364
365
366
367
368
369
370
371
372
373 public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException;
374
375
376
377
378
379
380
381
382 public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException;
383
384
385
386
387
388
389
390
391
392
393
394 public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411 public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException;
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432 public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException;
433
434
435
436
437
438
439
440
441
442
443
444
445
446 public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException;
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466 public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException;
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490 public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException;
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506 public List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, TException;
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524 public List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException;
525
526
527
528
529
530
531
532
533 public void scannerClose(int id) throws IOError, IllegalArgument, TException;
534
535 }
536
537 public static class Client implements Iface {
538 public Client(TProtocol prot)
539 {
540 this(prot, prot);
541 }
542
543 public Client(TProtocol iprot, TProtocol oprot)
544 {
545 iprot_ = iprot;
546 oprot_ = oprot;
547 }
548
549 protected TProtocol iprot_;
550 protected TProtocol oprot_;
551
552 protected int seqid_;
553
554 public TProtocol getInputProtocol()
555 {
556 return this.iprot_;
557 }
558
559 public TProtocol getOutputProtocol()
560 {
561 return this.oprot_;
562 }
563
564 public void enableTable(byte[] tableName) throws IOError, TException
565 {
566 send_enableTable(tableName);
567 recv_enableTable();
568 }
569
570 public void send_enableTable(byte[] tableName) throws TException
571 {
572 oprot_.writeMessageBegin(new TMessage("enableTable", TMessageType.CALL, seqid_));
573 enableTable_args args = new enableTable_args();
574 args.tableName = tableName;
575 args.write(oprot_);
576 oprot_.writeMessageEnd();
577 oprot_.getTransport().flush();
578 }
579
580 public void recv_enableTable() throws IOError, TException
581 {
582 TMessage msg = iprot_.readMessageBegin();
583 if (msg.type == TMessageType.EXCEPTION) {
584 TApplicationException x = TApplicationException.read(iprot_);
585 iprot_.readMessageEnd();
586 throw x;
587 }
588 enableTable_result result = new enableTable_result();
589 result.read(iprot_);
590 iprot_.readMessageEnd();
591 if (result.io != null) {
592 throw result.io;
593 }
594 return;
595 }
596
597 public void disableTable(byte[] tableName) throws IOError, TException
598 {
599 send_disableTable(tableName);
600 recv_disableTable();
601 }
602
603 public void send_disableTable(byte[] tableName) throws TException
604 {
605 oprot_.writeMessageBegin(new TMessage("disableTable", TMessageType.CALL, seqid_));
606 disableTable_args args = new disableTable_args();
607 args.tableName = tableName;
608 args.write(oprot_);
609 oprot_.writeMessageEnd();
610 oprot_.getTransport().flush();
611 }
612
613 public void recv_disableTable() throws IOError, TException
614 {
615 TMessage msg = iprot_.readMessageBegin();
616 if (msg.type == TMessageType.EXCEPTION) {
617 TApplicationException x = TApplicationException.read(iprot_);
618 iprot_.readMessageEnd();
619 throw x;
620 }
621 disableTable_result result = new disableTable_result();
622 result.read(iprot_);
623 iprot_.readMessageEnd();
624 if (result.io != null) {
625 throw result.io;
626 }
627 return;
628 }
629
630 public boolean isTableEnabled(byte[] tableName) throws IOError, TException
631 {
632 send_isTableEnabled(tableName);
633 return recv_isTableEnabled();
634 }
635
636 public void send_isTableEnabled(byte[] tableName) throws TException
637 {
638 oprot_.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.CALL, seqid_));
639 isTableEnabled_args args = new isTableEnabled_args();
640 args.tableName = tableName;
641 args.write(oprot_);
642 oprot_.writeMessageEnd();
643 oprot_.getTransport().flush();
644 }
645
646 public boolean recv_isTableEnabled() throws IOError, TException
647 {
648 TMessage msg = iprot_.readMessageBegin();
649 if (msg.type == TMessageType.EXCEPTION) {
650 TApplicationException x = TApplicationException.read(iprot_);
651 iprot_.readMessageEnd();
652 throw x;
653 }
654 isTableEnabled_result result = new isTableEnabled_result();
655 result.read(iprot_);
656 iprot_.readMessageEnd();
657 if (result.isSetSuccess()) {
658 return result.success;
659 }
660 if (result.io != null) {
661 throw result.io;
662 }
663 throw new TApplicationException(TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result");
664 }
665
666 public void compact(byte[] tableNameOrRegionName) throws IOError, TException
667 {
668 send_compact(tableNameOrRegionName);
669 recv_compact();
670 }
671
672 public void send_compact(byte[] tableNameOrRegionName) throws TException
673 {
674 oprot_.writeMessageBegin(new TMessage("compact", TMessageType.CALL, seqid_));
675 compact_args args = new compact_args();
676 args.tableNameOrRegionName = tableNameOrRegionName;
677 args.write(oprot_);
678 oprot_.writeMessageEnd();
679 oprot_.getTransport().flush();
680 }
681
682 public void recv_compact() throws IOError, TException
683 {
684 TMessage msg = iprot_.readMessageBegin();
685 if (msg.type == TMessageType.EXCEPTION) {
686 TApplicationException x = TApplicationException.read(iprot_);
687 iprot_.readMessageEnd();
688 throw x;
689 }
690 compact_result result = new compact_result();
691 result.read(iprot_);
692 iprot_.readMessageEnd();
693 if (result.io != null) {
694 throw result.io;
695 }
696 return;
697 }
698
699 public void majorCompact(byte[] tableNameOrRegionName) throws IOError, TException
700 {
701 send_majorCompact(tableNameOrRegionName);
702 recv_majorCompact();
703 }
704
705 public void send_majorCompact(byte[] tableNameOrRegionName) throws TException
706 {
707 oprot_.writeMessageBegin(new TMessage("majorCompact", TMessageType.CALL, seqid_));
708 majorCompact_args args = new majorCompact_args();
709 args.tableNameOrRegionName = tableNameOrRegionName;
710 args.write(oprot_);
711 oprot_.writeMessageEnd();
712 oprot_.getTransport().flush();
713 }
714
715 public void recv_majorCompact() throws IOError, TException
716 {
717 TMessage msg = iprot_.readMessageBegin();
718 if (msg.type == TMessageType.EXCEPTION) {
719 TApplicationException x = TApplicationException.read(iprot_);
720 iprot_.readMessageEnd();
721 throw x;
722 }
723 majorCompact_result result = new majorCompact_result();
724 result.read(iprot_);
725 iprot_.readMessageEnd();
726 if (result.io != null) {
727 throw result.io;
728 }
729 return;
730 }
731
732 public List<byte[]> getTableNames() throws IOError, TException
733 {
734 send_getTableNames();
735 return recv_getTableNames();
736 }
737
738 public void send_getTableNames() throws TException
739 {
740 oprot_.writeMessageBegin(new TMessage("getTableNames", TMessageType.CALL, seqid_));
741 getTableNames_args args = new getTableNames_args();
742 args.write(oprot_);
743 oprot_.writeMessageEnd();
744 oprot_.getTransport().flush();
745 }
746
747 public List<byte[]> recv_getTableNames() throws IOError, TException
748 {
749 TMessage msg = iprot_.readMessageBegin();
750 if (msg.type == TMessageType.EXCEPTION) {
751 TApplicationException x = TApplicationException.read(iprot_);
752 iprot_.readMessageEnd();
753 throw x;
754 }
755 getTableNames_result result = new getTableNames_result();
756 result.read(iprot_);
757 iprot_.readMessageEnd();
758 if (result.isSetSuccess()) {
759 return result.success;
760 }
761 if (result.io != null) {
762 throw result.io;
763 }
764 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result");
765 }
766
767 public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException
768 {
769 send_getColumnDescriptors(tableName);
770 return recv_getColumnDescriptors();
771 }
772
773 public void send_getColumnDescriptors(byte[] tableName) throws TException
774 {
775 oprot_.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.CALL, seqid_));
776 getColumnDescriptors_args args = new getColumnDescriptors_args();
777 args.tableName = tableName;
778 args.write(oprot_);
779 oprot_.writeMessageEnd();
780 oprot_.getTransport().flush();
781 }
782
783 public Map<byte[],ColumnDescriptor> recv_getColumnDescriptors() throws IOError, TException
784 {
785 TMessage msg = iprot_.readMessageBegin();
786 if (msg.type == TMessageType.EXCEPTION) {
787 TApplicationException x = TApplicationException.read(iprot_);
788 iprot_.readMessageEnd();
789 throw x;
790 }
791 getColumnDescriptors_result result = new getColumnDescriptors_result();
792 result.read(iprot_);
793 iprot_.readMessageEnd();
794 if (result.isSetSuccess()) {
795 return result.success;
796 }
797 if (result.io != null) {
798 throw result.io;
799 }
800 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result");
801 }
802
803 public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException
804 {
805 send_getTableRegions(tableName);
806 return recv_getTableRegions();
807 }
808
809 public void send_getTableRegions(byte[] tableName) throws TException
810 {
811 oprot_.writeMessageBegin(new TMessage("getTableRegions", TMessageType.CALL, seqid_));
812 getTableRegions_args args = new getTableRegions_args();
813 args.tableName = tableName;
814 args.write(oprot_);
815 oprot_.writeMessageEnd();
816 oprot_.getTransport().flush();
817 }
818
819 public List<TRegionInfo> recv_getTableRegions() throws IOError, TException
820 {
821 TMessage msg = iprot_.readMessageBegin();
822 if (msg.type == TMessageType.EXCEPTION) {
823 TApplicationException x = TApplicationException.read(iprot_);
824 iprot_.readMessageEnd();
825 throw x;
826 }
827 getTableRegions_result result = new getTableRegions_result();
828 result.read(iprot_);
829 iprot_.readMessageEnd();
830 if (result.isSetSuccess()) {
831 return result.success;
832 }
833 if (result.io != null) {
834 throw result.io;
835 }
836 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result");
837 }
838
839 public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException
840 {
841 send_createTable(tableName, columnFamilies);
842 recv_createTable();
843 }
844
845 public void send_createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws TException
846 {
847 oprot_.writeMessageBegin(new TMessage("createTable", TMessageType.CALL, seqid_));
848 createTable_args args = new createTable_args();
849 args.tableName = tableName;
850 args.columnFamilies = columnFamilies;
851 args.write(oprot_);
852 oprot_.writeMessageEnd();
853 oprot_.getTransport().flush();
854 }
855
856 public void recv_createTable() throws IOError, IllegalArgument, AlreadyExists, TException
857 {
858 TMessage msg = iprot_.readMessageBegin();
859 if (msg.type == TMessageType.EXCEPTION) {
860 TApplicationException x = TApplicationException.read(iprot_);
861 iprot_.readMessageEnd();
862 throw x;
863 }
864 createTable_result result = new createTable_result();
865 result.read(iprot_);
866 iprot_.readMessageEnd();
867 if (result.io != null) {
868 throw result.io;
869 }
870 if (result.ia != null) {
871 throw result.ia;
872 }
873 if (result.exist != null) {
874 throw result.exist;
875 }
876 return;
877 }
878
879 public void deleteTable(byte[] tableName) throws IOError, TException
880 {
881 send_deleteTable(tableName);
882 recv_deleteTable();
883 }
884
885 public void send_deleteTable(byte[] tableName) throws TException
886 {
887 oprot_.writeMessageBegin(new TMessage("deleteTable", TMessageType.CALL, seqid_));
888 deleteTable_args args = new deleteTable_args();
889 args.tableName = tableName;
890 args.write(oprot_);
891 oprot_.writeMessageEnd();
892 oprot_.getTransport().flush();
893 }
894
895 public void recv_deleteTable() throws IOError, TException
896 {
897 TMessage msg = iprot_.readMessageBegin();
898 if (msg.type == TMessageType.EXCEPTION) {
899 TApplicationException x = TApplicationException.read(iprot_);
900 iprot_.readMessageEnd();
901 throw x;
902 }
903 deleteTable_result result = new deleteTable_result();
904 result.read(iprot_);
905 iprot_.readMessageEnd();
906 if (result.io != null) {
907 throw result.io;
908 }
909 return;
910 }
911
912 public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
913 {
914 send_get(tableName, row, column);
915 return recv_get();
916 }
917
918 public void send_get(byte[] tableName, byte[] row, byte[] column) throws TException
919 {
920 oprot_.writeMessageBegin(new TMessage("get", TMessageType.CALL, seqid_));
921 get_args args = new get_args();
922 args.tableName = tableName;
923 args.row = row;
924 args.column = column;
925 args.write(oprot_);
926 oprot_.writeMessageEnd();
927 oprot_.getTransport().flush();
928 }
929
930 public List<TCell> recv_get() throws IOError, TException
931 {
932 TMessage msg = iprot_.readMessageBegin();
933 if (msg.type == TMessageType.EXCEPTION) {
934 TApplicationException x = TApplicationException.read(iprot_);
935 iprot_.readMessageEnd();
936 throw x;
937 }
938 get_result result = new get_result();
939 result.read(iprot_);
940 iprot_.readMessageEnd();
941 if (result.isSetSuccess()) {
942 return result.success;
943 }
944 if (result.io != null) {
945 throw result.io;
946 }
947 throw new TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result");
948 }
949
950 public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException
951 {
952 send_getVer(tableName, row, column, numVersions);
953 return recv_getVer();
954 }
955
956 public void send_getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws TException
957 {
958 oprot_.writeMessageBegin(new TMessage("getVer", TMessageType.CALL, seqid_));
959 getVer_args args = new getVer_args();
960 args.tableName = tableName;
961 args.row = row;
962 args.column = column;
963 args.numVersions = numVersions;
964 args.write(oprot_);
965 oprot_.writeMessageEnd();
966 oprot_.getTransport().flush();
967 }
968
969 public List<TCell> recv_getVer() throws IOError, TException
970 {
971 TMessage msg = iprot_.readMessageBegin();
972 if (msg.type == TMessageType.EXCEPTION) {
973 TApplicationException x = TApplicationException.read(iprot_);
974 iprot_.readMessageEnd();
975 throw x;
976 }
977 getVer_result result = new getVer_result();
978 result.read(iprot_);
979 iprot_.readMessageEnd();
980 if (result.isSetSuccess()) {
981 return result.success;
982 }
983 if (result.io != null) {
984 throw result.io;
985 }
986 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVer failed: unknown result");
987 }
988
989 public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException
990 {
991 send_getVerTs(tableName, row, column, timestamp, numVersions);
992 return recv_getVerTs();
993 }
994
995 public void send_getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws TException
996 {
997 oprot_.writeMessageBegin(new TMessage("getVerTs", TMessageType.CALL, seqid_));
998 getVerTs_args args = new getVerTs_args();
999 args.tableName = tableName;
1000 args.row = row;
1001 args.column = column;
1002 args.timestamp = timestamp;
1003 args.numVersions = numVersions;
1004 args.write(oprot_);
1005 oprot_.writeMessageEnd();
1006 oprot_.getTransport().flush();
1007 }
1008
1009 public List<TCell> recv_getVerTs() throws IOError, TException
1010 {
1011 TMessage msg = iprot_.readMessageBegin();
1012 if (msg.type == TMessageType.EXCEPTION) {
1013 TApplicationException x = TApplicationException.read(iprot_);
1014 iprot_.readMessageEnd();
1015 throw x;
1016 }
1017 getVerTs_result result = new getVerTs_result();
1018 result.read(iprot_);
1019 iprot_.readMessageEnd();
1020 if (result.isSetSuccess()) {
1021 return result.success;
1022 }
1023 if (result.io != null) {
1024 throw result.io;
1025 }
1026 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result");
1027 }
1028
1029 public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException
1030 {
1031 send_getRow(tableName, row);
1032 return recv_getRow();
1033 }
1034
1035 public void send_getRow(byte[] tableName, byte[] row) throws TException
1036 {
1037 oprot_.writeMessageBegin(new TMessage("getRow", TMessageType.CALL, seqid_));
1038 getRow_args args = new getRow_args();
1039 args.tableName = tableName;
1040 args.row = row;
1041 args.write(oprot_);
1042 oprot_.writeMessageEnd();
1043 oprot_.getTransport().flush();
1044 }
1045
1046 public List<TRowResult> recv_getRow() throws IOError, TException
1047 {
1048 TMessage msg = iprot_.readMessageBegin();
1049 if (msg.type == TMessageType.EXCEPTION) {
1050 TApplicationException x = TApplicationException.read(iprot_);
1051 iprot_.readMessageEnd();
1052 throw x;
1053 }
1054 getRow_result result = new getRow_result();
1055 result.read(iprot_);
1056 iprot_.readMessageEnd();
1057 if (result.isSetSuccess()) {
1058 return result.success;
1059 }
1060 if (result.io != null) {
1061 throw result.io;
1062 }
1063 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRow failed: unknown result");
1064 }
1065
1066 public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException
1067 {
1068 send_getRowWithColumns(tableName, row, columns);
1069 return recv_getRowWithColumns();
1070 }
1071
1072 public void send_getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws TException
1073 {
1074 oprot_.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.CALL, seqid_));
1075 getRowWithColumns_args args = new getRowWithColumns_args();
1076 args.tableName = tableName;
1077 args.row = row;
1078 args.columns = columns;
1079 args.write(oprot_);
1080 oprot_.writeMessageEnd();
1081 oprot_.getTransport().flush();
1082 }
1083
1084 public List<TRowResult> recv_getRowWithColumns() throws IOError, TException
1085 {
1086 TMessage msg = iprot_.readMessageBegin();
1087 if (msg.type == TMessageType.EXCEPTION) {
1088 TApplicationException x = TApplicationException.read(iprot_);
1089 iprot_.readMessageEnd();
1090 throw x;
1091 }
1092 getRowWithColumns_result result = new getRowWithColumns_result();
1093 result.read(iprot_);
1094 iprot_.readMessageEnd();
1095 if (result.isSetSuccess()) {
1096 return result.success;
1097 }
1098 if (result.io != null) {
1099 throw result.io;
1100 }
1101 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result");
1102 }
1103
1104 public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
1105 {
1106 send_getRowTs(tableName, row, timestamp);
1107 return recv_getRowTs();
1108 }
1109
1110 public void send_getRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
1111 {
1112 oprot_.writeMessageBegin(new TMessage("getRowTs", TMessageType.CALL, seqid_));
1113 getRowTs_args args = new getRowTs_args();
1114 args.tableName = tableName;
1115 args.row = row;
1116 args.timestamp = timestamp;
1117 args.write(oprot_);
1118 oprot_.writeMessageEnd();
1119 oprot_.getTransport().flush();
1120 }
1121
1122 public List<TRowResult> recv_getRowTs() throws IOError, TException
1123 {
1124 TMessage msg = iprot_.readMessageBegin();
1125 if (msg.type == TMessageType.EXCEPTION) {
1126 TApplicationException x = TApplicationException.read(iprot_);
1127 iprot_.readMessageEnd();
1128 throw x;
1129 }
1130 getRowTs_result result = new getRowTs_result();
1131 result.read(iprot_);
1132 iprot_.readMessageEnd();
1133 if (result.isSetSuccess()) {
1134 return result.success;
1135 }
1136 if (result.io != null) {
1137 throw result.io;
1138 }
1139 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result");
1140 }
1141
1142 public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException
1143 {
1144 send_getRowWithColumnsTs(tableName, row, columns, timestamp);
1145 return recv_getRowWithColumnsTs();
1146 }
1147
1148 public void send_getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws TException
1149 {
1150 oprot_.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.CALL, seqid_));
1151 getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
1152 args.tableName = tableName;
1153 args.row = row;
1154 args.columns = columns;
1155 args.timestamp = timestamp;
1156 args.write(oprot_);
1157 oprot_.writeMessageEnd();
1158 oprot_.getTransport().flush();
1159 }
1160
1161 public List<TRowResult> recv_getRowWithColumnsTs() throws IOError, TException
1162 {
1163 TMessage msg = iprot_.readMessageBegin();
1164 if (msg.type == TMessageType.EXCEPTION) {
1165 TApplicationException x = TApplicationException.read(iprot_);
1166 iprot_.readMessageEnd();
1167 throw x;
1168 }
1169 getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
1170 result.read(iprot_);
1171 iprot_.readMessageEnd();
1172 if (result.isSetSuccess()) {
1173 return result.success;
1174 }
1175 if (result.io != null) {
1176 throw result.io;
1177 }
1178 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
1179 }
1180
1181 public List<TRowResult> getRows(byte[] tableName, List<byte[]> rows) throws IOError, TException
1182 {
1183 send_getRows(tableName, rows);
1184 return recv_getRows();
1185 }
1186
1187 public void send_getRows(byte[] tableName, List<byte[]> rows) throws TException
1188 {
1189 oprot_.writeMessageBegin(new TMessage("getRows", TMessageType.CALL, seqid_));
1190 getRows_args args = new getRows_args();
1191 args.tableName = tableName;
1192 args.rows = rows;
1193 args.write(oprot_);
1194 oprot_.writeMessageEnd();
1195 oprot_.getTransport().flush();
1196 }
1197
1198 public List<TRowResult> recv_getRows() throws IOError, TException
1199 {
1200 TMessage msg = iprot_.readMessageBegin();
1201 if (msg.type == TMessageType.EXCEPTION) {
1202 TApplicationException x = TApplicationException.read(iprot_);
1203 iprot_.readMessageEnd();
1204 throw x;
1205 }
1206 getRows_result result = new getRows_result();
1207 result.read(iprot_);
1208 iprot_.readMessageEnd();
1209 if (result.isSetSuccess()) {
1210 return result.success;
1211 }
1212 if (result.io != null) {
1213 throw result.io;
1214 }
1215 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRows failed: unknown result");
1216 }
1217
1218 public List<TRowResult> getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns) throws IOError, TException
1219 {
1220 send_getRowsWithColumns(tableName, rows, columns);
1221 return recv_getRowsWithColumns();
1222 }
1223
1224 public void send_getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns) throws TException
1225 {
1226 oprot_.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.CALL, seqid_));
1227 getRowsWithColumns_args args = new getRowsWithColumns_args();
1228 args.tableName = tableName;
1229 args.rows = rows;
1230 args.columns = columns;
1231 args.write(oprot_);
1232 oprot_.writeMessageEnd();
1233 oprot_.getTransport().flush();
1234 }
1235
1236 public List<TRowResult> recv_getRowsWithColumns() throws IOError, TException
1237 {
1238 TMessage msg = iprot_.readMessageBegin();
1239 if (msg.type == TMessageType.EXCEPTION) {
1240 TApplicationException x = TApplicationException.read(iprot_);
1241 iprot_.readMessageEnd();
1242 throw x;
1243 }
1244 getRowsWithColumns_result result = new getRowsWithColumns_result();
1245 result.read(iprot_);
1246 iprot_.readMessageEnd();
1247 if (result.isSetSuccess()) {
1248 return result.success;
1249 }
1250 if (result.io != null) {
1251 throw result.io;
1252 }
1253 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumns failed: unknown result");
1254 }
1255
1256 public List<TRowResult> getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws IOError, TException
1257 {
1258 send_getRowsTs(tableName, rows, timestamp);
1259 return recv_getRowsTs();
1260 }
1261
1262 public void send_getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws TException
1263 {
1264 oprot_.writeMessageBegin(new TMessage("getRowsTs", TMessageType.CALL, seqid_));
1265 getRowsTs_args args = new getRowsTs_args();
1266 args.tableName = tableName;
1267 args.rows = rows;
1268 args.timestamp = timestamp;
1269 args.write(oprot_);
1270 oprot_.writeMessageEnd();
1271 oprot_.getTransport().flush();
1272 }
1273
1274 public List<TRowResult> recv_getRowsTs() throws IOError, TException
1275 {
1276 TMessage msg = iprot_.readMessageBegin();
1277 if (msg.type == TMessageType.EXCEPTION) {
1278 TApplicationException x = TApplicationException.read(iprot_);
1279 iprot_.readMessageEnd();
1280 throw x;
1281 }
1282 getRowsTs_result result = new getRowsTs_result();
1283 result.read(iprot_);
1284 iprot_.readMessageEnd();
1285 if (result.isSetSuccess()) {
1286 return result.success;
1287 }
1288 if (result.io != null) {
1289 throw result.io;
1290 }
1291 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsTs failed: unknown result");
1292 }
1293
1294 public List<TRowResult> getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp) throws IOError, TException
1295 {
1296 send_getRowsWithColumnsTs(tableName, rows, columns, timestamp);
1297 return recv_getRowsWithColumnsTs();
1298 }
1299
1300 public void send_getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp) throws TException
1301 {
1302 oprot_.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.CALL, seqid_));
1303 getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args();
1304 args.tableName = tableName;
1305 args.rows = rows;
1306 args.columns = columns;
1307 args.timestamp = timestamp;
1308 args.write(oprot_);
1309 oprot_.writeMessageEnd();
1310 oprot_.getTransport().flush();
1311 }
1312
1313 public List<TRowResult> recv_getRowsWithColumnsTs() throws IOError, TException
1314 {
1315 TMessage msg = iprot_.readMessageBegin();
1316 if (msg.type == TMessageType.EXCEPTION) {
1317 TApplicationException x = TApplicationException.read(iprot_);
1318 iprot_.readMessageEnd();
1319 throw x;
1320 }
1321 getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
1322 result.read(iprot_);
1323 iprot_.readMessageEnd();
1324 if (result.isSetSuccess()) {
1325 return result.success;
1326 }
1327 if (result.io != null) {
1328 throw result.io;
1329 }
1330 throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result");
1331 }
1332
1333 public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException
1334 {
1335 send_mutateRow(tableName, row, mutations);
1336 recv_mutateRow();
1337 }
1338
1339 public void send_mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws TException
1340 {
1341 oprot_.writeMessageBegin(new TMessage("mutateRow", TMessageType.CALL, seqid_));
1342 mutateRow_args args = new mutateRow_args();
1343 args.tableName = tableName;
1344 args.row = row;
1345 args.mutations = mutations;
1346 args.write(oprot_);
1347 oprot_.writeMessageEnd();
1348 oprot_.getTransport().flush();
1349 }
1350
1351 public void recv_mutateRow() throws IOError, IllegalArgument, TException
1352 {
1353 TMessage msg = iprot_.readMessageBegin();
1354 if (msg.type == TMessageType.EXCEPTION) {
1355 TApplicationException x = TApplicationException.read(iprot_);
1356 iprot_.readMessageEnd();
1357 throw x;
1358 }
1359 mutateRow_result result = new mutateRow_result();
1360 result.read(iprot_);
1361 iprot_.readMessageEnd();
1362 if (result.io != null) {
1363 throw result.io;
1364 }
1365 if (result.ia != null) {
1366 throw result.ia;
1367 }
1368 return;
1369 }
1370
1371 public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException
1372 {
1373 send_mutateRowTs(tableName, row, mutations, timestamp);
1374 recv_mutateRowTs();
1375 }
1376
1377 public void send_mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws TException
1378 {
1379 oprot_.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.CALL, seqid_));
1380 mutateRowTs_args args = new mutateRowTs_args();
1381 args.tableName = tableName;
1382 args.row = row;
1383 args.mutations = mutations;
1384 args.timestamp = timestamp;
1385 args.write(oprot_);
1386 oprot_.writeMessageEnd();
1387 oprot_.getTransport().flush();
1388 }
1389
1390 public void recv_mutateRowTs() throws IOError, IllegalArgument, TException
1391 {
1392 TMessage msg = iprot_.readMessageBegin();
1393 if (msg.type == TMessageType.EXCEPTION) {
1394 TApplicationException x = TApplicationException.read(iprot_);
1395 iprot_.readMessageEnd();
1396 throw x;
1397 }
1398 mutateRowTs_result result = new mutateRowTs_result();
1399 result.read(iprot_);
1400 iprot_.readMessageEnd();
1401 if (result.io != null) {
1402 throw result.io;
1403 }
1404 if (result.ia != null) {
1405 throw result.ia;
1406 }
1407 return;
1408 }
1409
1410 public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException
1411 {
1412 send_mutateRows(tableName, rowBatches);
1413 recv_mutateRows();
1414 }
1415
1416 public void send_mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws TException
1417 {
1418 oprot_.writeMessageBegin(new TMessage("mutateRows", TMessageType.CALL, seqid_));
1419 mutateRows_args args = new mutateRows_args();
1420 args.tableName = tableName;
1421 args.rowBatches = rowBatches;
1422 args.write(oprot_);
1423 oprot_.writeMessageEnd();
1424 oprot_.getTransport().flush();
1425 }
1426
1427 public void recv_mutateRows() throws IOError, IllegalArgument, TException
1428 {
1429 TMessage msg = iprot_.readMessageBegin();
1430 if (msg.type == TMessageType.EXCEPTION) {
1431 TApplicationException x = TApplicationException.read(iprot_);
1432 iprot_.readMessageEnd();
1433 throw x;
1434 }
1435 mutateRows_result result = new mutateRows_result();
1436 result.read(iprot_);
1437 iprot_.readMessageEnd();
1438 if (result.io != null) {
1439 throw result.io;
1440 }
1441 if (result.ia != null) {
1442 throw result.ia;
1443 }
1444 return;
1445 }
1446
1447 public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException
1448 {
1449 send_mutateRowsTs(tableName, rowBatches, timestamp);
1450 recv_mutateRowsTs();
1451 }
1452
1453 public void send_mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws TException
1454 {
1455 oprot_.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.CALL, seqid_));
1456 mutateRowsTs_args args = new mutateRowsTs_args();
1457 args.tableName = tableName;
1458 args.rowBatches = rowBatches;
1459 args.timestamp = timestamp;
1460 args.write(oprot_);
1461 oprot_.writeMessageEnd();
1462 oprot_.getTransport().flush();
1463 }
1464
1465 public void recv_mutateRowsTs() throws IOError, IllegalArgument, TException
1466 {
1467 TMessage msg = iprot_.readMessageBegin();
1468 if (msg.type == TMessageType.EXCEPTION) {
1469 TApplicationException x = TApplicationException.read(iprot_);
1470 iprot_.readMessageEnd();
1471 throw x;
1472 }
1473 mutateRowsTs_result result = new mutateRowsTs_result();
1474 result.read(iprot_);
1475 iprot_.readMessageEnd();
1476 if (result.io != null) {
1477 throw result.io;
1478 }
1479 if (result.ia != null) {
1480 throw result.ia;
1481 }
1482 return;
1483 }
1484
1485 public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException
1486 {
1487 send_atomicIncrement(tableName, row, column, value);
1488 return recv_atomicIncrement();
1489 }
1490
1491 public void send_atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws TException
1492 {
1493 oprot_.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.CALL, seqid_));
1494 atomicIncrement_args args = new atomicIncrement_args();
1495 args.tableName = tableName;
1496 args.row = row;
1497 args.column = column;
1498 args.value = value;
1499 args.write(oprot_);
1500 oprot_.writeMessageEnd();
1501 oprot_.getTransport().flush();
1502 }
1503
1504 public long recv_atomicIncrement() throws IOError, IllegalArgument, TException
1505 {
1506 TMessage msg = iprot_.readMessageBegin();
1507 if (msg.type == TMessageType.EXCEPTION) {
1508 TApplicationException x = TApplicationException.read(iprot_);
1509 iprot_.readMessageEnd();
1510 throw x;
1511 }
1512 atomicIncrement_result result = new atomicIncrement_result();
1513 result.read(iprot_);
1514 iprot_.readMessageEnd();
1515 if (result.isSetSuccess()) {
1516 return result.success;
1517 }
1518 if (result.io != null) {
1519 throw result.io;
1520 }
1521 if (result.ia != null) {
1522 throw result.ia;
1523 }
1524 throw new TApplicationException(TApplicationException.MISSING_RESULT, "atomicIncrement failed: unknown result");
1525 }
1526
1527 public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
1528 {
1529 send_deleteAll(tableName, row, column);
1530 recv_deleteAll();
1531 }
1532
1533 public void send_deleteAll(byte[] tableName, byte[] row, byte[] column) throws TException
1534 {
1535 oprot_.writeMessageBegin(new TMessage("deleteAll", TMessageType.CALL, seqid_));
1536 deleteAll_args args = new deleteAll_args();
1537 args.tableName = tableName;
1538 args.row = row;
1539 args.column = column;
1540 args.write(oprot_);
1541 oprot_.writeMessageEnd();
1542 oprot_.getTransport().flush();
1543 }
1544
1545 public void recv_deleteAll() throws IOError, TException
1546 {
1547 TMessage msg = iprot_.readMessageBegin();
1548 if (msg.type == TMessageType.EXCEPTION) {
1549 TApplicationException x = TApplicationException.read(iprot_);
1550 iprot_.readMessageEnd();
1551 throw x;
1552 }
1553 deleteAll_result result = new deleteAll_result();
1554 result.read(iprot_);
1555 iprot_.readMessageEnd();
1556 if (result.io != null) {
1557 throw result.io;
1558 }
1559 return;
1560 }
1561
1562 public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException
1563 {
1564 send_deleteAllTs(tableName, row, column, timestamp);
1565 recv_deleteAllTs();
1566 }
1567
1568 public void send_deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws TException
1569 {
1570 oprot_.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.CALL, seqid_));
1571 deleteAllTs_args args = new deleteAllTs_args();
1572 args.tableName = tableName;
1573 args.row = row;
1574 args.column = column;
1575 args.timestamp = timestamp;
1576 args.write(oprot_);
1577 oprot_.writeMessageEnd();
1578 oprot_.getTransport().flush();
1579 }
1580
1581 public void recv_deleteAllTs() throws IOError, TException
1582 {
1583 TMessage msg = iprot_.readMessageBegin();
1584 if (msg.type == TMessageType.EXCEPTION) {
1585 TApplicationException x = TApplicationException.read(iprot_);
1586 iprot_.readMessageEnd();
1587 throw x;
1588 }
1589 deleteAllTs_result result = new deleteAllTs_result();
1590 result.read(iprot_);
1591 iprot_.readMessageEnd();
1592 if (result.io != null) {
1593 throw result.io;
1594 }
1595 return;
1596 }
1597
1598 public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException
1599 {
1600 send_deleteAllRow(tableName, row);
1601 recv_deleteAllRow();
1602 }
1603
1604 public void send_deleteAllRow(byte[] tableName, byte[] row) throws TException
1605 {
1606 oprot_.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.CALL, seqid_));
1607 deleteAllRow_args args = new deleteAllRow_args();
1608 args.tableName = tableName;
1609 args.row = row;
1610 args.write(oprot_);
1611 oprot_.writeMessageEnd();
1612 oprot_.getTransport().flush();
1613 }
1614
1615 public void recv_deleteAllRow() throws IOError, TException
1616 {
1617 TMessage msg = iprot_.readMessageBegin();
1618 if (msg.type == TMessageType.EXCEPTION) {
1619 TApplicationException x = TApplicationException.read(iprot_);
1620 iprot_.readMessageEnd();
1621 throw x;
1622 }
1623 deleteAllRow_result result = new deleteAllRow_result();
1624 result.read(iprot_);
1625 iprot_.readMessageEnd();
1626 if (result.io != null) {
1627 throw result.io;
1628 }
1629 return;
1630 }
1631
1632 public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
1633 {
1634 send_deleteAllRowTs(tableName, row, timestamp);
1635 recv_deleteAllRowTs();
1636 }
1637
1638 public void send_deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
1639 {
1640 oprot_.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.CALL, seqid_));
1641 deleteAllRowTs_args args = new deleteAllRowTs_args();
1642 args.tableName = tableName;
1643 args.row = row;
1644 args.timestamp = timestamp;
1645 args.write(oprot_);
1646 oprot_.writeMessageEnd();
1647 oprot_.getTransport().flush();
1648 }
1649
1650 public void recv_deleteAllRowTs() throws IOError, TException
1651 {
1652 TMessage msg = iprot_.readMessageBegin();
1653 if (msg.type == TMessageType.EXCEPTION) {
1654 TApplicationException x = TApplicationException.read(iprot_);
1655 iprot_.readMessageEnd();
1656 throw x;
1657 }
1658 deleteAllRowTs_result result = new deleteAllRowTs_result();
1659 result.read(iprot_);
1660 iprot_.readMessageEnd();
1661 if (result.io != null) {
1662 throw result.io;
1663 }
1664 return;
1665 }
1666
1667 public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException
1668 {
1669 send_scannerOpen(tableName, startRow, columns);
1670 return recv_scannerOpen();
1671 }
1672
1673 public void send_scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws TException
1674 {
1675 oprot_.writeMessageBegin(new TMessage("scannerOpen", TMessageType.CALL, seqid_));
1676 scannerOpen_args args = new scannerOpen_args();
1677 args.tableName = tableName;
1678 args.startRow = startRow;
1679 args.columns = columns;
1680 args.write(oprot_);
1681 oprot_.writeMessageEnd();
1682 oprot_.getTransport().flush();
1683 }
1684
1685 public int recv_scannerOpen() throws IOError, TException
1686 {
1687 TMessage msg = iprot_.readMessageBegin();
1688 if (msg.type == TMessageType.EXCEPTION) {
1689 TApplicationException x = TApplicationException.read(iprot_);
1690 iprot_.readMessageEnd();
1691 throw x;
1692 }
1693 scannerOpen_result result = new scannerOpen_result();
1694 result.read(iprot_);
1695 iprot_.readMessageEnd();
1696 if (result.isSetSuccess()) {
1697 return result.success;
1698 }
1699 if (result.io != null) {
1700 throw result.io;
1701 }
1702 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result");
1703 }
1704
1705 public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException
1706 {
1707 send_scannerOpenWithStop(tableName, startRow, stopRow, columns);
1708 return recv_scannerOpenWithStop();
1709 }
1710
1711 public void send_scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws TException
1712 {
1713 oprot_.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.CALL, seqid_));
1714 scannerOpenWithStop_args args = new scannerOpenWithStop_args();
1715 args.tableName = tableName;
1716 args.startRow = startRow;
1717 args.stopRow = stopRow;
1718 args.columns = columns;
1719 args.write(oprot_);
1720 oprot_.writeMessageEnd();
1721 oprot_.getTransport().flush();
1722 }
1723
1724 public int recv_scannerOpenWithStop() throws IOError, TException
1725 {
1726 TMessage msg = iprot_.readMessageBegin();
1727 if (msg.type == TMessageType.EXCEPTION) {
1728 TApplicationException x = TApplicationException.read(iprot_);
1729 iprot_.readMessageEnd();
1730 throw x;
1731 }
1732 scannerOpenWithStop_result result = new scannerOpenWithStop_result();
1733 result.read(iprot_);
1734 iprot_.readMessageEnd();
1735 if (result.isSetSuccess()) {
1736 return result.success;
1737 }
1738 if (result.io != null) {
1739 throw result.io;
1740 }
1741 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
1742 }
1743
1744 public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException
1745 {
1746 send_scannerOpenWithPrefix(tableName, startAndPrefix, columns);
1747 return recv_scannerOpenWithPrefix();
1748 }
1749
1750 public void send_scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws TException
1751 {
1752 oprot_.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.CALL, seqid_));
1753 scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
1754 args.tableName = tableName;
1755 args.startAndPrefix = startAndPrefix;
1756 args.columns = columns;
1757 args.write(oprot_);
1758 oprot_.writeMessageEnd();
1759 oprot_.getTransport().flush();
1760 }
1761
1762 public int recv_scannerOpenWithPrefix() throws IOError, TException
1763 {
1764 TMessage msg = iprot_.readMessageBegin();
1765 if (msg.type == TMessageType.EXCEPTION) {
1766 TApplicationException x = TApplicationException.read(iprot_);
1767 iprot_.readMessageEnd();
1768 throw x;
1769 }
1770 scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
1771 result.read(iprot_);
1772 iprot_.readMessageEnd();
1773 if (result.isSetSuccess()) {
1774 return result.success;
1775 }
1776 if (result.io != null) {
1777 throw result.io;
1778 }
1779 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
1780 }
1781
1782 public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException
1783 {
1784 send_scannerOpenTs(tableName, startRow, columns, timestamp);
1785 return recv_scannerOpenTs();
1786 }
1787
1788 public void send_scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws TException
1789 {
1790 oprot_.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.CALL, seqid_));
1791 scannerOpenTs_args args = new scannerOpenTs_args();
1792 args.tableName = tableName;
1793 args.startRow = startRow;
1794 args.columns = columns;
1795 args.timestamp = timestamp;
1796 args.write(oprot_);
1797 oprot_.writeMessageEnd();
1798 oprot_.getTransport().flush();
1799 }
1800
1801 public int recv_scannerOpenTs() throws IOError, TException
1802 {
1803 TMessage msg = iprot_.readMessageBegin();
1804 if (msg.type == TMessageType.EXCEPTION) {
1805 TApplicationException x = TApplicationException.read(iprot_);
1806 iprot_.readMessageEnd();
1807 throw x;
1808 }
1809 scannerOpenTs_result result = new scannerOpenTs_result();
1810 result.read(iprot_);
1811 iprot_.readMessageEnd();
1812 if (result.isSetSuccess()) {
1813 return result.success;
1814 }
1815 if (result.io != null) {
1816 throw result.io;
1817 }
1818 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result");
1819 }
1820
1821 public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException
1822 {
1823 send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
1824 return recv_scannerOpenWithStopTs();
1825 }
1826
1827 public void send_scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws TException
1828 {
1829 oprot_.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.CALL, seqid_));
1830 scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
1831 args.tableName = tableName;
1832 args.startRow = startRow;
1833 args.stopRow = stopRow;
1834 args.columns = columns;
1835 args.timestamp = timestamp;
1836 args.write(oprot_);
1837 oprot_.writeMessageEnd();
1838 oprot_.getTransport().flush();
1839 }
1840
1841 public int recv_scannerOpenWithStopTs() throws IOError, TException
1842 {
1843 TMessage msg = iprot_.readMessageBegin();
1844 if (msg.type == TMessageType.EXCEPTION) {
1845 TApplicationException x = TApplicationException.read(iprot_);
1846 iprot_.readMessageEnd();
1847 throw x;
1848 }
1849 scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
1850 result.read(iprot_);
1851 iprot_.readMessageEnd();
1852 if (result.isSetSuccess()) {
1853 return result.success;
1854 }
1855 if (result.io != null) {
1856 throw result.io;
1857 }
1858 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
1859 }
1860
1861 public List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, TException
1862 {
1863 send_scannerGet(id);
1864 return recv_scannerGet();
1865 }
1866
1867 public void send_scannerGet(int id) throws TException
1868 {
1869 oprot_.writeMessageBegin(new TMessage("scannerGet", TMessageType.CALL, seqid_));
1870 scannerGet_args args = new scannerGet_args();
1871 args.id = id;
1872 args.write(oprot_);
1873 oprot_.writeMessageEnd();
1874 oprot_.getTransport().flush();
1875 }
1876
1877 public List<TRowResult> recv_scannerGet() throws IOError, IllegalArgument, TException
1878 {
1879 TMessage msg = iprot_.readMessageBegin();
1880 if (msg.type == TMessageType.EXCEPTION) {
1881 TApplicationException x = TApplicationException.read(iprot_);
1882 iprot_.readMessageEnd();
1883 throw x;
1884 }
1885 scannerGet_result result = new scannerGet_result();
1886 result.read(iprot_);
1887 iprot_.readMessageEnd();
1888 if (result.isSetSuccess()) {
1889 return result.success;
1890 }
1891 if (result.io != null) {
1892 throw result.io;
1893 }
1894 if (result.ia != null) {
1895 throw result.ia;
1896 }
1897 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGet failed: unknown result");
1898 }
1899
1900 public List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException
1901 {
1902 send_scannerGetList(id, nbRows);
1903 return recv_scannerGetList();
1904 }
1905
1906 public void send_scannerGetList(int id, int nbRows) throws TException
1907 {
1908 oprot_.writeMessageBegin(new TMessage("scannerGetList", TMessageType.CALL, seqid_));
1909 scannerGetList_args args = new scannerGetList_args();
1910 args.id = id;
1911 args.nbRows = nbRows;
1912 args.write(oprot_);
1913 oprot_.writeMessageEnd();
1914 oprot_.getTransport().flush();
1915 }
1916
1917 public List<TRowResult> recv_scannerGetList() throws IOError, IllegalArgument, TException
1918 {
1919 TMessage msg = iprot_.readMessageBegin();
1920 if (msg.type == TMessageType.EXCEPTION) {
1921 TApplicationException x = TApplicationException.read(iprot_);
1922 iprot_.readMessageEnd();
1923 throw x;
1924 }
1925 scannerGetList_result result = new scannerGetList_result();
1926 result.read(iprot_);
1927 iprot_.readMessageEnd();
1928 if (result.isSetSuccess()) {
1929 return result.success;
1930 }
1931 if (result.io != null) {
1932 throw result.io;
1933 }
1934 if (result.ia != null) {
1935 throw result.ia;
1936 }
1937 throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGetList failed: unknown result");
1938 }
1939
1940 public void scannerClose(int id) throws IOError, IllegalArgument, TException
1941 {
1942 send_scannerClose(id);
1943 recv_scannerClose();
1944 }
1945
1946 public void send_scannerClose(int id) throws TException
1947 {
1948 oprot_.writeMessageBegin(new TMessage("scannerClose", TMessageType.CALL, seqid_));
1949 scannerClose_args args = new scannerClose_args();
1950 args.id = id;
1951 args.write(oprot_);
1952 oprot_.writeMessageEnd();
1953 oprot_.getTransport().flush();
1954 }
1955
1956 public void recv_scannerClose() throws IOError, IllegalArgument, TException
1957 {
1958 TMessage msg = iprot_.readMessageBegin();
1959 if (msg.type == TMessageType.EXCEPTION) {
1960 TApplicationException x = TApplicationException.read(iprot_);
1961 iprot_.readMessageEnd();
1962 throw x;
1963 }
1964 scannerClose_result result = new scannerClose_result();
1965 result.read(iprot_);
1966 iprot_.readMessageEnd();
1967 if (result.io != null) {
1968 throw result.io;
1969 }
1970 if (result.ia != null) {
1971 throw result.ia;
1972 }
1973 return;
1974 }
1975
1976 }
1977 public static class Processor implements TProcessor {
1978 private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1979 public Processor(Iface iface)
1980 {
1981 iface_ = iface;
1982 processMap_.put("enableTable", new enableTable());
1983 processMap_.put("disableTable", new disableTable());
1984 processMap_.put("isTableEnabled", new isTableEnabled());
1985 processMap_.put("compact", new compact());
1986 processMap_.put("majorCompact", new majorCompact());
1987 processMap_.put("getTableNames", new getTableNames());
1988 processMap_.put("getColumnDescriptors", new getColumnDescriptors());
1989 processMap_.put("getTableRegions", new getTableRegions());
1990 processMap_.put("createTable", new createTable());
1991 processMap_.put("deleteTable", new deleteTable());
1992 processMap_.put("get", new get());
1993 processMap_.put("getVer", new getVer());
1994 processMap_.put("getVerTs", new getVerTs());
1995 processMap_.put("getRow", new getRow());
1996 processMap_.put("getRowWithColumns", new getRowWithColumns());
1997 processMap_.put("getRowTs", new getRowTs());
1998 processMap_.put("getRowWithColumnsTs", new getRowWithColumnsTs());
1999 processMap_.put("getRows", new getRows());
2000 processMap_.put("getRowsWithColumns", new getRowsWithColumns());
2001 processMap_.put("getRowsTs", new getRowsTs());
2002 processMap_.put("getRowsWithColumnsTs", new getRowsWithColumnsTs());
2003 processMap_.put("mutateRow", new mutateRow());
2004 processMap_.put("mutateRowTs", new mutateRowTs());
2005 processMap_.put("mutateRows", new mutateRows());
2006 processMap_.put("mutateRowsTs", new mutateRowsTs());
2007 processMap_.put("atomicIncrement", new atomicIncrement());
2008 processMap_.put("deleteAll", new deleteAll());
2009 processMap_.put("deleteAllTs", new deleteAllTs());
2010 processMap_.put("deleteAllRow", new deleteAllRow());
2011 processMap_.put("deleteAllRowTs", new deleteAllRowTs());
2012 processMap_.put("scannerOpen", new scannerOpen());
2013 processMap_.put("scannerOpenWithStop", new scannerOpenWithStop());
2014 processMap_.put("scannerOpenWithPrefix", new scannerOpenWithPrefix());
2015 processMap_.put("scannerOpenTs", new scannerOpenTs());
2016 processMap_.put("scannerOpenWithStopTs", new scannerOpenWithStopTs());
2017 processMap_.put("scannerGet", new scannerGet());
2018 processMap_.put("scannerGetList", new scannerGetList());
2019 processMap_.put("scannerClose", new scannerClose());
2020 }
2021
2022 protected static interface ProcessFunction {
2023 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException;
2024 }
2025
2026 private Iface iface_;
2027 protected final HashMap<String,ProcessFunction> processMap_ = new HashMap<String,ProcessFunction>();
2028
2029 public boolean process(TProtocol iprot, TProtocol oprot) throws TException
2030 {
2031 TMessage msg = iprot.readMessageBegin();
2032 ProcessFunction fn = processMap_.get(msg.name);
2033 if (fn == null) {
2034 TProtocolUtil.skip(iprot, TType.STRUCT);
2035 iprot.readMessageEnd();
2036 TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'");
2037 oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));
2038 x.write(oprot);
2039 oprot.writeMessageEnd();
2040 oprot.getTransport().flush();
2041 return true;
2042 }
2043 fn.process(msg.seqid, iprot, oprot);
2044 return true;
2045 }
2046
2047 private class enableTable implements ProcessFunction {
2048 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2049 {
2050 enableTable_args args = new enableTable_args();
2051 args.read(iprot);
2052 iprot.readMessageEnd();
2053 enableTable_result result = new enableTable_result();
2054 try {
2055 iface_.enableTable(args.tableName);
2056 } catch (IOError io) {
2057 result.io = io;
2058 } catch (Throwable th) {
2059 LOGGER.error("Internal error processing enableTable", th);
2060 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing enableTable");
2061 oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.EXCEPTION, seqid));
2062 x.write(oprot);
2063 oprot.writeMessageEnd();
2064 oprot.getTransport().flush();
2065 return;
2066 }
2067 oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.REPLY, seqid));
2068 result.write(oprot);
2069 oprot.writeMessageEnd();
2070 oprot.getTransport().flush();
2071 }
2072
2073 }
2074
2075 private class disableTable implements ProcessFunction {
2076 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2077 {
2078 disableTable_args args = new disableTable_args();
2079 args.read(iprot);
2080 iprot.readMessageEnd();
2081 disableTable_result result = new disableTable_result();
2082 try {
2083 iface_.disableTable(args.tableName);
2084 } catch (IOError io) {
2085 result.io = io;
2086 } catch (Throwable th) {
2087 LOGGER.error("Internal error processing disableTable", th);
2088 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing disableTable");
2089 oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.EXCEPTION, seqid));
2090 x.write(oprot);
2091 oprot.writeMessageEnd();
2092 oprot.getTransport().flush();
2093 return;
2094 }
2095 oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.REPLY, seqid));
2096 result.write(oprot);
2097 oprot.writeMessageEnd();
2098 oprot.getTransport().flush();
2099 }
2100
2101 }
2102
2103 private class isTableEnabled implements ProcessFunction {
2104 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2105 {
2106 isTableEnabled_args args = new isTableEnabled_args();
2107 args.read(iprot);
2108 iprot.readMessageEnd();
2109 isTableEnabled_result result = new isTableEnabled_result();
2110 try {
2111 result.success = iface_.isTableEnabled(args.tableName);
2112 result.setSuccessIsSet(true);
2113 } catch (IOError io) {
2114 result.io = io;
2115 } catch (Throwable th) {
2116 LOGGER.error("Internal error processing isTableEnabled", th);
2117 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing isTableEnabled");
2118 oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.EXCEPTION, seqid));
2119 x.write(oprot);
2120 oprot.writeMessageEnd();
2121 oprot.getTransport().flush();
2122 return;
2123 }
2124 oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.REPLY, seqid));
2125 result.write(oprot);
2126 oprot.writeMessageEnd();
2127 oprot.getTransport().flush();
2128 }
2129
2130 }
2131
2132 private class compact implements ProcessFunction {
2133 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2134 {
2135 compact_args args = new compact_args();
2136 args.read(iprot);
2137 iprot.readMessageEnd();
2138 compact_result result = new compact_result();
2139 try {
2140 iface_.compact(args.tableNameOrRegionName);
2141 } catch (IOError io) {
2142 result.io = io;
2143 } catch (Throwable th) {
2144 LOGGER.error("Internal error processing compact", th);
2145 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing compact");
2146 oprot.writeMessageBegin(new TMessage("compact", TMessageType.EXCEPTION, seqid));
2147 x.write(oprot);
2148 oprot.writeMessageEnd();
2149 oprot.getTransport().flush();
2150 return;
2151 }
2152 oprot.writeMessageBegin(new TMessage("compact", TMessageType.REPLY, seqid));
2153 result.write(oprot);
2154 oprot.writeMessageEnd();
2155 oprot.getTransport().flush();
2156 }
2157
2158 }
2159
2160 private class majorCompact implements ProcessFunction {
2161 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2162 {
2163 majorCompact_args args = new majorCompact_args();
2164 args.read(iprot);
2165 iprot.readMessageEnd();
2166 majorCompact_result result = new majorCompact_result();
2167 try {
2168 iface_.majorCompact(args.tableNameOrRegionName);
2169 } catch (IOError io) {
2170 result.io = io;
2171 } catch (Throwable th) {
2172 LOGGER.error("Internal error processing majorCompact", th);
2173 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing majorCompact");
2174 oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.EXCEPTION, seqid));
2175 x.write(oprot);
2176 oprot.writeMessageEnd();
2177 oprot.getTransport().flush();
2178 return;
2179 }
2180 oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.REPLY, seqid));
2181 result.write(oprot);
2182 oprot.writeMessageEnd();
2183 oprot.getTransport().flush();
2184 }
2185
2186 }
2187
2188 private class getTableNames implements ProcessFunction {
2189 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2190 {
2191 getTableNames_args args = new getTableNames_args();
2192 args.read(iprot);
2193 iprot.readMessageEnd();
2194 getTableNames_result result = new getTableNames_result();
2195 try {
2196 result.success = iface_.getTableNames();
2197 } catch (IOError io) {
2198 result.io = io;
2199 } catch (Throwable th) {
2200 LOGGER.error("Internal error processing getTableNames", th);
2201 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableNames");
2202 oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.EXCEPTION, seqid));
2203 x.write(oprot);
2204 oprot.writeMessageEnd();
2205 oprot.getTransport().flush();
2206 return;
2207 }
2208 oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.REPLY, seqid));
2209 result.write(oprot);
2210 oprot.writeMessageEnd();
2211 oprot.getTransport().flush();
2212 }
2213
2214 }
2215
2216 private class getColumnDescriptors implements ProcessFunction {
2217 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2218 {
2219 getColumnDescriptors_args args = new getColumnDescriptors_args();
2220 args.read(iprot);
2221 iprot.readMessageEnd();
2222 getColumnDescriptors_result result = new getColumnDescriptors_result();
2223 try {
2224 result.success = iface_.getColumnDescriptors(args.tableName);
2225 } catch (IOError io) {
2226 result.io = io;
2227 } catch (Throwable th) {
2228 LOGGER.error("Internal error processing getColumnDescriptors", th);
2229 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getColumnDescriptors");
2230 oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.EXCEPTION, seqid));
2231 x.write(oprot);
2232 oprot.writeMessageEnd();
2233 oprot.getTransport().flush();
2234 return;
2235 }
2236 oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.REPLY, seqid));
2237 result.write(oprot);
2238 oprot.writeMessageEnd();
2239 oprot.getTransport().flush();
2240 }
2241
2242 }
2243
2244 private class getTableRegions implements ProcessFunction {
2245 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2246 {
2247 getTableRegions_args args = new getTableRegions_args();
2248 args.read(iprot);
2249 iprot.readMessageEnd();
2250 getTableRegions_result result = new getTableRegions_result();
2251 try {
2252 result.success = iface_.getTableRegions(args.tableName);
2253 } catch (IOError io) {
2254 result.io = io;
2255 } catch (Throwable th) {
2256 LOGGER.error("Internal error processing getTableRegions", th);
2257 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableRegions");
2258 oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.EXCEPTION, seqid));
2259 x.write(oprot);
2260 oprot.writeMessageEnd();
2261 oprot.getTransport().flush();
2262 return;
2263 }
2264 oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.REPLY, seqid));
2265 result.write(oprot);
2266 oprot.writeMessageEnd();
2267 oprot.getTransport().flush();
2268 }
2269
2270 }
2271
2272 private class createTable implements ProcessFunction {
2273 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2274 {
2275 createTable_args args = new createTable_args();
2276 args.read(iprot);
2277 iprot.readMessageEnd();
2278 createTable_result result = new createTable_result();
2279 try {
2280 iface_.createTable(args.tableName, args.columnFamilies);
2281 } catch (IOError io) {
2282 result.io = io;
2283 } catch (IllegalArgument ia) {
2284 result.ia = ia;
2285 } catch (AlreadyExists exist) {
2286 result.exist = exist;
2287 } catch (Throwable th) {
2288 LOGGER.error("Internal error processing createTable", th);
2289 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing createTable");
2290 oprot.writeMessageBegin(new TMessage("createTable", TMessageType.EXCEPTION, seqid));
2291 x.write(oprot);
2292 oprot.writeMessageEnd();
2293 oprot.getTransport().flush();
2294 return;
2295 }
2296 oprot.writeMessageBegin(new TMessage("createTable", TMessageType.REPLY, seqid));
2297 result.write(oprot);
2298 oprot.writeMessageEnd();
2299 oprot.getTransport().flush();
2300 }
2301
2302 }
2303
2304 private class deleteTable implements ProcessFunction {
2305 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2306 {
2307 deleteTable_args args = new deleteTable_args();
2308 args.read(iprot);
2309 iprot.readMessageEnd();
2310 deleteTable_result result = new deleteTable_result();
2311 try {
2312 iface_.deleteTable(args.tableName);
2313 } catch (IOError io) {
2314 result.io = io;
2315 } catch (Throwable th) {
2316 LOGGER.error("Internal error processing deleteTable", th);
2317 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteTable");
2318 oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.EXCEPTION, seqid));
2319 x.write(oprot);
2320 oprot.writeMessageEnd();
2321 oprot.getTransport().flush();
2322 return;
2323 }
2324 oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.REPLY, seqid));
2325 result.write(oprot);
2326 oprot.writeMessageEnd();
2327 oprot.getTransport().flush();
2328 }
2329
2330 }
2331
2332 private class get implements ProcessFunction {
2333 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2334 {
2335 get_args args = new get_args();
2336 args.read(iprot);
2337 iprot.readMessageEnd();
2338 get_result result = new get_result();
2339 try {
2340 result.success = iface_.get(args.tableName, args.row, args.column);
2341 } catch (IOError io) {
2342 result.io = io;
2343 } catch (Throwable th) {
2344 LOGGER.error("Internal error processing get", th);
2345 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing get");
2346 oprot.writeMessageBegin(new TMessage("get", TMessageType.EXCEPTION, seqid));
2347 x.write(oprot);
2348 oprot.writeMessageEnd();
2349 oprot.getTransport().flush();
2350 return;
2351 }
2352 oprot.writeMessageBegin(new TMessage("get", TMessageType.REPLY, seqid));
2353 result.write(oprot);
2354 oprot.writeMessageEnd();
2355 oprot.getTransport().flush();
2356 }
2357
2358 }
2359
2360 private class getVer implements ProcessFunction {
2361 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2362 {
2363 getVer_args args = new getVer_args();
2364 args.read(iprot);
2365 iprot.readMessageEnd();
2366 getVer_result result = new getVer_result();
2367 try {
2368 result.success = iface_.getVer(args.tableName, args.row, args.column, args.numVersions);
2369 } catch (IOError io) {
2370 result.io = io;
2371 } catch (Throwable th) {
2372 LOGGER.error("Internal error processing getVer", th);
2373 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVer");
2374 oprot.writeMessageBegin(new TMessage("getVer", TMessageType.EXCEPTION, seqid));
2375 x.write(oprot);
2376 oprot.writeMessageEnd();
2377 oprot.getTransport().flush();
2378 return;
2379 }
2380 oprot.writeMessageBegin(new TMessage("getVer", TMessageType.REPLY, seqid));
2381 result.write(oprot);
2382 oprot.writeMessageEnd();
2383 oprot.getTransport().flush();
2384 }
2385
2386 }
2387
2388 private class getVerTs implements ProcessFunction {
2389 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2390 {
2391 getVerTs_args args = new getVerTs_args();
2392 args.read(iprot);
2393 iprot.readMessageEnd();
2394 getVerTs_result result = new getVerTs_result();
2395 try {
2396 result.success = iface_.getVerTs(args.tableName, args.row, args.column, args.timestamp, args.numVersions);
2397 } catch (IOError io) {
2398 result.io = io;
2399 } catch (Throwable th) {
2400 LOGGER.error("Internal error processing getVerTs", th);
2401 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVerTs");
2402 oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.EXCEPTION, seqid));
2403 x.write(oprot);
2404 oprot.writeMessageEnd();
2405 oprot.getTransport().flush();
2406 return;
2407 }
2408 oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.REPLY, seqid));
2409 result.write(oprot);
2410 oprot.writeMessageEnd();
2411 oprot.getTransport().flush();
2412 }
2413
2414 }
2415
2416 private class getRow implements ProcessFunction {
2417 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2418 {
2419 getRow_args args = new getRow_args();
2420 args.read(iprot);
2421 iprot.readMessageEnd();
2422 getRow_result result = new getRow_result();
2423 try {
2424 result.success = iface_.getRow(args.tableName, args.row);
2425 } catch (IOError io) {
2426 result.io = io;
2427 } catch (Throwable th) {
2428 LOGGER.error("Internal error processing getRow", th);
2429 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRow");
2430 oprot.writeMessageBegin(new TMessage("getRow", TMessageType.EXCEPTION, seqid));
2431 x.write(oprot);
2432 oprot.writeMessageEnd();
2433 oprot.getTransport().flush();
2434 return;
2435 }
2436 oprot.writeMessageBegin(new TMessage("getRow", TMessageType.REPLY, seqid));
2437 result.write(oprot);
2438 oprot.writeMessageEnd();
2439 oprot.getTransport().flush();
2440 }
2441
2442 }
2443
2444 private class getRowWithColumns implements ProcessFunction {
2445 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2446 {
2447 getRowWithColumns_args args = new getRowWithColumns_args();
2448 args.read(iprot);
2449 iprot.readMessageEnd();
2450 getRowWithColumns_result result = new getRowWithColumns_result();
2451 try {
2452 result.success = iface_.getRowWithColumns(args.tableName, args.row, args.columns);
2453 } catch (IOError io) {
2454 result.io = io;
2455 } catch (Throwable th) {
2456 LOGGER.error("Internal error processing getRowWithColumns", th);
2457 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumns");
2458 oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.EXCEPTION, seqid));
2459 x.write(oprot);
2460 oprot.writeMessageEnd();
2461 oprot.getTransport().flush();
2462 return;
2463 }
2464 oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.REPLY, seqid));
2465 result.write(oprot);
2466 oprot.writeMessageEnd();
2467 oprot.getTransport().flush();
2468 }
2469
2470 }
2471
2472 private class getRowTs implements ProcessFunction {
2473 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2474 {
2475 getRowTs_args args = new getRowTs_args();
2476 args.read(iprot);
2477 iprot.readMessageEnd();
2478 getRowTs_result result = new getRowTs_result();
2479 try {
2480 result.success = iface_.getRowTs(args.tableName, args.row, args.timestamp);
2481 } catch (IOError io) {
2482 result.io = io;
2483 } catch (Throwable th) {
2484 LOGGER.error("Internal error processing getRowTs", th);
2485 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowTs");
2486 oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.EXCEPTION, seqid));
2487 x.write(oprot);
2488 oprot.writeMessageEnd();
2489 oprot.getTransport().flush();
2490 return;
2491 }
2492 oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.REPLY, seqid));
2493 result.write(oprot);
2494 oprot.writeMessageEnd();
2495 oprot.getTransport().flush();
2496 }
2497
2498 }
2499
2500 private class getRowWithColumnsTs implements ProcessFunction {
2501 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2502 {
2503 getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
2504 args.read(iprot);
2505 iprot.readMessageEnd();
2506 getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
2507 try {
2508 result.success = iface_.getRowWithColumnsTs(args.tableName, args.row, args.columns, args.timestamp);
2509 } catch (IOError io) {
2510 result.io = io;
2511 } catch (Throwable th) {
2512 LOGGER.error("Internal error processing getRowWithColumnsTs", th);
2513 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumnsTs");
2514 oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.EXCEPTION, seqid));
2515 x.write(oprot);
2516 oprot.writeMessageEnd();
2517 oprot.getTransport().flush();
2518 return;
2519 }
2520 oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.REPLY, seqid));
2521 result.write(oprot);
2522 oprot.writeMessageEnd();
2523 oprot.getTransport().flush();
2524 }
2525
2526 }
2527
2528 private class getRows implements ProcessFunction {
2529 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2530 {
2531 getRows_args args = new getRows_args();
2532 args.read(iprot);
2533 iprot.readMessageEnd();
2534 getRows_result result = new getRows_result();
2535 try {
2536 result.success = iface_.getRows(args.tableName, args.rows);
2537 } catch (IOError io) {
2538 result.io = io;
2539 } catch (Throwable th) {
2540 LOGGER.error("Internal error processing getRows", th);
2541 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRows");
2542 oprot.writeMessageBegin(new TMessage("getRows", TMessageType.EXCEPTION, seqid));
2543 x.write(oprot);
2544 oprot.writeMessageEnd();
2545 oprot.getTransport().flush();
2546 return;
2547 }
2548 oprot.writeMessageBegin(new TMessage("getRows", TMessageType.REPLY, seqid));
2549 result.write(oprot);
2550 oprot.writeMessageEnd();
2551 oprot.getTransport().flush();
2552 }
2553
2554 }
2555
2556 private class getRowsWithColumns implements ProcessFunction {
2557 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2558 {
2559 getRowsWithColumns_args args = new getRowsWithColumns_args();
2560 args.read(iprot);
2561 iprot.readMessageEnd();
2562 getRowsWithColumns_result result = new getRowsWithColumns_result();
2563 try {
2564 result.success = iface_.getRowsWithColumns(args.tableName, args.rows, args.columns);
2565 } catch (IOError io) {
2566 result.io = io;
2567 } catch (Throwable th) {
2568 LOGGER.error("Internal error processing getRowsWithColumns", th);
2569 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumns");
2570 oprot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.EXCEPTION, seqid));
2571 x.write(oprot);
2572 oprot.writeMessageEnd();
2573 oprot.getTransport().flush();
2574 return;
2575 }
2576 oprot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.REPLY, seqid));
2577 result.write(oprot);
2578 oprot.writeMessageEnd();
2579 oprot.getTransport().flush();
2580 }
2581
2582 }
2583
2584 private class getRowsTs implements ProcessFunction {
2585 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2586 {
2587 getRowsTs_args args = new getRowsTs_args();
2588 args.read(iprot);
2589 iprot.readMessageEnd();
2590 getRowsTs_result result = new getRowsTs_result();
2591 try {
2592 result.success = iface_.getRowsTs(args.tableName, args.rows, args.timestamp);
2593 } catch (IOError io) {
2594 result.io = io;
2595 } catch (Throwable th) {
2596 LOGGER.error("Internal error processing getRowsTs", th);
2597 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsTs");
2598 oprot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.EXCEPTION, seqid));
2599 x.write(oprot);
2600 oprot.writeMessageEnd();
2601 oprot.getTransport().flush();
2602 return;
2603 }
2604 oprot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.REPLY, seqid));
2605 result.write(oprot);
2606 oprot.writeMessageEnd();
2607 oprot.getTransport().flush();
2608 }
2609
2610 }
2611
2612 private class getRowsWithColumnsTs implements ProcessFunction {
2613 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2614 {
2615 getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args();
2616 args.read(iprot);
2617 iprot.readMessageEnd();
2618 getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
2619 try {
2620 result.success = iface_.getRowsWithColumnsTs(args.tableName, args.rows, args.columns, args.timestamp);
2621 } catch (IOError io) {
2622 result.io = io;
2623 } catch (Throwable th) {
2624 LOGGER.error("Internal error processing getRowsWithColumnsTs", th);
2625 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumnsTs");
2626 oprot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.EXCEPTION, seqid));
2627 x.write(oprot);
2628 oprot.writeMessageEnd();
2629 oprot.getTransport().flush();
2630 return;
2631 }
2632 oprot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.REPLY, seqid));
2633 result.write(oprot);
2634 oprot.writeMessageEnd();
2635 oprot.getTransport().flush();
2636 }
2637
2638 }
2639
2640 private class mutateRow implements ProcessFunction {
2641 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2642 {
2643 mutateRow_args args = new mutateRow_args();
2644 args.read(iprot);
2645 iprot.readMessageEnd();
2646 mutateRow_result result = new mutateRow_result();
2647 try {
2648 iface_.mutateRow(args.tableName, args.row, args.mutations);
2649 } catch (IOError io) {
2650 result.io = io;
2651 } catch (IllegalArgument ia) {
2652 result.ia = ia;
2653 } catch (Throwable th) {
2654 LOGGER.error("Internal error processing mutateRow", th);
2655 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRow");
2656 oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.EXCEPTION, seqid));
2657 x.write(oprot);
2658 oprot.writeMessageEnd();
2659 oprot.getTransport().flush();
2660 return;
2661 }
2662 oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.REPLY, seqid));
2663 result.write(oprot);
2664 oprot.writeMessageEnd();
2665 oprot.getTransport().flush();
2666 }
2667
2668 }
2669
2670 private class mutateRowTs implements ProcessFunction {
2671 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2672 {
2673 mutateRowTs_args args = new mutateRowTs_args();
2674 args.read(iprot);
2675 iprot.readMessageEnd();
2676 mutateRowTs_result result = new mutateRowTs_result();
2677 try {
2678 iface_.mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp);
2679 } catch (IOError io) {
2680 result.io = io;
2681 } catch (IllegalArgument ia) {
2682 result.ia = ia;
2683 } catch (Throwable th) {
2684 LOGGER.error("Internal error processing mutateRowTs", th);
2685 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowTs");
2686 oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.EXCEPTION, seqid));
2687 x.write(oprot);
2688 oprot.writeMessageEnd();
2689 oprot.getTransport().flush();
2690 return;
2691 }
2692 oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.REPLY, seqid));
2693 result.write(oprot);
2694 oprot.writeMessageEnd();
2695 oprot.getTransport().flush();
2696 }
2697
2698 }
2699
2700 private class mutateRows implements ProcessFunction {
2701 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2702 {
2703 mutateRows_args args = new mutateRows_args();
2704 args.read(iprot);
2705 iprot.readMessageEnd();
2706 mutateRows_result result = new mutateRows_result();
2707 try {
2708 iface_.mutateRows(args.tableName, args.rowBatches);
2709 } catch (IOError io) {
2710 result.io = io;
2711 } catch (IllegalArgument ia) {
2712 result.ia = ia;
2713 } catch (Throwable th) {
2714 LOGGER.error("Internal error processing mutateRows", th);
2715 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRows");
2716 oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.EXCEPTION, seqid));
2717 x.write(oprot);
2718 oprot.writeMessageEnd();
2719 oprot.getTransport().flush();
2720 return;
2721 }
2722 oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.REPLY, seqid));
2723 result.write(oprot);
2724 oprot.writeMessageEnd();
2725 oprot.getTransport().flush();
2726 }
2727
2728 }
2729
2730 private class mutateRowsTs implements ProcessFunction {
2731 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2732 {
2733 mutateRowsTs_args args = new mutateRowsTs_args();
2734 args.read(iprot);
2735 iprot.readMessageEnd();
2736 mutateRowsTs_result result = new mutateRowsTs_result();
2737 try {
2738 iface_.mutateRowsTs(args.tableName, args.rowBatches, args.timestamp);
2739 } catch (IOError io) {
2740 result.io = io;
2741 } catch (IllegalArgument ia) {
2742 result.ia = ia;
2743 } catch (Throwable th) {
2744 LOGGER.error("Internal error processing mutateRowsTs", th);
2745 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowsTs");
2746 oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.EXCEPTION, seqid));
2747 x.write(oprot);
2748 oprot.writeMessageEnd();
2749 oprot.getTransport().flush();
2750 return;
2751 }
2752 oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.REPLY, seqid));
2753 result.write(oprot);
2754 oprot.writeMessageEnd();
2755 oprot.getTransport().flush();
2756 }
2757
2758 }
2759
2760 private class atomicIncrement implements ProcessFunction {
2761 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2762 {
2763 atomicIncrement_args args = new atomicIncrement_args();
2764 args.read(iprot);
2765 iprot.readMessageEnd();
2766 atomicIncrement_result result = new atomicIncrement_result();
2767 try {
2768 result.success = iface_.atomicIncrement(args.tableName, args.row, args.column, args.value);
2769 result.setSuccessIsSet(true);
2770 } catch (IOError io) {
2771 result.io = io;
2772 } catch (IllegalArgument ia) {
2773 result.ia = ia;
2774 } catch (Throwable th) {
2775 LOGGER.error("Internal error processing atomicIncrement", th);
2776 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing atomicIncrement");
2777 oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.EXCEPTION, seqid));
2778 x.write(oprot);
2779 oprot.writeMessageEnd();
2780 oprot.getTransport().flush();
2781 return;
2782 }
2783 oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.REPLY, seqid));
2784 result.write(oprot);
2785 oprot.writeMessageEnd();
2786 oprot.getTransport().flush();
2787 }
2788
2789 }
2790
2791 private class deleteAll implements ProcessFunction {
2792 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2793 {
2794 deleteAll_args args = new deleteAll_args();
2795 args.read(iprot);
2796 iprot.readMessageEnd();
2797 deleteAll_result result = new deleteAll_result();
2798 try {
2799 iface_.deleteAll(args.tableName, args.row, args.column);
2800 } catch (IOError io) {
2801 result.io = io;
2802 } catch (Throwable th) {
2803 LOGGER.error("Internal error processing deleteAll", th);
2804 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAll");
2805 oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.EXCEPTION, seqid));
2806 x.write(oprot);
2807 oprot.writeMessageEnd();
2808 oprot.getTransport().flush();
2809 return;
2810 }
2811 oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.REPLY, seqid));
2812 result.write(oprot);
2813 oprot.writeMessageEnd();
2814 oprot.getTransport().flush();
2815 }
2816
2817 }
2818
2819 private class deleteAllTs implements ProcessFunction {
2820 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2821 {
2822 deleteAllTs_args args = new deleteAllTs_args();
2823 args.read(iprot);
2824 iprot.readMessageEnd();
2825 deleteAllTs_result result = new deleteAllTs_result();
2826 try {
2827 iface_.deleteAllTs(args.tableName, args.row, args.column, args.timestamp);
2828 } catch (IOError io) {
2829 result.io = io;
2830 } catch (Throwable th) {
2831 LOGGER.error("Internal error processing deleteAllTs", th);
2832 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllTs");
2833 oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.EXCEPTION, seqid));
2834 x.write(oprot);
2835 oprot.writeMessageEnd();
2836 oprot.getTransport().flush();
2837 return;
2838 }
2839 oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.REPLY, seqid));
2840 result.write(oprot);
2841 oprot.writeMessageEnd();
2842 oprot.getTransport().flush();
2843 }
2844
2845 }
2846
2847 private class deleteAllRow implements ProcessFunction {
2848 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2849 {
2850 deleteAllRow_args args = new deleteAllRow_args();
2851 args.read(iprot);
2852 iprot.readMessageEnd();
2853 deleteAllRow_result result = new deleteAllRow_result();
2854 try {
2855 iface_.deleteAllRow(args.tableName, args.row);
2856 } catch (IOError io) {
2857 result.io = io;
2858 } catch (Throwable th) {
2859 LOGGER.error("Internal error processing deleteAllRow", th);
2860 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRow");
2861 oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.EXCEPTION, seqid));
2862 x.write(oprot);
2863 oprot.writeMessageEnd();
2864 oprot.getTransport().flush();
2865 return;
2866 }
2867 oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.REPLY, seqid));
2868 result.write(oprot);
2869 oprot.writeMessageEnd();
2870 oprot.getTransport().flush();
2871 }
2872
2873 }
2874
2875 private class deleteAllRowTs implements ProcessFunction {
2876 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2877 {
2878 deleteAllRowTs_args args = new deleteAllRowTs_args();
2879 args.read(iprot);
2880 iprot.readMessageEnd();
2881 deleteAllRowTs_result result = new deleteAllRowTs_result();
2882 try {
2883 iface_.deleteAllRowTs(args.tableName, args.row, args.timestamp);
2884 } catch (IOError io) {
2885 result.io = io;
2886 } catch (Throwable th) {
2887 LOGGER.error("Internal error processing deleteAllRowTs", th);
2888 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRowTs");
2889 oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.EXCEPTION, seqid));
2890 x.write(oprot);
2891 oprot.writeMessageEnd();
2892 oprot.getTransport().flush();
2893 return;
2894 }
2895 oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.REPLY, seqid));
2896 result.write(oprot);
2897 oprot.writeMessageEnd();
2898 oprot.getTransport().flush();
2899 }
2900
2901 }
2902
2903 private class scannerOpen implements ProcessFunction {
2904 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2905 {
2906 scannerOpen_args args = new scannerOpen_args();
2907 args.read(iprot);
2908 iprot.readMessageEnd();
2909 scannerOpen_result result = new scannerOpen_result();
2910 try {
2911 result.success = iface_.scannerOpen(args.tableName, args.startRow, args.columns);
2912 result.setSuccessIsSet(true);
2913 } catch (IOError io) {
2914 result.io = io;
2915 } catch (Throwable th) {
2916 LOGGER.error("Internal error processing scannerOpen", th);
2917 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpen");
2918 oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.EXCEPTION, seqid));
2919 x.write(oprot);
2920 oprot.writeMessageEnd();
2921 oprot.getTransport().flush();
2922 return;
2923 }
2924 oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.REPLY, seqid));
2925 result.write(oprot);
2926 oprot.writeMessageEnd();
2927 oprot.getTransport().flush();
2928 }
2929
2930 }
2931
2932 private class scannerOpenWithStop implements ProcessFunction {
2933 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2934 {
2935 scannerOpenWithStop_args args = new scannerOpenWithStop_args();
2936 args.read(iprot);
2937 iprot.readMessageEnd();
2938 scannerOpenWithStop_result result = new scannerOpenWithStop_result();
2939 try {
2940 result.success = iface_.scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns);
2941 result.setSuccessIsSet(true);
2942 } catch (IOError io) {
2943 result.io = io;
2944 } catch (Throwable th) {
2945 LOGGER.error("Internal error processing scannerOpenWithStop", th);
2946 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStop");
2947 oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.EXCEPTION, seqid));
2948 x.write(oprot);
2949 oprot.writeMessageEnd();
2950 oprot.getTransport().flush();
2951 return;
2952 }
2953 oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.REPLY, seqid));
2954 result.write(oprot);
2955 oprot.writeMessageEnd();
2956 oprot.getTransport().flush();
2957 }
2958
2959 }
2960
2961 private class scannerOpenWithPrefix implements ProcessFunction {
2962 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2963 {
2964 scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
2965 args.read(iprot);
2966 iprot.readMessageEnd();
2967 scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
2968 try {
2969 result.success = iface_.scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns);
2970 result.setSuccessIsSet(true);
2971 } catch (IOError io) {
2972 result.io = io;
2973 } catch (Throwable th) {
2974 LOGGER.error("Internal error processing scannerOpenWithPrefix", th);
2975 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithPrefix");
2976 oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.EXCEPTION, seqid));
2977 x.write(oprot);
2978 oprot.writeMessageEnd();
2979 oprot.getTransport().flush();
2980 return;
2981 }
2982 oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.REPLY, seqid));
2983 result.write(oprot);
2984 oprot.writeMessageEnd();
2985 oprot.getTransport().flush();
2986 }
2987
2988 }
2989
2990 private class scannerOpenTs implements ProcessFunction {
2991 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2992 {
2993 scannerOpenTs_args args = new scannerOpenTs_args();
2994 args.read(iprot);
2995 iprot.readMessageEnd();
2996 scannerOpenTs_result result = new scannerOpenTs_result();
2997 try {
2998 result.success = iface_.scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp);
2999 result.setSuccessIsSet(true);
3000 } catch (IOError io) {
3001 result.io = io;
3002 } catch (Throwable th) {
3003 LOGGER.error("Internal error processing scannerOpenTs", th);
3004 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenTs");
3005 oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.EXCEPTION, seqid));
3006 x.write(oprot);
3007 oprot.writeMessageEnd();
3008 oprot.getTransport().flush();
3009 return;
3010 }
3011 oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.REPLY, seqid));
3012 result.write(oprot);
3013 oprot.writeMessageEnd();
3014 oprot.getTransport().flush();
3015 }
3016
3017 }
3018
3019 private class scannerOpenWithStopTs implements ProcessFunction {
3020 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
3021 {
3022 scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
3023 args.read(iprot);
3024 iprot.readMessageEnd();
3025 scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
3026 try {
3027 result.success = iface_.scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp);
3028 result.setSuccessIsSet(true);
3029 } catch (IOError io) {
3030 result.io = io;
3031 } catch (Throwable th) {
3032 LOGGER.error("Internal error processing scannerOpenWithStopTs", th);
3033 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStopTs");
3034 oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.EXCEPTION, seqid));
3035 x.write(oprot);
3036 oprot.writeMessageEnd();
3037 oprot.getTransport().flush();
3038 return;
3039 }
3040 oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.REPLY, seqid));
3041 result.write(oprot);
3042 oprot.writeMessageEnd();
3043 oprot.getTransport().flush();
3044 }
3045
3046 }
3047
3048 private class scannerGet implements ProcessFunction {
3049 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
3050 {
3051 scannerGet_args args = new scannerGet_args();
3052 args.read(iprot);
3053 iprot.readMessageEnd();
3054 scannerGet_result result = new scannerGet_result();
3055 try {
3056 result.success = iface_.scannerGet(args.id);
3057 } catch (IOError io) {
3058 result.io = io;
3059 } catch (IllegalArgument ia) {
3060 result.ia = ia;
3061 } catch (Throwable th) {
3062 LOGGER.error("Internal error processing scannerGet", th);
3063 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGet");
3064 oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.EXCEPTION, seqid));
3065 x.write(oprot);
3066 oprot.writeMessageEnd();
3067 oprot.getTransport().flush();
3068 return;
3069 }
3070 oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.REPLY, seqid));
3071 result.write(oprot);
3072 oprot.writeMessageEnd();
3073 oprot.getTransport().flush();
3074 }
3075
3076 }
3077
3078 private class scannerGetList implements ProcessFunction {
3079 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
3080 {
3081 scannerGetList_args args = new scannerGetList_args();
3082 args.read(iprot);
3083 iprot.readMessageEnd();
3084 scannerGetList_result result = new scannerGetList_result();
3085 try {
3086 result.success = iface_.scannerGetList(args.id, args.nbRows);
3087 } catch (IOError io) {
3088 result.io = io;
3089 } catch (IllegalArgument ia) {
3090 result.ia = ia;
3091 } catch (Throwable th) {
3092 LOGGER.error("Internal error processing scannerGetList", th);
3093 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGetList");
3094 oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.EXCEPTION, seqid));
3095 x.write(oprot);
3096 oprot.writeMessageEnd();
3097 oprot.getTransport().flush();
3098 return;
3099 }
3100 oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.REPLY, seqid));
3101 result.write(oprot);
3102 oprot.writeMessageEnd();
3103 oprot.getTransport().flush();
3104 }
3105
3106 }
3107
3108 private class scannerClose implements ProcessFunction {
3109 public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
3110 {
3111 scannerClose_args args = new scannerClose_args();
3112 args.read(iprot);
3113 iprot.readMessageEnd();
3114 scannerClose_result result = new scannerClose_result();
3115 try {
3116 iface_.scannerClose(args.id);
3117 } catch (IOError io) {
3118 result.io = io;
3119 } catch (IllegalArgument ia) {
3120 result.ia = ia;
3121 } catch (Throwable th) {
3122 LOGGER.error("Internal error processing scannerClose", th);
3123 TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerClose");
3124 oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.EXCEPTION, seqid));
3125 x.write(oprot);
3126 oprot.writeMessageEnd();
3127 oprot.getTransport().flush();
3128 return;
3129 }
3130 oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.REPLY, seqid));
3131 result.write(oprot);
3132 oprot.writeMessageEnd();
3133 oprot.getTransport().flush();
3134 }
3135
3136 }
3137
3138 }
3139
3140 public static class enableTable_args implements TBase<enableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_args> {
3141 private static final TStruct STRUCT_DESC = new TStruct("enableTable_args");
3142
3143 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
3144
3145
3146
3147
3148 public byte[] tableName;
3149
3150
3151 public enum _Fields implements TFieldIdEnum {
3152
3153
3154
3155 TABLE_NAME((short)1, "tableName");
3156
3157 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3158 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3159
3160 static {
3161 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3162 byId.put((int)field._thriftId, field);
3163 byName.put(field.getFieldName(), field);
3164 }
3165 }
3166
3167
3168
3169
3170 public static _Fields findByThriftId(int fieldId) {
3171 return byId.get(fieldId);
3172 }
3173
3174
3175
3176
3177
3178 public static _Fields findByThriftIdOrThrow(int fieldId) {
3179 _Fields fields = findByThriftId(fieldId);
3180 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3181 return fields;
3182 }
3183
3184
3185
3186
3187 public static _Fields findByName(String name) {
3188 return byName.get(name);
3189 }
3190
3191 private final short _thriftId;
3192 private final String _fieldName;
3193
3194 _Fields(short thriftId, String fieldName) {
3195 _thriftId = thriftId;
3196 _fieldName = fieldName;
3197 }
3198
3199 public short getThriftFieldId() {
3200 return _thriftId;
3201 }
3202
3203 public String getFieldName() {
3204 return _fieldName;
3205 }
3206 }
3207
3208
3209
3210 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3211 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
3212 new FieldValueMetaData(TType.STRING)));
3213 }});
3214
3215 static {
3216 FieldMetaData.addStructMetaDataMap(enableTable_args.class, metaDataMap);
3217 }
3218
3219 public enableTable_args() {
3220 }
3221
3222 public enableTable_args(
3223 byte[] tableName)
3224 {
3225 this();
3226 this.tableName = tableName;
3227 }
3228
3229
3230
3231
3232 public enableTable_args(enableTable_args other) {
3233 if (other.isSetTableName()) {
3234 this.tableName = other.tableName;
3235 }
3236 }
3237
3238 public enableTable_args deepCopy() {
3239 return new enableTable_args(this);
3240 }
3241
3242 @Deprecated
3243 public enableTable_args clone() {
3244 return new enableTable_args(this);
3245 }
3246
3247
3248
3249
3250 public byte[] getTableName() {
3251 return this.tableName;
3252 }
3253
3254
3255
3256
3257 public enableTable_args setTableName(byte[] tableName) {
3258 this.tableName = tableName;
3259 return this;
3260 }
3261
3262 public void unsetTableName() {
3263 this.tableName = null;
3264 }
3265
3266
3267 public boolean isSetTableName() {
3268 return this.tableName != null;
3269 }
3270
3271 public void setTableNameIsSet(boolean value) {
3272 if (!value) {
3273 this.tableName = null;
3274 }
3275 }
3276
3277 public void setFieldValue(_Fields field, Object value) {
3278 switch (field) {
3279 case TABLE_NAME:
3280 if (value == null) {
3281 unsetTableName();
3282 } else {
3283 setTableName((byte[])value);
3284 }
3285 break;
3286
3287 }
3288 }
3289
3290 public void setFieldValue(int fieldID, Object value) {
3291 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3292 }
3293
3294 public Object getFieldValue(_Fields field) {
3295 switch (field) {
3296 case TABLE_NAME:
3297 return getTableName();
3298
3299 }
3300 throw new IllegalStateException();
3301 }
3302
3303 public Object getFieldValue(int fieldId) {
3304 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3305 }
3306
3307
3308 public boolean isSet(_Fields field) {
3309 switch (field) {
3310 case TABLE_NAME:
3311 return isSetTableName();
3312 }
3313 throw new IllegalStateException();
3314 }
3315
3316 public boolean isSet(int fieldID) {
3317 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3318 }
3319
3320 @Override
3321 public boolean equals(Object that) {
3322 if (that == null)
3323 return false;
3324 if (that instanceof enableTable_args)
3325 return this.equals((enableTable_args)that);
3326 return false;
3327 }
3328
3329 public boolean equals(enableTable_args that) {
3330 if (that == null)
3331 return false;
3332
3333 boolean this_present_tableName = true && this.isSetTableName();
3334 boolean that_present_tableName = true && that.isSetTableName();
3335 if (this_present_tableName || that_present_tableName) {
3336 if (!(this_present_tableName && that_present_tableName))
3337 return false;
3338 if (!java.util.Arrays.equals(this.tableName, that.tableName))
3339 return false;
3340 }
3341
3342 return true;
3343 }
3344
3345 @Override
3346 public int hashCode() {
3347 HashCodeBuilder builder = new HashCodeBuilder();
3348
3349 boolean present_tableName = true && (isSetTableName());
3350 builder.append(present_tableName);
3351 if (present_tableName)
3352 builder.append(tableName);
3353
3354 return builder.toHashCode();
3355 }
3356
3357 public int compareTo(enableTable_args other) {
3358 if (!getClass().equals(other.getClass())) {
3359 return getClass().getName().compareTo(other.getClass().getName());
3360 }
3361
3362 int lastComparison = 0;
3363 enableTable_args typedOther = (enableTable_args)other;
3364
3365 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
3366 if (lastComparison != 0) {
3367 return lastComparison;
3368 }
3369 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
3370 if (lastComparison != 0) {
3371 return lastComparison;
3372 }
3373 return 0;
3374 }
3375
3376 public void read(TProtocol iprot) throws TException {
3377 TField field;
3378 iprot.readStructBegin();
3379 while (true)
3380 {
3381 field = iprot.readFieldBegin();
3382 if (field.type == TType.STOP) {
3383 break;
3384 }
3385 _Fields fieldId = _Fields.findByThriftId(field.id);
3386 if (fieldId == null) {
3387 TProtocolUtil.skip(iprot, field.type);
3388 } else {
3389 switch (fieldId) {
3390 case TABLE_NAME:
3391 if (field.type == TType.STRING) {
3392 this.tableName = iprot.readBinary();
3393 } else {
3394 TProtocolUtil.skip(iprot, field.type);
3395 }
3396 break;
3397 }
3398 iprot.readFieldEnd();
3399 }
3400 }
3401 iprot.readStructEnd();
3402
3403
3404 validate();
3405 }
3406
3407 public void write(TProtocol oprot) throws TException {
3408 validate();
3409
3410 oprot.writeStructBegin(STRUCT_DESC);
3411 if (this.tableName != null) {
3412 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
3413 oprot.writeBinary(this.tableName);
3414 oprot.writeFieldEnd();
3415 }
3416 oprot.writeFieldStop();
3417 oprot.writeStructEnd();
3418 }
3419
3420 @Override
3421 public String toString() {
3422 StringBuilder sb = new StringBuilder("enableTable_args(");
3423 boolean first = true;
3424
3425 sb.append("tableName:");
3426 if (this.tableName == null) {
3427 sb.append("null");
3428 } else {
3429 sb.append(this.tableName);
3430 }
3431 first = false;
3432 sb.append(")");
3433 return sb.toString();
3434 }
3435
3436 public void validate() throws TException {
3437
3438 }
3439
3440 }
3441
3442 public static class enableTable_result implements TBase<enableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_result> {
3443 private static final TStruct STRUCT_DESC = new TStruct("enableTable_result");
3444
3445 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
3446
3447 public IOError io;
3448
3449
3450 public enum _Fields implements TFieldIdEnum {
3451 IO((short)1, "io");
3452
3453 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3454 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3455
3456 static {
3457 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3458 byId.put((int)field._thriftId, field);
3459 byName.put(field.getFieldName(), field);
3460 }
3461 }
3462
3463
3464
3465
3466 public static _Fields findByThriftId(int fieldId) {
3467 return byId.get(fieldId);
3468 }
3469
3470
3471
3472
3473
3474 public static _Fields findByThriftIdOrThrow(int fieldId) {
3475 _Fields fields = findByThriftId(fieldId);
3476 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3477 return fields;
3478 }
3479
3480
3481
3482
3483 public static _Fields findByName(String name) {
3484 return byName.get(name);
3485 }
3486
3487 private final short _thriftId;
3488 private final String _fieldName;
3489
3490 _Fields(short thriftId, String fieldName) {
3491 _thriftId = thriftId;
3492 _fieldName = fieldName;
3493 }
3494
3495 public short getThriftFieldId() {
3496 return _thriftId;
3497 }
3498
3499 public String getFieldName() {
3500 return _fieldName;
3501 }
3502 }
3503
3504
3505
3506 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3507 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
3508 new FieldValueMetaData(TType.STRUCT)));
3509 }});
3510
3511 static {
3512 FieldMetaData.addStructMetaDataMap(enableTable_result.class, metaDataMap);
3513 }
3514
3515 public enableTable_result() {
3516 }
3517
3518 public enableTable_result(
3519 IOError io)
3520 {
3521 this();
3522 this.io = io;
3523 }
3524
3525
3526
3527
3528 public enableTable_result(enableTable_result other) {
3529 if (other.isSetIo()) {
3530 this.io = new IOError(other.io);
3531 }
3532 }
3533
3534 public enableTable_result deepCopy() {
3535 return new enableTable_result(this);
3536 }
3537
3538 @Deprecated
3539 public enableTable_result clone() {
3540 return new enableTable_result(this);
3541 }
3542
3543 public IOError getIo() {
3544 return this.io;
3545 }
3546
3547 public enableTable_result setIo(IOError io) {
3548 this.io = io;
3549 return this;
3550 }
3551
3552 public void unsetIo() {
3553 this.io = null;
3554 }
3555
3556
3557 public boolean isSetIo() {
3558 return this.io != null;
3559 }
3560
3561 public void setIoIsSet(boolean value) {
3562 if (!value) {
3563 this.io = null;
3564 }
3565 }
3566
3567 public void setFieldValue(_Fields field, Object value) {
3568 switch (field) {
3569 case IO:
3570 if (value == null) {
3571 unsetIo();
3572 } else {
3573 setIo((IOError)value);
3574 }
3575 break;
3576
3577 }
3578 }
3579
3580 public void setFieldValue(int fieldID, Object value) {
3581 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3582 }
3583
3584 public Object getFieldValue(_Fields field) {
3585 switch (field) {
3586 case IO:
3587 return getIo();
3588
3589 }
3590 throw new IllegalStateException();
3591 }
3592
3593 public Object getFieldValue(int fieldId) {
3594 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3595 }
3596
3597
3598 public boolean isSet(_Fields field) {
3599 switch (field) {
3600 case IO:
3601 return isSetIo();
3602 }
3603 throw new IllegalStateException();
3604 }
3605
3606 public boolean isSet(int fieldID) {
3607 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3608 }
3609
3610 @Override
3611 public boolean equals(Object that) {
3612 if (that == null)
3613 return false;
3614 if (that instanceof enableTable_result)
3615 return this.equals((enableTable_result)that);
3616 return false;
3617 }
3618
3619 public boolean equals(enableTable_result that) {
3620 if (that == null)
3621 return false;
3622
3623 boolean this_present_io = true && this.isSetIo();
3624 boolean that_present_io = true && that.isSetIo();
3625 if (this_present_io || that_present_io) {
3626 if (!(this_present_io && that_present_io))
3627 return false;
3628 if (!this.io.equals(that.io))
3629 return false;
3630 }
3631
3632 return true;
3633 }
3634
3635 @Override
3636 public int hashCode() {
3637 HashCodeBuilder builder = new HashCodeBuilder();
3638
3639 boolean present_io = true && (isSetIo());
3640 builder.append(present_io);
3641 if (present_io)
3642 builder.append(io);
3643
3644 return builder.toHashCode();
3645 }
3646
3647 public int compareTo(enableTable_result other) {
3648 if (!getClass().equals(other.getClass())) {
3649 return getClass().getName().compareTo(other.getClass().getName());
3650 }
3651
3652 int lastComparison = 0;
3653 enableTable_result typedOther = (enableTable_result)other;
3654
3655 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
3656 if (lastComparison != 0) {
3657 return lastComparison;
3658 }
3659 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
3660 if (lastComparison != 0) {
3661 return lastComparison;
3662 }
3663 return 0;
3664 }
3665
3666 public void read(TProtocol iprot) throws TException {
3667 TField field;
3668 iprot.readStructBegin();
3669 while (true)
3670 {
3671 field = iprot.readFieldBegin();
3672 if (field.type == TType.STOP) {
3673 break;
3674 }
3675 _Fields fieldId = _Fields.findByThriftId(field.id);
3676 if (fieldId == null) {
3677 TProtocolUtil.skip(iprot, field.type);
3678 } else {
3679 switch (fieldId) {
3680 case IO:
3681 if (field.type == TType.STRUCT) {
3682 this.io = new IOError();
3683 this.io.read(iprot);
3684 } else {
3685 TProtocolUtil.skip(iprot, field.type);
3686 }
3687 break;
3688 }
3689 iprot.readFieldEnd();
3690 }
3691 }
3692 iprot.readStructEnd();
3693
3694
3695 validate();
3696 }
3697
3698 public void write(TProtocol oprot) throws TException {
3699 oprot.writeStructBegin(STRUCT_DESC);
3700
3701 if (this.isSetIo()) {
3702 oprot.writeFieldBegin(IO_FIELD_DESC);
3703 this.io.write(oprot);
3704 oprot.writeFieldEnd();
3705 }
3706 oprot.writeFieldStop();
3707 oprot.writeStructEnd();
3708 }
3709
3710 @Override
3711 public String toString() {
3712 StringBuilder sb = new StringBuilder("enableTable_result(");
3713 boolean first = true;
3714
3715 sb.append("io:");
3716 if (this.io == null) {
3717 sb.append("null");
3718 } else {
3719 sb.append(this.io);
3720 }
3721 first = false;
3722 sb.append(")");
3723 return sb.toString();
3724 }
3725
3726 public void validate() throws TException {
3727
3728 }
3729
3730 }
3731
3732 public static class disableTable_args implements TBase<disableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_args> {
3733 private static final TStruct STRUCT_DESC = new TStruct("disableTable_args");
3734
3735 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
3736
3737
3738
3739
3740 public byte[] tableName;
3741
3742
3743 public enum _Fields implements TFieldIdEnum {
3744
3745
3746
3747 TABLE_NAME((short)1, "tableName");
3748
3749 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3750 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3751
3752 static {
3753 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3754 byId.put((int)field._thriftId, field);
3755 byName.put(field.getFieldName(), field);
3756 }
3757 }
3758
3759
3760
3761
3762 public static _Fields findByThriftId(int fieldId) {
3763 return byId.get(fieldId);
3764 }
3765
3766
3767
3768
3769
3770 public static _Fields findByThriftIdOrThrow(int fieldId) {
3771 _Fields fields = findByThriftId(fieldId);
3772 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3773 return fields;
3774 }
3775
3776
3777
3778
3779 public static _Fields findByName(String name) {
3780 return byName.get(name);
3781 }
3782
3783 private final short _thriftId;
3784 private final String _fieldName;
3785
3786 _Fields(short thriftId, String fieldName) {
3787 _thriftId = thriftId;
3788 _fieldName = fieldName;
3789 }
3790
3791 public short getThriftFieldId() {
3792 return _thriftId;
3793 }
3794
3795 public String getFieldName() {
3796 return _fieldName;
3797 }
3798 }
3799
3800
3801
3802 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3803 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
3804 new FieldValueMetaData(TType.STRING)));
3805 }});
3806
3807 static {
3808 FieldMetaData.addStructMetaDataMap(disableTable_args.class, metaDataMap);
3809 }
3810
3811 public disableTable_args() {
3812 }
3813
3814 public disableTable_args(
3815 byte[] tableName)
3816 {
3817 this();
3818 this.tableName = tableName;
3819 }
3820
3821
3822
3823
3824 public disableTable_args(disableTable_args other) {
3825 if (other.isSetTableName()) {
3826 this.tableName = other.tableName;
3827 }
3828 }
3829
3830 public disableTable_args deepCopy() {
3831 return new disableTable_args(this);
3832 }
3833
3834 @Deprecated
3835 public disableTable_args clone() {
3836 return new disableTable_args(this);
3837 }
3838
3839
3840
3841
3842 public byte[] getTableName() {
3843 return this.tableName;
3844 }
3845
3846
3847
3848
3849 public disableTable_args setTableName(byte[] tableName) {
3850 this.tableName = tableName;
3851 return this;
3852 }
3853
3854 public void unsetTableName() {
3855 this.tableName = null;
3856 }
3857
3858
3859 public boolean isSetTableName() {
3860 return this.tableName != null;
3861 }
3862
3863 public void setTableNameIsSet(boolean value) {
3864 if (!value) {
3865 this.tableName = null;
3866 }
3867 }
3868
3869 public void setFieldValue(_Fields field, Object value) {
3870 switch (field) {
3871 case TABLE_NAME:
3872 if (value == null) {
3873 unsetTableName();
3874 } else {
3875 setTableName((byte[])value);
3876 }
3877 break;
3878
3879 }
3880 }
3881
3882 public void setFieldValue(int fieldID, Object value) {
3883 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3884 }
3885
3886 public Object getFieldValue(_Fields field) {
3887 switch (field) {
3888 case TABLE_NAME:
3889 return getTableName();
3890
3891 }
3892 throw new IllegalStateException();
3893 }
3894
3895 public Object getFieldValue(int fieldId) {
3896 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3897 }
3898
3899
3900 public boolean isSet(_Fields field) {
3901 switch (field) {
3902 case TABLE_NAME:
3903 return isSetTableName();
3904 }
3905 throw new IllegalStateException();
3906 }
3907
3908 public boolean isSet(int fieldID) {
3909 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3910 }
3911
3912 @Override
3913 public boolean equals(Object that) {
3914 if (that == null)
3915 return false;
3916 if (that instanceof disableTable_args)
3917 return this.equals((disableTable_args)that);
3918 return false;
3919 }
3920
3921 public boolean equals(disableTable_args that) {
3922 if (that == null)
3923 return false;
3924
3925 boolean this_present_tableName = true && this.isSetTableName();
3926 boolean that_present_tableName = true && that.isSetTableName();
3927 if (this_present_tableName || that_present_tableName) {
3928 if (!(this_present_tableName && that_present_tableName))
3929 return false;
3930 if (!java.util.Arrays.equals(this.tableName, that.tableName))
3931 return false;
3932 }
3933
3934 return true;
3935 }
3936
3937 @Override
3938 public int hashCode() {
3939 HashCodeBuilder builder = new HashCodeBuilder();
3940
3941 boolean present_tableName = true && (isSetTableName());
3942 builder.append(present_tableName);
3943 if (present_tableName)
3944 builder.append(tableName);
3945
3946 return builder.toHashCode();
3947 }
3948
3949 public int compareTo(disableTable_args other) {
3950 if (!getClass().equals(other.getClass())) {
3951 return getClass().getName().compareTo(other.getClass().getName());
3952 }
3953
3954 int lastComparison = 0;
3955 disableTable_args typedOther = (disableTable_args)other;
3956
3957 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
3958 if (lastComparison != 0) {
3959 return lastComparison;
3960 }
3961 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
3962 if (lastComparison != 0) {
3963 return lastComparison;
3964 }
3965 return 0;
3966 }
3967
3968 public void read(TProtocol iprot) throws TException {
3969 TField field;
3970 iprot.readStructBegin();
3971 while (true)
3972 {
3973 field = iprot.readFieldBegin();
3974 if (field.type == TType.STOP) {
3975 break;
3976 }
3977 _Fields fieldId = _Fields.findByThriftId(field.id);
3978 if (fieldId == null) {
3979 TProtocolUtil.skip(iprot, field.type);
3980 } else {
3981 switch (fieldId) {
3982 case TABLE_NAME:
3983 if (field.type == TType.STRING) {
3984 this.tableName = iprot.readBinary();
3985 } else {
3986 TProtocolUtil.skip(iprot, field.type);
3987 }
3988 break;
3989 }
3990 iprot.readFieldEnd();
3991 }
3992 }
3993 iprot.readStructEnd();
3994
3995
3996 validate();
3997 }
3998
3999 public void write(TProtocol oprot) throws TException {
4000 validate();
4001
4002 oprot.writeStructBegin(STRUCT_DESC);
4003 if (this.tableName != null) {
4004 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
4005 oprot.writeBinary(this.tableName);
4006 oprot.writeFieldEnd();
4007 }
4008 oprot.writeFieldStop();
4009 oprot.writeStructEnd();
4010 }
4011
4012 @Override
4013 public String toString() {
4014 StringBuilder sb = new StringBuilder("disableTable_args(");
4015 boolean first = true;
4016
4017 sb.append("tableName:");
4018 if (this.tableName == null) {
4019 sb.append("null");
4020 } else {
4021 sb.append(this.tableName);
4022 }
4023 first = false;
4024 sb.append(")");
4025 return sb.toString();
4026 }
4027
4028 public void validate() throws TException {
4029
4030 }
4031
4032 }
4033
4034 public static class disableTable_result implements TBase<disableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_result> {
4035 private static final TStruct STRUCT_DESC = new TStruct("disableTable_result");
4036
4037 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
4038
4039 public IOError io;
4040
4041
4042 public enum _Fields implements TFieldIdEnum {
4043 IO((short)1, "io");
4044
4045 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4046 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4047
4048 static {
4049 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4050 byId.put((int)field._thriftId, field);
4051 byName.put(field.getFieldName(), field);
4052 }
4053 }
4054
4055
4056
4057
4058 public static _Fields findByThriftId(int fieldId) {
4059 return byId.get(fieldId);
4060 }
4061
4062
4063
4064
4065
4066 public static _Fields findByThriftIdOrThrow(int fieldId) {
4067 _Fields fields = findByThriftId(fieldId);
4068 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4069 return fields;
4070 }
4071
4072
4073
4074
4075 public static _Fields findByName(String name) {
4076 return byName.get(name);
4077 }
4078
4079 private final short _thriftId;
4080 private final String _fieldName;
4081
4082 _Fields(short thriftId, String fieldName) {
4083 _thriftId = thriftId;
4084 _fieldName = fieldName;
4085 }
4086
4087 public short getThriftFieldId() {
4088 return _thriftId;
4089 }
4090
4091 public String getFieldName() {
4092 return _fieldName;
4093 }
4094 }
4095
4096
4097
4098 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4099 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
4100 new FieldValueMetaData(TType.STRUCT)));
4101 }});
4102
4103 static {
4104 FieldMetaData.addStructMetaDataMap(disableTable_result.class, metaDataMap);
4105 }
4106
4107 public disableTable_result() {
4108 }
4109
4110 public disableTable_result(
4111 IOError io)
4112 {
4113 this();
4114 this.io = io;
4115 }
4116
4117
4118
4119
4120 public disableTable_result(disableTable_result other) {
4121 if (other.isSetIo()) {
4122 this.io = new IOError(other.io);
4123 }
4124 }
4125
4126 public disableTable_result deepCopy() {
4127 return new disableTable_result(this);
4128 }
4129
4130 @Deprecated
4131 public disableTable_result clone() {
4132 return new disableTable_result(this);
4133 }
4134
4135 public IOError getIo() {
4136 return this.io;
4137 }
4138
4139 public disableTable_result setIo(IOError io) {
4140 this.io = io;
4141 return this;
4142 }
4143
4144 public void unsetIo() {
4145 this.io = null;
4146 }
4147
4148
4149 public boolean isSetIo() {
4150 return this.io != null;
4151 }
4152
4153 public void setIoIsSet(boolean value) {
4154 if (!value) {
4155 this.io = null;
4156 }
4157 }
4158
4159 public void setFieldValue(_Fields field, Object value) {
4160 switch (field) {
4161 case IO:
4162 if (value == null) {
4163 unsetIo();
4164 } else {
4165 setIo((IOError)value);
4166 }
4167 break;
4168
4169 }
4170 }
4171
4172 public void setFieldValue(int fieldID, Object value) {
4173 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4174 }
4175
4176 public Object getFieldValue(_Fields field) {
4177 switch (field) {
4178 case IO:
4179 return getIo();
4180
4181 }
4182 throw new IllegalStateException();
4183 }
4184
4185 public Object getFieldValue(int fieldId) {
4186 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4187 }
4188
4189
4190 public boolean isSet(_Fields field) {
4191 switch (field) {
4192 case IO:
4193 return isSetIo();
4194 }
4195 throw new IllegalStateException();
4196 }
4197
4198 public boolean isSet(int fieldID) {
4199 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4200 }
4201
4202 @Override
4203 public boolean equals(Object that) {
4204 if (that == null)
4205 return false;
4206 if (that instanceof disableTable_result)
4207 return this.equals((disableTable_result)that);
4208 return false;
4209 }
4210
4211 public boolean equals(disableTable_result that) {
4212 if (that == null)
4213 return false;
4214
4215 boolean this_present_io = true && this.isSetIo();
4216 boolean that_present_io = true && that.isSetIo();
4217 if (this_present_io || that_present_io) {
4218 if (!(this_present_io && that_present_io))
4219 return false;
4220 if (!this.io.equals(that.io))
4221 return false;
4222 }
4223
4224 return true;
4225 }
4226
4227 @Override
4228 public int hashCode() {
4229 HashCodeBuilder builder = new HashCodeBuilder();
4230
4231 boolean present_io = true && (isSetIo());
4232 builder.append(present_io);
4233 if (present_io)
4234 builder.append(io);
4235
4236 return builder.toHashCode();
4237 }
4238
4239 public int compareTo(disableTable_result other) {
4240 if (!getClass().equals(other.getClass())) {
4241 return getClass().getName().compareTo(other.getClass().getName());
4242 }
4243
4244 int lastComparison = 0;
4245 disableTable_result typedOther = (disableTable_result)other;
4246
4247 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
4248 if (lastComparison != 0) {
4249 return lastComparison;
4250 }
4251 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
4252 if (lastComparison != 0) {
4253 return lastComparison;
4254 }
4255 return 0;
4256 }
4257
4258 public void read(TProtocol iprot) throws TException {
4259 TField field;
4260 iprot.readStructBegin();
4261 while (true)
4262 {
4263 field = iprot.readFieldBegin();
4264 if (field.type == TType.STOP) {
4265 break;
4266 }
4267 _Fields fieldId = _Fields.findByThriftId(field.id);
4268 if (fieldId == null) {
4269 TProtocolUtil.skip(iprot, field.type);
4270 } else {
4271 switch (fieldId) {
4272 case IO:
4273 if (field.type == TType.STRUCT) {
4274 this.io = new IOError();
4275 this.io.read(iprot);
4276 } else {
4277 TProtocolUtil.skip(iprot, field.type);
4278 }
4279 break;
4280 }
4281 iprot.readFieldEnd();
4282 }
4283 }
4284 iprot.readStructEnd();
4285
4286
4287 validate();
4288 }
4289
4290 public void write(TProtocol oprot) throws TException {
4291 oprot.writeStructBegin(STRUCT_DESC);
4292
4293 if (this.isSetIo()) {
4294 oprot.writeFieldBegin(IO_FIELD_DESC);
4295 this.io.write(oprot);
4296 oprot.writeFieldEnd();
4297 }
4298 oprot.writeFieldStop();
4299 oprot.writeStructEnd();
4300 }
4301
4302 @Override
4303 public String toString() {
4304 StringBuilder sb = new StringBuilder("disableTable_result(");
4305 boolean first = true;
4306
4307 sb.append("io:");
4308 if (this.io == null) {
4309 sb.append("null");
4310 } else {
4311 sb.append(this.io);
4312 }
4313 first = false;
4314 sb.append(")");
4315 return sb.toString();
4316 }
4317
4318 public void validate() throws TException {
4319
4320 }
4321
4322 }
4323
4324 public static class isTableEnabled_args implements TBase<isTableEnabled_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_args> {
4325 private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_args");
4326
4327 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
4328
4329
4330
4331
4332 public byte[] tableName;
4333
4334
4335 public enum _Fields implements TFieldIdEnum {
4336
4337
4338
4339 TABLE_NAME((short)1, "tableName");
4340
4341 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4342 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4343
4344 static {
4345 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4346 byId.put((int)field._thriftId, field);
4347 byName.put(field.getFieldName(), field);
4348 }
4349 }
4350
4351
4352
4353
4354 public static _Fields findByThriftId(int fieldId) {
4355 return byId.get(fieldId);
4356 }
4357
4358
4359
4360
4361
4362 public static _Fields findByThriftIdOrThrow(int fieldId) {
4363 _Fields fields = findByThriftId(fieldId);
4364 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4365 return fields;
4366 }
4367
4368
4369
4370
4371 public static _Fields findByName(String name) {
4372 return byName.get(name);
4373 }
4374
4375 private final short _thriftId;
4376 private final String _fieldName;
4377
4378 _Fields(short thriftId, String fieldName) {
4379 _thriftId = thriftId;
4380 _fieldName = fieldName;
4381 }
4382
4383 public short getThriftFieldId() {
4384 return _thriftId;
4385 }
4386
4387 public String getFieldName() {
4388 return _fieldName;
4389 }
4390 }
4391
4392
4393
4394 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4395 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
4396 new FieldValueMetaData(TType.STRING)));
4397 }});
4398
4399 static {
4400 FieldMetaData.addStructMetaDataMap(isTableEnabled_args.class, metaDataMap);
4401 }
4402
4403 public isTableEnabled_args() {
4404 }
4405
4406 public isTableEnabled_args(
4407 byte[] tableName)
4408 {
4409 this();
4410 this.tableName = tableName;
4411 }
4412
4413
4414
4415
4416 public isTableEnabled_args(isTableEnabled_args other) {
4417 if (other.isSetTableName()) {
4418 this.tableName = other.tableName;
4419 }
4420 }
4421
4422 public isTableEnabled_args deepCopy() {
4423 return new isTableEnabled_args(this);
4424 }
4425
4426 @Deprecated
4427 public isTableEnabled_args clone() {
4428 return new isTableEnabled_args(this);
4429 }
4430
4431
4432
4433
4434 public byte[] getTableName() {
4435 return this.tableName;
4436 }
4437
4438
4439
4440
4441 public isTableEnabled_args setTableName(byte[] tableName) {
4442 this.tableName = tableName;
4443 return this;
4444 }
4445
4446 public void unsetTableName() {
4447 this.tableName = null;
4448 }
4449
4450
4451 public boolean isSetTableName() {
4452 return this.tableName != null;
4453 }
4454
4455 public void setTableNameIsSet(boolean value) {
4456 if (!value) {
4457 this.tableName = null;
4458 }
4459 }
4460
4461 public void setFieldValue(_Fields field, Object value) {
4462 switch (field) {
4463 case TABLE_NAME:
4464 if (value == null) {
4465 unsetTableName();
4466 } else {
4467 setTableName((byte[])value);
4468 }
4469 break;
4470
4471 }
4472 }
4473
4474 public void setFieldValue(int fieldID, Object value) {
4475 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4476 }
4477
4478 public Object getFieldValue(_Fields field) {
4479 switch (field) {
4480 case TABLE_NAME:
4481 return getTableName();
4482
4483 }
4484 throw new IllegalStateException();
4485 }
4486
4487 public Object getFieldValue(int fieldId) {
4488 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4489 }
4490
4491
4492 public boolean isSet(_Fields field) {
4493 switch (field) {
4494 case TABLE_NAME:
4495 return isSetTableName();
4496 }
4497 throw new IllegalStateException();
4498 }
4499
4500 public boolean isSet(int fieldID) {
4501 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4502 }
4503
4504 @Override
4505 public boolean equals(Object that) {
4506 if (that == null)
4507 return false;
4508 if (that instanceof isTableEnabled_args)
4509 return this.equals((isTableEnabled_args)that);
4510 return false;
4511 }
4512
4513 public boolean equals(isTableEnabled_args that) {
4514 if (that == null)
4515 return false;
4516
4517 boolean this_present_tableName = true && this.isSetTableName();
4518 boolean that_present_tableName = true && that.isSetTableName();
4519 if (this_present_tableName || that_present_tableName) {
4520 if (!(this_present_tableName && that_present_tableName))
4521 return false;
4522 if (!java.util.Arrays.equals(this.tableName, that.tableName))
4523 return false;
4524 }
4525
4526 return true;
4527 }
4528
4529 @Override
4530 public int hashCode() {
4531 HashCodeBuilder builder = new HashCodeBuilder();
4532
4533 boolean present_tableName = true && (isSetTableName());
4534 builder.append(present_tableName);
4535 if (present_tableName)
4536 builder.append(tableName);
4537
4538 return builder.toHashCode();
4539 }
4540
4541 public int compareTo(isTableEnabled_args other) {
4542 if (!getClass().equals(other.getClass())) {
4543 return getClass().getName().compareTo(other.getClass().getName());
4544 }
4545
4546 int lastComparison = 0;
4547 isTableEnabled_args typedOther = (isTableEnabled_args)other;
4548
4549 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
4550 if (lastComparison != 0) {
4551 return lastComparison;
4552 }
4553 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
4554 if (lastComparison != 0) {
4555 return lastComparison;
4556 }
4557 return 0;
4558 }
4559
4560 public void read(TProtocol iprot) throws TException {
4561 TField field;
4562 iprot.readStructBegin();
4563 while (true)
4564 {
4565 field = iprot.readFieldBegin();
4566 if (field.type == TType.STOP) {
4567 break;
4568 }
4569 _Fields fieldId = _Fields.findByThriftId(field.id);
4570 if (fieldId == null) {
4571 TProtocolUtil.skip(iprot, field.type);
4572 } else {
4573 switch (fieldId) {
4574 case TABLE_NAME:
4575 if (field.type == TType.STRING) {
4576 this.tableName = iprot.readBinary();
4577 } else {
4578 TProtocolUtil.skip(iprot, field.type);
4579 }
4580 break;
4581 }
4582 iprot.readFieldEnd();
4583 }
4584 }
4585 iprot.readStructEnd();
4586
4587
4588 validate();
4589 }
4590
4591 public void write(TProtocol oprot) throws TException {
4592 validate();
4593
4594 oprot.writeStructBegin(STRUCT_DESC);
4595 if (this.tableName != null) {
4596 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
4597 oprot.writeBinary(this.tableName);
4598 oprot.writeFieldEnd();
4599 }
4600 oprot.writeFieldStop();
4601 oprot.writeStructEnd();
4602 }
4603
4604 @Override
4605 public String toString() {
4606 StringBuilder sb = new StringBuilder("isTableEnabled_args(");
4607 boolean first = true;
4608
4609 sb.append("tableName:");
4610 if (this.tableName == null) {
4611 sb.append("null");
4612 } else {
4613 sb.append(this.tableName);
4614 }
4615 first = false;
4616 sb.append(")");
4617 return sb.toString();
4618 }
4619
4620 public void validate() throws TException {
4621
4622 }
4623
4624 }
4625
4626 public static class isTableEnabled_result implements TBase<isTableEnabled_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_result> {
4627 private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_result");
4628
4629 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0);
4630 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
4631
4632 public boolean success;
4633 public IOError io;
4634
4635
4636 public enum _Fields implements TFieldIdEnum {
4637 SUCCESS((short)0, "success"),
4638 IO((short)1, "io");
4639
4640 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4641 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4642
4643 static {
4644 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4645 byId.put((int)field._thriftId, field);
4646 byName.put(field.getFieldName(), field);
4647 }
4648 }
4649
4650
4651
4652
4653 public static _Fields findByThriftId(int fieldId) {
4654 return byId.get(fieldId);
4655 }
4656
4657
4658
4659
4660
4661 public static _Fields findByThriftIdOrThrow(int fieldId) {
4662 _Fields fields = findByThriftId(fieldId);
4663 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4664 return fields;
4665 }
4666
4667
4668
4669
4670 public static _Fields findByName(String name) {
4671 return byName.get(name);
4672 }
4673
4674 private final short _thriftId;
4675 private final String _fieldName;
4676
4677 _Fields(short thriftId, String fieldName) {
4678 _thriftId = thriftId;
4679 _fieldName = fieldName;
4680 }
4681
4682 public short getThriftFieldId() {
4683 return _thriftId;
4684 }
4685
4686 public String getFieldName() {
4687 return _fieldName;
4688 }
4689 }
4690
4691
4692 private static final int __SUCCESS_ISSET_ID = 0;
4693 private BitSet __isset_bit_vector = new BitSet(1);
4694
4695 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4696 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
4697 new FieldValueMetaData(TType.BOOL)));
4698 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
4699 new FieldValueMetaData(TType.STRUCT)));
4700 }});
4701
4702 static {
4703 FieldMetaData.addStructMetaDataMap(isTableEnabled_result.class, metaDataMap);
4704 }
4705
4706 public isTableEnabled_result() {
4707 }
4708
4709 public isTableEnabled_result(
4710 boolean success,
4711 IOError io)
4712 {
4713 this();
4714 this.success = success;
4715 setSuccessIsSet(true);
4716 this.io = io;
4717 }
4718
4719
4720
4721
4722 public isTableEnabled_result(isTableEnabled_result other) {
4723 __isset_bit_vector.clear();
4724 __isset_bit_vector.or(other.__isset_bit_vector);
4725 this.success = other.success;
4726 if (other.isSetIo()) {
4727 this.io = new IOError(other.io);
4728 }
4729 }
4730
4731 public isTableEnabled_result deepCopy() {
4732 return new isTableEnabled_result(this);
4733 }
4734
4735 @Deprecated
4736 public isTableEnabled_result clone() {
4737 return new isTableEnabled_result(this);
4738 }
4739
4740 public boolean isSuccess() {
4741 return this.success;
4742 }
4743
4744 public isTableEnabled_result setSuccess(boolean success) {
4745 this.success = success;
4746 setSuccessIsSet(true);
4747 return this;
4748 }
4749
4750 public void unsetSuccess() {
4751 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
4752 }
4753
4754
4755 public boolean isSetSuccess() {
4756 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
4757 }
4758
4759 public void setSuccessIsSet(boolean value) {
4760 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
4761 }
4762
4763 public IOError getIo() {
4764 return this.io;
4765 }
4766
4767 public isTableEnabled_result setIo(IOError io) {
4768 this.io = io;
4769 return this;
4770 }
4771
4772 public void unsetIo() {
4773 this.io = null;
4774 }
4775
4776
4777 public boolean isSetIo() {
4778 return this.io != null;
4779 }
4780
4781 public void setIoIsSet(boolean value) {
4782 if (!value) {
4783 this.io = null;
4784 }
4785 }
4786
4787 public void setFieldValue(_Fields field, Object value) {
4788 switch (field) {
4789 case SUCCESS:
4790 if (value == null) {
4791 unsetSuccess();
4792 } else {
4793 setSuccess((Boolean)value);
4794 }
4795 break;
4796
4797 case IO:
4798 if (value == null) {
4799 unsetIo();
4800 } else {
4801 setIo((IOError)value);
4802 }
4803 break;
4804
4805 }
4806 }
4807
4808 public void setFieldValue(int fieldID, Object value) {
4809 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4810 }
4811
4812 public Object getFieldValue(_Fields field) {
4813 switch (field) {
4814 case SUCCESS:
4815 return new Boolean(isSuccess());
4816
4817 case IO:
4818 return getIo();
4819
4820 }
4821 throw new IllegalStateException();
4822 }
4823
4824 public Object getFieldValue(int fieldId) {
4825 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4826 }
4827
4828
4829 public boolean isSet(_Fields field) {
4830 switch (field) {
4831 case SUCCESS:
4832 return isSetSuccess();
4833 case IO:
4834 return isSetIo();
4835 }
4836 throw new IllegalStateException();
4837 }
4838
4839 public boolean isSet(int fieldID) {
4840 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4841 }
4842
4843 @Override
4844 public boolean equals(Object that) {
4845 if (that == null)
4846 return false;
4847 if (that instanceof isTableEnabled_result)
4848 return this.equals((isTableEnabled_result)that);
4849 return false;
4850 }
4851
4852 public boolean equals(isTableEnabled_result that) {
4853 if (that == null)
4854 return false;
4855
4856 boolean this_present_success = true;
4857 boolean that_present_success = true;
4858 if (this_present_success || that_present_success) {
4859 if (!(this_present_success && that_present_success))
4860 return false;
4861 if (this.success != that.success)
4862 return false;
4863 }
4864
4865 boolean this_present_io = true && this.isSetIo();
4866 boolean that_present_io = true && that.isSetIo();
4867 if (this_present_io || that_present_io) {
4868 if (!(this_present_io && that_present_io))
4869 return false;
4870 if (!this.io.equals(that.io))
4871 return false;
4872 }
4873
4874 return true;
4875 }
4876
4877 @Override
4878 public int hashCode() {
4879 HashCodeBuilder builder = new HashCodeBuilder();
4880
4881 boolean present_success = true;
4882 builder.append(present_success);
4883 if (present_success)
4884 builder.append(success);
4885
4886 boolean present_io = true && (isSetIo());
4887 builder.append(present_io);
4888 if (present_io)
4889 builder.append(io);
4890
4891 return builder.toHashCode();
4892 }
4893
4894 public int compareTo(isTableEnabled_result other) {
4895 if (!getClass().equals(other.getClass())) {
4896 return getClass().getName().compareTo(other.getClass().getName());
4897 }
4898
4899 int lastComparison = 0;
4900 isTableEnabled_result typedOther = (isTableEnabled_result)other;
4901
4902 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
4903 if (lastComparison != 0) {
4904 return lastComparison;
4905 }
4906 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
4907 if (lastComparison != 0) {
4908 return lastComparison;
4909 }
4910 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
4911 if (lastComparison != 0) {
4912 return lastComparison;
4913 }
4914 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
4915 if (lastComparison != 0) {
4916 return lastComparison;
4917 }
4918 return 0;
4919 }
4920
4921 public void read(TProtocol iprot) throws TException {
4922 TField field;
4923 iprot.readStructBegin();
4924 while (true)
4925 {
4926 field = iprot.readFieldBegin();
4927 if (field.type == TType.STOP) {
4928 break;
4929 }
4930 _Fields fieldId = _Fields.findByThriftId(field.id);
4931 if (fieldId == null) {
4932 TProtocolUtil.skip(iprot, field.type);
4933 } else {
4934 switch (fieldId) {
4935 case SUCCESS:
4936 if (field.type == TType.BOOL) {
4937 this.success = iprot.readBool();
4938 setSuccessIsSet(true);
4939 } else {
4940 TProtocolUtil.skip(iprot, field.type);
4941 }
4942 break;
4943 case IO:
4944 if (field.type == TType.STRUCT) {
4945 this.io = new IOError();
4946 this.io.read(iprot);
4947 } else {
4948 TProtocolUtil.skip(iprot, field.type);
4949 }
4950 break;
4951 }
4952 iprot.readFieldEnd();
4953 }
4954 }
4955 iprot.readStructEnd();
4956
4957
4958 validate();
4959 }
4960
4961 public void write(TProtocol oprot) throws TException {
4962 oprot.writeStructBegin(STRUCT_DESC);
4963
4964 if (this.isSetSuccess()) {
4965 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4966 oprot.writeBool(this.success);
4967 oprot.writeFieldEnd();
4968 } else if (this.isSetIo()) {
4969 oprot.writeFieldBegin(IO_FIELD_DESC);
4970 this.io.write(oprot);
4971 oprot.writeFieldEnd();
4972 }
4973 oprot.writeFieldStop();
4974 oprot.writeStructEnd();
4975 }
4976
4977 @Override
4978 public String toString() {
4979 StringBuilder sb = new StringBuilder("isTableEnabled_result(");
4980 boolean first = true;
4981
4982 sb.append("success:");
4983 sb.append(this.success);
4984 first = false;
4985 if (!first) sb.append(", ");
4986 sb.append("io:");
4987 if (this.io == null) {
4988 sb.append("null");
4989 } else {
4990 sb.append(this.io);
4991 }
4992 first = false;
4993 sb.append(")");
4994 return sb.toString();
4995 }
4996
4997 public void validate() throws TException {
4998
4999 }
5000
5001 }
5002
5003 public static class compact_args implements TBase<compact_args._Fields>, java.io.Serializable, Cloneable, Comparable<compact_args> {
5004 private static final TStruct STRUCT_DESC = new TStruct("compact_args");
5005
5006 private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1);
5007
5008 public byte[] tableNameOrRegionName;
5009
5010
5011 public enum _Fields implements TFieldIdEnum {
5012 TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
5013
5014 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5015 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5016
5017 static {
5018 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5019 byId.put((int)field._thriftId, field);
5020 byName.put(field.getFieldName(), field);
5021 }
5022 }
5023
5024
5025
5026
5027 public static _Fields findByThriftId(int fieldId) {
5028 return byId.get(fieldId);
5029 }
5030
5031
5032
5033
5034
5035 public static _Fields findByThriftIdOrThrow(int fieldId) {
5036 _Fields fields = findByThriftId(fieldId);
5037 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5038 return fields;
5039 }
5040
5041
5042
5043
5044 public static _Fields findByName(String name) {
5045 return byName.get(name);
5046 }
5047
5048 private final short _thriftId;
5049 private final String _fieldName;
5050
5051 _Fields(short thriftId, String fieldName) {
5052 _thriftId = thriftId;
5053 _fieldName = fieldName;
5054 }
5055
5056 public short getThriftFieldId() {
5057 return _thriftId;
5058 }
5059
5060 public String getFieldName() {
5061 return _fieldName;
5062 }
5063 }
5064
5065
5066
5067 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5068 put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT,
5069 new FieldValueMetaData(TType.STRING)));
5070 }});
5071
5072 static {
5073 FieldMetaData.addStructMetaDataMap(compact_args.class, metaDataMap);
5074 }
5075
5076 public compact_args() {
5077 }
5078
5079 public compact_args(
5080 byte[] tableNameOrRegionName)
5081 {
5082 this();
5083 this.tableNameOrRegionName = tableNameOrRegionName;
5084 }
5085
5086
5087
5088
5089 public compact_args(compact_args other) {
5090 if (other.isSetTableNameOrRegionName()) {
5091 this.tableNameOrRegionName = other.tableNameOrRegionName;
5092 }
5093 }
5094
5095 public compact_args deepCopy() {
5096 return new compact_args(this);
5097 }
5098
5099 @Deprecated
5100 public compact_args clone() {
5101 return new compact_args(this);
5102 }
5103
5104 public byte[] getTableNameOrRegionName() {
5105 return this.tableNameOrRegionName;
5106 }
5107
5108 public compact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
5109 this.tableNameOrRegionName = tableNameOrRegionName;
5110 return this;
5111 }
5112
5113 public void unsetTableNameOrRegionName() {
5114 this.tableNameOrRegionName = null;
5115 }
5116
5117
5118 public boolean isSetTableNameOrRegionName() {
5119 return this.tableNameOrRegionName != null;
5120 }
5121
5122 public void setTableNameOrRegionNameIsSet(boolean value) {
5123 if (!value) {
5124 this.tableNameOrRegionName = null;
5125 }
5126 }
5127
5128 public void setFieldValue(_Fields field, Object value) {
5129 switch (field) {
5130 case TABLE_NAME_OR_REGION_NAME:
5131 if (value == null) {
5132 unsetTableNameOrRegionName();
5133 } else {
5134 setTableNameOrRegionName((byte[])value);
5135 }
5136 break;
5137
5138 }
5139 }
5140
5141 public void setFieldValue(int fieldID, Object value) {
5142 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5143 }
5144
5145 public Object getFieldValue(_Fields field) {
5146 switch (field) {
5147 case TABLE_NAME_OR_REGION_NAME:
5148 return getTableNameOrRegionName();
5149
5150 }
5151 throw new IllegalStateException();
5152 }
5153
5154 public Object getFieldValue(int fieldId) {
5155 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5156 }
5157
5158
5159 public boolean isSet(_Fields field) {
5160 switch (field) {
5161 case TABLE_NAME_OR_REGION_NAME:
5162 return isSetTableNameOrRegionName();
5163 }
5164 throw new IllegalStateException();
5165 }
5166
5167 public boolean isSet(int fieldID) {
5168 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5169 }
5170
5171 @Override
5172 public boolean equals(Object that) {
5173 if (that == null)
5174 return false;
5175 if (that instanceof compact_args)
5176 return this.equals((compact_args)that);
5177 return false;
5178 }
5179
5180 public boolean equals(compact_args that) {
5181 if (that == null)
5182 return false;
5183
5184 boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
5185 boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
5186 if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
5187 if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
5188 return false;
5189 if (!java.util.Arrays.equals(this.tableNameOrRegionName, that.tableNameOrRegionName))
5190 return false;
5191 }
5192
5193 return true;
5194 }
5195
5196 @Override
5197 public int hashCode() {
5198 HashCodeBuilder builder = new HashCodeBuilder();
5199
5200 boolean present_tableNameOrRegionName = true && (isSetTableNameOrRegionName());
5201 builder.append(present_tableNameOrRegionName);
5202 if (present_tableNameOrRegionName)
5203 builder.append(tableNameOrRegionName);
5204
5205 return builder.toHashCode();
5206 }
5207
5208 public int compareTo(compact_args other) {
5209 if (!getClass().equals(other.getClass())) {
5210 return getClass().getName().compareTo(other.getClass().getName());
5211 }
5212
5213 int lastComparison = 0;
5214 compact_args typedOther = (compact_args)other;
5215
5216 lastComparison = Boolean.valueOf(isSetTableNameOrRegionName()).compareTo(isSetTableNameOrRegionName());
5217 if (lastComparison != 0) {
5218 return lastComparison;
5219 }
5220 lastComparison = TBaseHelper.compareTo(tableNameOrRegionName, typedOther.tableNameOrRegionName);
5221 if (lastComparison != 0) {
5222 return lastComparison;
5223 }
5224 return 0;
5225 }
5226
5227 public void read(TProtocol iprot) throws TException {
5228 TField field;
5229 iprot.readStructBegin();
5230 while (true)
5231 {
5232 field = iprot.readFieldBegin();
5233 if (field.type == TType.STOP) {
5234 break;
5235 }
5236 _Fields fieldId = _Fields.findByThriftId(field.id);
5237 if (fieldId == null) {
5238 TProtocolUtil.skip(iprot, field.type);
5239 } else {
5240 switch (fieldId) {
5241 case TABLE_NAME_OR_REGION_NAME:
5242 if (field.type == TType.STRING) {
5243 this.tableNameOrRegionName = iprot.readBinary();
5244 } else {
5245 TProtocolUtil.skip(iprot, field.type);
5246 }
5247 break;
5248 }
5249 iprot.readFieldEnd();
5250 }
5251 }
5252 iprot.readStructEnd();
5253
5254
5255 validate();
5256 }
5257
5258 public void write(TProtocol oprot) throws TException {
5259 validate();
5260
5261 oprot.writeStructBegin(STRUCT_DESC);
5262 if (this.tableNameOrRegionName != null) {
5263 oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
5264 oprot.writeBinary(this.tableNameOrRegionName);
5265 oprot.writeFieldEnd();
5266 }
5267 oprot.writeFieldStop();
5268 oprot.writeStructEnd();
5269 }
5270
5271 @Override
5272 public String toString() {
5273 StringBuilder sb = new StringBuilder("compact_args(");
5274 boolean first = true;
5275
5276 sb.append("tableNameOrRegionName:");
5277 if (this.tableNameOrRegionName == null) {
5278 sb.append("null");
5279 } else {
5280 sb.append(this.tableNameOrRegionName);
5281 }
5282 first = false;
5283 sb.append(")");
5284 return sb.toString();
5285 }
5286
5287 public void validate() throws TException {
5288
5289 }
5290
5291 }
5292
5293 public static class compact_result implements TBase<compact_result._Fields>, java.io.Serializable, Cloneable, Comparable<compact_result> {
5294 private static final TStruct STRUCT_DESC = new TStruct("compact_result");
5295
5296 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
5297
5298 public IOError io;
5299
5300
5301 public enum _Fields implements TFieldIdEnum {
5302 IO((short)1, "io");
5303
5304 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5305 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5306
5307 static {
5308 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5309 byId.put((int)field._thriftId, field);
5310 byName.put(field.getFieldName(), field);
5311 }
5312 }
5313
5314
5315
5316
5317 public static _Fields findByThriftId(int fieldId) {
5318 return byId.get(fieldId);
5319 }
5320
5321
5322
5323
5324
5325 public static _Fields findByThriftIdOrThrow(int fieldId) {
5326 _Fields fields = findByThriftId(fieldId);
5327 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5328 return fields;
5329 }
5330
5331
5332
5333
5334 public static _Fields findByName(String name) {
5335 return byName.get(name);
5336 }
5337
5338 private final short _thriftId;
5339 private final String _fieldName;
5340
5341 _Fields(short thriftId, String fieldName) {
5342 _thriftId = thriftId;
5343 _fieldName = fieldName;
5344 }
5345
5346 public short getThriftFieldId() {
5347 return _thriftId;
5348 }
5349
5350 public String getFieldName() {
5351 return _fieldName;
5352 }
5353 }
5354
5355
5356
5357 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5358 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
5359 new FieldValueMetaData(TType.STRUCT)));
5360 }});
5361
5362 static {
5363 FieldMetaData.addStructMetaDataMap(compact_result.class, metaDataMap);
5364 }
5365
5366 public compact_result() {
5367 }
5368
5369 public compact_result(
5370 IOError io)
5371 {
5372 this();
5373 this.io = io;
5374 }
5375
5376
5377
5378
5379 public compact_result(compact_result other) {
5380 if (other.isSetIo()) {
5381 this.io = new IOError(other.io);
5382 }
5383 }
5384
5385 public compact_result deepCopy() {
5386 return new compact_result(this);
5387 }
5388
5389 @Deprecated
5390 public compact_result clone() {
5391 return new compact_result(this);
5392 }
5393
5394 public IOError getIo() {
5395 return this.io;
5396 }
5397
5398 public compact_result setIo(IOError io) {
5399 this.io = io;
5400 return this;
5401 }
5402
5403 public void unsetIo() {
5404 this.io = null;
5405 }
5406
5407
5408 public boolean isSetIo() {
5409 return this.io != null;
5410 }
5411
5412 public void setIoIsSet(boolean value) {
5413 if (!value) {
5414 this.io = null;
5415 }
5416 }
5417
5418 public void setFieldValue(_Fields field, Object value) {
5419 switch (field) {
5420 case IO:
5421 if (value == null) {
5422 unsetIo();
5423 } else {
5424 setIo((IOError)value);
5425 }
5426 break;
5427
5428 }
5429 }
5430
5431 public void setFieldValue(int fieldID, Object value) {
5432 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5433 }
5434
5435 public Object getFieldValue(_Fields field) {
5436 switch (field) {
5437 case IO:
5438 return getIo();
5439
5440 }
5441 throw new IllegalStateException();
5442 }
5443
5444 public Object getFieldValue(int fieldId) {
5445 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5446 }
5447
5448
5449 public boolean isSet(_Fields field) {
5450 switch (field) {
5451 case IO:
5452 return isSetIo();
5453 }
5454 throw new IllegalStateException();
5455 }
5456
5457 public boolean isSet(int fieldID) {
5458 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5459 }
5460
5461 @Override
5462 public boolean equals(Object that) {
5463 if (that == null)
5464 return false;
5465 if (that instanceof compact_result)
5466 return this.equals((compact_result)that);
5467 return false;
5468 }
5469
5470 public boolean equals(compact_result that) {
5471 if (that == null)
5472 return false;
5473
5474 boolean this_present_io = true && this.isSetIo();
5475 boolean that_present_io = true && that.isSetIo();
5476 if (this_present_io || that_present_io) {
5477 if (!(this_present_io && that_present_io))
5478 return false;
5479 if (!this.io.equals(that.io))
5480 return false;
5481 }
5482
5483 return true;
5484 }
5485
5486 @Override
5487 public int hashCode() {
5488 HashCodeBuilder builder = new HashCodeBuilder();
5489
5490 boolean present_io = true && (isSetIo());
5491 builder.append(present_io);
5492 if (present_io)
5493 builder.append(io);
5494
5495 return builder.toHashCode();
5496 }
5497
5498 public int compareTo(compact_result other) {
5499 if (!getClass().equals(other.getClass())) {
5500 return getClass().getName().compareTo(other.getClass().getName());
5501 }
5502
5503 int lastComparison = 0;
5504 compact_result typedOther = (compact_result)other;
5505
5506 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
5507 if (lastComparison != 0) {
5508 return lastComparison;
5509 }
5510 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
5511 if (lastComparison != 0) {
5512 return lastComparison;
5513 }
5514 return 0;
5515 }
5516
5517 public void read(TProtocol iprot) throws TException {
5518 TField field;
5519 iprot.readStructBegin();
5520 while (true)
5521 {
5522 field = iprot.readFieldBegin();
5523 if (field.type == TType.STOP) {
5524 break;
5525 }
5526 _Fields fieldId = _Fields.findByThriftId(field.id);
5527 if (fieldId == null) {
5528 TProtocolUtil.skip(iprot, field.type);
5529 } else {
5530 switch (fieldId) {
5531 case IO:
5532 if (field.type == TType.STRUCT) {
5533 this.io = new IOError();
5534 this.io.read(iprot);
5535 } else {
5536 TProtocolUtil.skip(iprot, field.type);
5537 }
5538 break;
5539 }
5540 iprot.readFieldEnd();
5541 }
5542 }
5543 iprot.readStructEnd();
5544
5545
5546 validate();
5547 }
5548
5549 public void write(TProtocol oprot) throws TException {
5550 oprot.writeStructBegin(STRUCT_DESC);
5551
5552 if (this.isSetIo()) {
5553 oprot.writeFieldBegin(IO_FIELD_DESC);
5554 this.io.write(oprot);
5555 oprot.writeFieldEnd();
5556 }
5557 oprot.writeFieldStop();
5558 oprot.writeStructEnd();
5559 }
5560
5561 @Override
5562 public String toString() {
5563 StringBuilder sb = new StringBuilder("compact_result(");
5564 boolean first = true;
5565
5566 sb.append("io:");
5567 if (this.io == null) {
5568 sb.append("null");
5569 } else {
5570 sb.append(this.io);
5571 }
5572 first = false;
5573 sb.append(")");
5574 return sb.toString();
5575 }
5576
5577 public void validate() throws TException {
5578
5579 }
5580
5581 }
5582
5583 public static class majorCompact_args implements TBase<majorCompact_args._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_args> {
5584 private static final TStruct STRUCT_DESC = new TStruct("majorCompact_args");
5585
5586 private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1);
5587
5588 public byte[] tableNameOrRegionName;
5589
5590
5591 public enum _Fields implements TFieldIdEnum {
5592 TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
5593
5594 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5595 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5596
5597 static {
5598 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5599 byId.put((int)field._thriftId, field);
5600 byName.put(field.getFieldName(), field);
5601 }
5602 }
5603
5604
5605
5606
5607 public static _Fields findByThriftId(int fieldId) {
5608 return byId.get(fieldId);
5609 }
5610
5611
5612
5613
5614
5615 public static _Fields findByThriftIdOrThrow(int fieldId) {
5616 _Fields fields = findByThriftId(fieldId);
5617 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5618 return fields;
5619 }
5620
5621
5622
5623
5624 public static _Fields findByName(String name) {
5625 return byName.get(name);
5626 }
5627
5628 private final short _thriftId;
5629 private final String _fieldName;
5630
5631 _Fields(short thriftId, String fieldName) {
5632 _thriftId = thriftId;
5633 _fieldName = fieldName;
5634 }
5635
5636 public short getThriftFieldId() {
5637 return _thriftId;
5638 }
5639
5640 public String getFieldName() {
5641 return _fieldName;
5642 }
5643 }
5644
5645
5646
5647 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5648 put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT,
5649 new FieldValueMetaData(TType.STRING)));
5650 }});
5651
5652 static {
5653 FieldMetaData.addStructMetaDataMap(majorCompact_args.class, metaDataMap);
5654 }
5655
5656 public majorCompact_args() {
5657 }
5658
5659 public majorCompact_args(
5660 byte[] tableNameOrRegionName)
5661 {
5662 this();
5663 this.tableNameOrRegionName = tableNameOrRegionName;
5664 }
5665
5666
5667
5668
5669 public majorCompact_args(majorCompact_args other) {
5670 if (other.isSetTableNameOrRegionName()) {
5671 this.tableNameOrRegionName = other.tableNameOrRegionName;
5672 }
5673 }
5674
5675 public majorCompact_args deepCopy() {
5676 return new majorCompact_args(this);
5677 }
5678
5679 @Deprecated
5680 public majorCompact_args clone() {
5681 return new majorCompact_args(this);
5682 }
5683
5684 public byte[] getTableNameOrRegionName() {
5685 return this.tableNameOrRegionName;
5686 }
5687
5688 public majorCompact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
5689 this.tableNameOrRegionName = tableNameOrRegionName;
5690 return this;
5691 }
5692
5693 public void unsetTableNameOrRegionName() {
5694 this.tableNameOrRegionName = null;
5695 }
5696
5697
5698 public boolean isSetTableNameOrRegionName() {
5699 return this.tableNameOrRegionName != null;
5700 }
5701
5702 public void setTableNameOrRegionNameIsSet(boolean value) {
5703 if (!value) {
5704 this.tableNameOrRegionName = null;
5705 }
5706 }
5707
5708 public void setFieldValue(_Fields field, Object value) {
5709 switch (field) {
5710 case TABLE_NAME_OR_REGION_NAME:
5711 if (value == null) {
5712 unsetTableNameOrRegionName();
5713 } else {
5714 setTableNameOrRegionName((byte[])value);
5715 }
5716 break;
5717
5718 }
5719 }
5720
5721 public void setFieldValue(int fieldID, Object value) {
5722 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5723 }
5724
5725 public Object getFieldValue(_Fields field) {
5726 switch (field) {
5727 case TABLE_NAME_OR_REGION_NAME:
5728 return getTableNameOrRegionName();
5729
5730 }
5731 throw new IllegalStateException();
5732 }
5733
5734 public Object getFieldValue(int fieldId) {
5735 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5736 }
5737
5738
5739 public boolean isSet(_Fields field) {
5740 switch (field) {
5741 case TABLE_NAME_OR_REGION_NAME:
5742 return isSetTableNameOrRegionName();
5743 }
5744 throw new IllegalStateException();
5745 }
5746
5747 public boolean isSet(int fieldID) {
5748 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5749 }
5750
5751 @Override
5752 public boolean equals(Object that) {
5753 if (that == null)
5754 return false;
5755 if (that instanceof majorCompact_args)
5756 return this.equals((majorCompact_args)that);
5757 return false;
5758 }
5759
5760 public boolean equals(majorCompact_args that) {
5761 if (that == null)
5762 return false;
5763
5764 boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
5765 boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
5766 if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
5767 if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
5768 return false;
5769 if (!java.util.Arrays.equals(this.tableNameOrRegionName, that.tableNameOrRegionName))
5770 return false;
5771 }
5772
5773 return true;
5774 }
5775
5776 @Override
5777 public int hashCode() {
5778 HashCodeBuilder builder = new HashCodeBuilder();
5779
5780 boolean present_tableNameOrRegionName = true && (isSetTableNameOrRegionName());
5781 builder.append(present_tableNameOrRegionName);
5782 if (present_tableNameOrRegionName)
5783 builder.append(tableNameOrRegionName);
5784
5785 return builder.toHashCode();
5786 }
5787
5788 public int compareTo(majorCompact_args other) {
5789 if (!getClass().equals(other.getClass())) {
5790 return getClass().getName().compareTo(other.getClass().getName());
5791 }
5792
5793 int lastComparison = 0;
5794 majorCompact_args typedOther = (majorCompact_args)other;
5795
5796 lastComparison = Boolean.valueOf(isSetTableNameOrRegionName()).compareTo(isSetTableNameOrRegionName());
5797 if (lastComparison != 0) {
5798 return lastComparison;
5799 }
5800 lastComparison = TBaseHelper.compareTo(tableNameOrRegionName, typedOther.tableNameOrRegionName);
5801 if (lastComparison != 0) {
5802 return lastComparison;
5803 }
5804 return 0;
5805 }
5806
5807 public void read(TProtocol iprot) throws TException {
5808 TField field;
5809 iprot.readStructBegin();
5810 while (true)
5811 {
5812 field = iprot.readFieldBegin();
5813 if (field.type == TType.STOP) {
5814 break;
5815 }
5816 _Fields fieldId = _Fields.findByThriftId(field.id);
5817 if (fieldId == null) {
5818 TProtocolUtil.skip(iprot, field.type);
5819 } else {
5820 switch (fieldId) {
5821 case TABLE_NAME_OR_REGION_NAME:
5822 if (field.type == TType.STRING) {
5823 this.tableNameOrRegionName = iprot.readBinary();
5824 } else {
5825 TProtocolUtil.skip(iprot, field.type);
5826 }
5827 break;
5828 }
5829 iprot.readFieldEnd();
5830 }
5831 }
5832 iprot.readStructEnd();
5833
5834
5835 validate();
5836 }
5837
5838 public void write(TProtocol oprot) throws TException {
5839 validate();
5840
5841 oprot.writeStructBegin(STRUCT_DESC);
5842 if (this.tableNameOrRegionName != null) {
5843 oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
5844 oprot.writeBinary(this.tableNameOrRegionName);
5845 oprot.writeFieldEnd();
5846 }
5847 oprot.writeFieldStop();
5848 oprot.writeStructEnd();
5849 }
5850
5851 @Override
5852 public String toString() {
5853 StringBuilder sb = new StringBuilder("majorCompact_args(");
5854 boolean first = true;
5855
5856 sb.append("tableNameOrRegionName:");
5857 if (this.tableNameOrRegionName == null) {
5858 sb.append("null");
5859 } else {
5860 sb.append(this.tableNameOrRegionName);
5861 }
5862 first = false;
5863 sb.append(")");
5864 return sb.toString();
5865 }
5866
5867 public void validate() throws TException {
5868
5869 }
5870
5871 }
5872
5873 public static class majorCompact_result implements TBase<majorCompact_result._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_result> {
5874 private static final TStruct STRUCT_DESC = new TStruct("majorCompact_result");
5875
5876 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
5877
5878 public IOError io;
5879
5880
5881 public enum _Fields implements TFieldIdEnum {
5882 IO((short)1, "io");
5883
5884 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5885 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5886
5887 static {
5888 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5889 byId.put((int)field._thriftId, field);
5890 byName.put(field.getFieldName(), field);
5891 }
5892 }
5893
5894
5895
5896
5897 public static _Fields findByThriftId(int fieldId) {
5898 return byId.get(fieldId);
5899 }
5900
5901
5902
5903
5904
5905 public static _Fields findByThriftIdOrThrow(int fieldId) {
5906 _Fields fields = findByThriftId(fieldId);
5907 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5908 return fields;
5909 }
5910
5911
5912
5913
5914 public static _Fields findByName(String name) {
5915 return byName.get(name);
5916 }
5917
5918 private final short _thriftId;
5919 private final String _fieldName;
5920
5921 _Fields(short thriftId, String fieldName) {
5922 _thriftId = thriftId;
5923 _fieldName = fieldName;
5924 }
5925
5926 public short getThriftFieldId() {
5927 return _thriftId;
5928 }
5929
5930 public String getFieldName() {
5931 return _fieldName;
5932 }
5933 }
5934
5935
5936
5937 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5938 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
5939 new FieldValueMetaData(TType.STRUCT)));
5940 }});
5941
5942 static {
5943 FieldMetaData.addStructMetaDataMap(majorCompact_result.class, metaDataMap);
5944 }
5945
5946 public majorCompact_result() {
5947 }
5948
5949 public majorCompact_result(
5950 IOError io)
5951 {
5952 this();
5953 this.io = io;
5954 }
5955
5956
5957
5958
5959 public majorCompact_result(majorCompact_result other) {
5960 if (other.isSetIo()) {
5961 this.io = new IOError(other.io);
5962 }
5963 }
5964
5965 public majorCompact_result deepCopy() {
5966 return new majorCompact_result(this);
5967 }
5968
5969 @Deprecated
5970 public majorCompact_result clone() {
5971 return new majorCompact_result(this);
5972 }
5973
5974 public IOError getIo() {
5975 return this.io;
5976 }
5977
5978 public majorCompact_result setIo(IOError io) {
5979 this.io = io;
5980 return this;
5981 }
5982
5983 public void unsetIo() {
5984 this.io = null;
5985 }
5986
5987
5988 public boolean isSetIo() {
5989 return this.io != null;
5990 }
5991
5992 public void setIoIsSet(boolean value) {
5993 if (!value) {
5994 this.io = null;
5995 }
5996 }
5997
5998 public void setFieldValue(_Fields field, Object value) {
5999 switch (field) {
6000 case IO:
6001 if (value == null) {
6002 unsetIo();
6003 } else {
6004 setIo((IOError)value);
6005 }
6006 break;
6007
6008 }
6009 }
6010
6011 public void setFieldValue(int fieldID, Object value) {
6012 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6013 }
6014
6015 public Object getFieldValue(_Fields field) {
6016 switch (field) {
6017 case IO:
6018 return getIo();
6019
6020 }
6021 throw new IllegalStateException();
6022 }
6023
6024 public Object getFieldValue(int fieldId) {
6025 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6026 }
6027
6028
6029 public boolean isSet(_Fields field) {
6030 switch (field) {
6031 case IO:
6032 return isSetIo();
6033 }
6034 throw new IllegalStateException();
6035 }
6036
6037 public boolean isSet(int fieldID) {
6038 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6039 }
6040
6041 @Override
6042 public boolean equals(Object that) {
6043 if (that == null)
6044 return false;
6045 if (that instanceof majorCompact_result)
6046 return this.equals((majorCompact_result)that);
6047 return false;
6048 }
6049
6050 public boolean equals(majorCompact_result that) {
6051 if (that == null)
6052 return false;
6053
6054 boolean this_present_io = true && this.isSetIo();
6055 boolean that_present_io = true && that.isSetIo();
6056 if (this_present_io || that_present_io) {
6057 if (!(this_present_io && that_present_io))
6058 return false;
6059 if (!this.io.equals(that.io))
6060 return false;
6061 }
6062
6063 return true;
6064 }
6065
6066 @Override
6067 public int hashCode() {
6068 HashCodeBuilder builder = new HashCodeBuilder();
6069
6070 boolean present_io = true && (isSetIo());
6071 builder.append(present_io);
6072 if (present_io)
6073 builder.append(io);
6074
6075 return builder.toHashCode();
6076 }
6077
6078 public int compareTo(majorCompact_result other) {
6079 if (!getClass().equals(other.getClass())) {
6080 return getClass().getName().compareTo(other.getClass().getName());
6081 }
6082
6083 int lastComparison = 0;
6084 majorCompact_result typedOther = (majorCompact_result)other;
6085
6086 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
6087 if (lastComparison != 0) {
6088 return lastComparison;
6089 }
6090 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
6091 if (lastComparison != 0) {
6092 return lastComparison;
6093 }
6094 return 0;
6095 }
6096
6097 public void read(TProtocol iprot) throws TException {
6098 TField field;
6099 iprot.readStructBegin();
6100 while (true)
6101 {
6102 field = iprot.readFieldBegin();
6103 if (field.type == TType.STOP) {
6104 break;
6105 }
6106 _Fields fieldId = _Fields.findByThriftId(field.id);
6107 if (fieldId == null) {
6108 TProtocolUtil.skip(iprot, field.type);
6109 } else {
6110 switch (fieldId) {
6111 case IO:
6112 if (field.type == TType.STRUCT) {
6113 this.io = new IOError();
6114 this.io.read(iprot);
6115 } else {
6116 TProtocolUtil.skip(iprot, field.type);
6117 }
6118 break;
6119 }
6120 iprot.readFieldEnd();
6121 }
6122 }
6123 iprot.readStructEnd();
6124
6125
6126 validate();
6127 }
6128
6129 public void write(TProtocol oprot) throws TException {
6130 oprot.writeStructBegin(STRUCT_DESC);
6131
6132 if (this.isSetIo()) {
6133 oprot.writeFieldBegin(IO_FIELD_DESC);
6134 this.io.write(oprot);
6135 oprot.writeFieldEnd();
6136 }
6137 oprot.writeFieldStop();
6138 oprot.writeStructEnd();
6139 }
6140
6141 @Override
6142 public String toString() {
6143 StringBuilder sb = new StringBuilder("majorCompact_result(");
6144 boolean first = true;
6145
6146 sb.append("io:");
6147 if (this.io == null) {
6148 sb.append("null");
6149 } else {
6150 sb.append(this.io);
6151 }
6152 first = false;
6153 sb.append(")");
6154 return sb.toString();
6155 }
6156
6157 public void validate() throws TException {
6158
6159 }
6160
6161 }
6162
6163 public static class getTableNames_args implements TBase<getTableNames_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_args> {
6164 private static final TStruct STRUCT_DESC = new TStruct("getTableNames_args");
6165
6166
6167
6168
6169 public enum _Fields implements TFieldIdEnum {
6170 ;
6171
6172 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6173 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6174
6175 static {
6176 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6177 byId.put((int)field._thriftId, field);
6178 byName.put(field.getFieldName(), field);
6179 }
6180 }
6181
6182
6183
6184
6185 public static _Fields findByThriftId(int fieldId) {
6186 return byId.get(fieldId);
6187 }
6188
6189
6190
6191
6192
6193 public static _Fields findByThriftIdOrThrow(int fieldId) {
6194 _Fields fields = findByThriftId(fieldId);
6195 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6196 return fields;
6197 }
6198
6199
6200
6201
6202 public static _Fields findByName(String name) {
6203 return byName.get(name);
6204 }
6205
6206 private final short _thriftId;
6207 private final String _fieldName;
6208
6209 _Fields(short thriftId, String fieldName) {
6210 _thriftId = thriftId;
6211 _fieldName = fieldName;
6212 }
6213
6214 public short getThriftFieldId() {
6215 return _thriftId;
6216 }
6217
6218 public String getFieldName() {
6219 return _fieldName;
6220 }
6221 }
6222 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6223 }});
6224
6225 static {
6226 FieldMetaData.addStructMetaDataMap(getTableNames_args.class, metaDataMap);
6227 }
6228
6229 public getTableNames_args() {
6230 }
6231
6232
6233
6234
6235 public getTableNames_args(getTableNames_args other) {
6236 }
6237
6238 public getTableNames_args deepCopy() {
6239 return new getTableNames_args(this);
6240 }
6241
6242 @Deprecated
6243 public getTableNames_args clone() {
6244 return new getTableNames_args(this);
6245 }
6246
6247 public void setFieldValue(_Fields field, Object value) {
6248 switch (field) {
6249 }
6250 }
6251
6252 public void setFieldValue(int fieldID, Object value) {
6253 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6254 }
6255
6256 public Object getFieldValue(_Fields field) {
6257 switch (field) {
6258 }
6259 throw new IllegalStateException();
6260 }
6261
6262 public Object getFieldValue(int fieldId) {
6263 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6264 }
6265
6266
6267 public boolean isSet(_Fields field) {
6268 switch (field) {
6269 }
6270 throw new IllegalStateException();
6271 }
6272
6273 public boolean isSet(int fieldID) {
6274 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6275 }
6276
6277 @Override
6278 public boolean equals(Object that) {
6279 if (that == null)
6280 return false;
6281 if (that instanceof getTableNames_args)
6282 return this.equals((getTableNames_args)that);
6283 return false;
6284 }
6285
6286 public boolean equals(getTableNames_args that) {
6287 if (that == null)
6288 return false;
6289
6290 return true;
6291 }
6292
6293 @Override
6294 public int hashCode() {
6295 HashCodeBuilder builder = new HashCodeBuilder();
6296
6297 return builder.toHashCode();
6298 }
6299
6300 public int compareTo(getTableNames_args other) {
6301 if (!getClass().equals(other.getClass())) {
6302 return getClass().getName().compareTo(other.getClass().getName());
6303 }
6304
6305 int lastComparison = 0;
6306 getTableNames_args typedOther = (getTableNames_args)other;
6307
6308 return 0;
6309 }
6310
6311 public void read(TProtocol iprot) throws TException {
6312 TField field;
6313 iprot.readStructBegin();
6314 while (true)
6315 {
6316 field = iprot.readFieldBegin();
6317 if (field.type == TType.STOP) {
6318 break;
6319 }
6320 _Fields fieldId = _Fields.findByThriftId(field.id);
6321 if (fieldId == null) {
6322 TProtocolUtil.skip(iprot, field.type);
6323 } else {
6324 switch (fieldId) {
6325 }
6326 iprot.readFieldEnd();
6327 }
6328 }
6329 iprot.readStructEnd();
6330
6331
6332 validate();
6333 }
6334
6335 public void write(TProtocol oprot) throws TException {
6336 validate();
6337
6338 oprot.writeStructBegin(STRUCT_DESC);
6339 oprot.writeFieldStop();
6340 oprot.writeStructEnd();
6341 }
6342
6343 @Override
6344 public String toString() {
6345 StringBuilder sb = new StringBuilder("getTableNames_args(");
6346 boolean first = true;
6347
6348 sb.append(")");
6349 return sb.toString();
6350 }
6351
6352 public void validate() throws TException {
6353
6354 }
6355
6356 }
6357
6358 public static class getTableNames_result implements TBase<getTableNames_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_result> {
6359 private static final TStruct STRUCT_DESC = new TStruct("getTableNames_result");
6360
6361 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
6362 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
6363
6364 public List<byte[]> success;
6365 public IOError io;
6366
6367
6368 public enum _Fields implements TFieldIdEnum {
6369 SUCCESS((short)0, "success"),
6370 IO((short)1, "io");
6371
6372 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6373 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6374
6375 static {
6376 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6377 byId.put((int)field._thriftId, field);
6378 byName.put(field.getFieldName(), field);
6379 }
6380 }
6381
6382
6383
6384
6385 public static _Fields findByThriftId(int fieldId) {
6386 return byId.get(fieldId);
6387 }
6388
6389
6390
6391
6392
6393 public static _Fields findByThriftIdOrThrow(int fieldId) {
6394 _Fields fields = findByThriftId(fieldId);
6395 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6396 return fields;
6397 }
6398
6399
6400
6401
6402 public static _Fields findByName(String name) {
6403 return byName.get(name);
6404 }
6405
6406 private final short _thriftId;
6407 private final String _fieldName;
6408
6409 _Fields(short thriftId, String fieldName) {
6410 _thriftId = thriftId;
6411 _fieldName = fieldName;
6412 }
6413
6414 public short getThriftFieldId() {
6415 return _thriftId;
6416 }
6417
6418 public String getFieldName() {
6419 return _fieldName;
6420 }
6421 }
6422
6423
6424
6425 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6426 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
6427 new ListMetaData(TType.LIST,
6428 new FieldValueMetaData(TType.STRING))));
6429 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
6430 new FieldValueMetaData(TType.STRUCT)));
6431 }});
6432
6433 static {
6434 FieldMetaData.addStructMetaDataMap(getTableNames_result.class, metaDataMap);
6435 }
6436
6437 public getTableNames_result() {
6438 }
6439
6440 public getTableNames_result(
6441 List<byte[]> success,
6442 IOError io)
6443 {
6444 this();
6445 this.success = success;
6446 this.io = io;
6447 }
6448
6449
6450
6451
6452 public getTableNames_result(getTableNames_result other) {
6453 if (other.isSetSuccess()) {
6454 List<byte[]> __this__success = new ArrayList<byte[]>();
6455 for (byte[] other_element : other.success) {
6456 __this__success.add(other_element);
6457 }
6458 this.success = __this__success;
6459 }
6460 if (other.isSetIo()) {
6461 this.io = new IOError(other.io);
6462 }
6463 }
6464
6465 public getTableNames_result deepCopy() {
6466 return new getTableNames_result(this);
6467 }
6468
6469 @Deprecated
6470 public getTableNames_result clone() {
6471 return new getTableNames_result(this);
6472 }
6473
6474 public int getSuccessSize() {
6475 return (this.success == null) ? 0 : this.success.size();
6476 }
6477
6478 public java.util.Iterator<byte[]> getSuccessIterator() {
6479 return (this.success == null) ? null : this.success.iterator();
6480 }
6481
6482 public void addToSuccess(byte[] elem) {
6483 if (this.success == null) {
6484 this.success = new ArrayList<byte[]>();
6485 }
6486 this.success.add(elem);
6487 }
6488
6489 public List<byte[]> getSuccess() {
6490 return this.success;
6491 }
6492
6493 public getTableNames_result setSuccess(List<byte[]> success) {
6494 this.success = success;
6495 return this;
6496 }
6497
6498 public void unsetSuccess() {
6499 this.success = null;
6500 }
6501
6502
6503 public boolean isSetSuccess() {
6504 return this.success != null;
6505 }
6506
6507 public void setSuccessIsSet(boolean value) {
6508 if (!value) {
6509 this.success = null;
6510 }
6511 }
6512
6513 public IOError getIo() {
6514 return this.io;
6515 }
6516
6517 public getTableNames_result setIo(IOError io) {
6518 this.io = io;
6519 return this;
6520 }
6521
6522 public void unsetIo() {
6523 this.io = null;
6524 }
6525
6526
6527 public boolean isSetIo() {
6528 return this.io != null;
6529 }
6530
6531 public void setIoIsSet(boolean value) {
6532 if (!value) {
6533 this.io = null;
6534 }
6535 }
6536
6537 public void setFieldValue(_Fields field, Object value) {
6538 switch (field) {
6539 case SUCCESS:
6540 if (value == null) {
6541 unsetSuccess();
6542 } else {
6543 setSuccess((List<byte[]>)value);
6544 }
6545 break;
6546
6547 case IO:
6548 if (value == null) {
6549 unsetIo();
6550 } else {
6551 setIo((IOError)value);
6552 }
6553 break;
6554
6555 }
6556 }
6557
6558 public void setFieldValue(int fieldID, Object value) {
6559 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6560 }
6561
6562 public Object getFieldValue(_Fields field) {
6563 switch (field) {
6564 case SUCCESS:
6565 return getSuccess();
6566
6567 case IO:
6568 return getIo();
6569
6570 }
6571 throw new IllegalStateException();
6572 }
6573
6574 public Object getFieldValue(int fieldId) {
6575 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6576 }
6577
6578
6579 public boolean isSet(_Fields field) {
6580 switch (field) {
6581 case SUCCESS:
6582 return isSetSuccess();
6583 case IO:
6584 return isSetIo();
6585 }
6586 throw new IllegalStateException();
6587 }
6588
6589 public boolean isSet(int fieldID) {
6590 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6591 }
6592
6593 @Override
6594 public boolean equals(Object that) {
6595 if (that == null)
6596 return false;
6597 if (that instanceof getTableNames_result)
6598 return this.equals((getTableNames_result)that);
6599 return false;
6600 }
6601
6602 public boolean equals(getTableNames_result that) {
6603 if (that == null)
6604 return false;
6605
6606 boolean this_present_success = true && this.isSetSuccess();
6607 boolean that_present_success = true && that.isSetSuccess();
6608 if (this_present_success || that_present_success) {
6609 if (!(this_present_success && that_present_success))
6610 return false;
6611 if (!this.success.equals(that.success))
6612 return false;
6613 }
6614
6615 boolean this_present_io = true && this.isSetIo();
6616 boolean that_present_io = true && that.isSetIo();
6617 if (this_present_io || that_present_io) {
6618 if (!(this_present_io && that_present_io))
6619 return false;
6620 if (!this.io.equals(that.io))
6621 return false;
6622 }
6623
6624 return true;
6625 }
6626
6627 @Override
6628 public int hashCode() {
6629 HashCodeBuilder builder = new HashCodeBuilder();
6630
6631 boolean present_success = true && (isSetSuccess());
6632 builder.append(present_success);
6633 if (present_success)
6634 builder.append(success);
6635
6636 boolean present_io = true && (isSetIo());
6637 builder.append(present_io);
6638 if (present_io)
6639 builder.append(io);
6640
6641 return builder.toHashCode();
6642 }
6643
6644 public int compareTo(getTableNames_result other) {
6645 if (!getClass().equals(other.getClass())) {
6646 return getClass().getName().compareTo(other.getClass().getName());
6647 }
6648
6649 int lastComparison = 0;
6650 getTableNames_result typedOther = (getTableNames_result)other;
6651
6652 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
6653 if (lastComparison != 0) {
6654 return lastComparison;
6655 }
6656 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
6657 if (lastComparison != 0) {
6658 return lastComparison;
6659 }
6660 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
6661 if (lastComparison != 0) {
6662 return lastComparison;
6663 }
6664 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
6665 if (lastComparison != 0) {
6666 return lastComparison;
6667 }
6668 return 0;
6669 }
6670
6671 public void read(TProtocol iprot) throws TException {
6672 TField field;
6673 iprot.readStructBegin();
6674 while (true)
6675 {
6676 field = iprot.readFieldBegin();
6677 if (field.type == TType.STOP) {
6678 break;
6679 }
6680 _Fields fieldId = _Fields.findByThriftId(field.id);
6681 if (fieldId == null) {
6682 TProtocolUtil.skip(iprot, field.type);
6683 } else {
6684 switch (fieldId) {
6685 case SUCCESS:
6686 if (field.type == TType.LIST) {
6687 {
6688 TList _list9 = iprot.readListBegin();
6689 this.success = new ArrayList<byte[]>(_list9.size);
6690 for (int _i10 = 0; _i10 < _list9.size; ++_i10)
6691 {
6692 byte[] _elem11;
6693 _elem11 = iprot.readBinary();
6694 this.success.add(_elem11);
6695 }
6696 iprot.readListEnd();
6697 }
6698 } else {
6699 TProtocolUtil.skip(iprot, field.type);
6700 }
6701 break;
6702 case IO:
6703 if (field.type == TType.STRUCT) {
6704 this.io = new IOError();
6705 this.io.read(iprot);
6706 } else {
6707 TProtocolUtil.skip(iprot, field.type);
6708 }
6709 break;
6710 }
6711 iprot.readFieldEnd();
6712 }
6713 }
6714 iprot.readStructEnd();
6715
6716
6717 validate();
6718 }
6719
6720 public void write(TProtocol oprot) throws TException {
6721 oprot.writeStructBegin(STRUCT_DESC);
6722
6723 if (this.isSetSuccess()) {
6724 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6725 {
6726 oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
6727 for (byte[] _iter12 : this.success)
6728 {
6729 oprot.writeBinary(_iter12);
6730 }
6731 oprot.writeListEnd();
6732 }
6733 oprot.writeFieldEnd();
6734 } else if (this.isSetIo()) {
6735 oprot.writeFieldBegin(IO_FIELD_DESC);
6736 this.io.write(oprot);
6737 oprot.writeFieldEnd();
6738 }
6739 oprot.writeFieldStop();
6740 oprot.writeStructEnd();
6741 }
6742
6743 @Override
6744 public String toString() {
6745 StringBuilder sb = new StringBuilder("getTableNames_result(");
6746 boolean first = true;
6747
6748 sb.append("success:");
6749 if (this.success == null) {
6750 sb.append("null");
6751 } else {
6752 sb.append(this.success);
6753 }
6754 first = false;
6755 if (!first) sb.append(", ");
6756 sb.append("io:");
6757 if (this.io == null) {
6758 sb.append("null");
6759 } else {
6760 sb.append(this.io);
6761 }
6762 first = false;
6763 sb.append(")");
6764 return sb.toString();
6765 }
6766
6767 public void validate() throws TException {
6768
6769 }
6770
6771 }
6772
6773 public static class getColumnDescriptors_args implements TBase<getColumnDescriptors_args._Fields>, java.io.Serializable, Cloneable, Comparable<getColumnDescriptors_args> {
6774 private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_args");
6775
6776 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
6777
6778
6779
6780
6781 public byte[] tableName;
6782
6783
6784 public enum _Fields implements TFieldIdEnum {
6785
6786
6787
6788 TABLE_NAME((short)1, "tableName");
6789
6790 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6791 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6792
6793 static {
6794 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6795 byId.put((int)field._thriftId, field);
6796 byName.put(field.getFieldName(), field);
6797 }
6798 }
6799
6800
6801
6802
6803 public static _Fields findByThriftId(int fieldId) {
6804 return byId.get(fieldId);
6805 }
6806
6807
6808
6809
6810
6811 public static _Fields findByThriftIdOrThrow(int fieldId) {
6812 _Fields fields = findByThriftId(fieldId);
6813 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6814 return fields;
6815 }
6816
6817
6818
6819
6820 public static _Fields findByName(String name) {
6821 return byName.get(name);
6822 }
6823
6824 private final short _thriftId;
6825 private final String _fieldName;
6826
6827 _Fields(short thriftId, String fieldName) {
6828 _thriftId = thriftId;
6829 _fieldName = fieldName;
6830 }
6831
6832 public short getThriftFieldId() {
6833 return _thriftId;
6834 }
6835
6836 public String getFieldName() {
6837 return _fieldName;
6838 }
6839 }
6840
6841
6842
6843 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6844 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
6845 new FieldValueMetaData(TType.STRING)));
6846 }});
6847
6848 static {
6849 FieldMetaData.addStructMetaDataMap(getColumnDescriptors_args.class, metaDataMap);
6850 }
6851
6852 public getColumnDescriptors_args() {
6853 }
6854
6855 public getColumnDescriptors_args(
6856 byte[] tableName)
6857 {
6858 this();
6859 this.tableName = tableName;
6860 }
6861
6862
6863
6864
6865 public getColumnDescriptors_args(getColumnDescriptors_args other) {
6866 if (other.isSetTableName()) {
6867 this.tableName = other.tableName;
6868 }
6869 }
6870
6871 public getColumnDescriptors_args deepCopy() {
6872 return new getColumnDescriptors_args(this);
6873 }
6874
6875 @Deprecated
6876 public getColumnDescriptors_args clone() {
6877 return new getColumnDescriptors_args(this);
6878 }
6879
6880
6881
6882
6883 public byte[] getTableName() {
6884 return this.tableName;
6885 }
6886
6887
6888
6889
6890 public getColumnDescriptors_args setTableName(byte[] tableName) {
6891 this.tableName = tableName;
6892 return this;
6893 }
6894
6895 public void unsetTableName() {
6896 this.tableName = null;
6897 }
6898
6899
6900 public boolean isSetTableName() {
6901 return this.tableName != null;
6902 }
6903
6904 public void setTableNameIsSet(boolean value) {
6905 if (!value) {
6906 this.tableName = null;
6907 }
6908 }
6909
6910 public void setFieldValue(_Fields field, Object value) {
6911 switch (field) {
6912 case TABLE_NAME:
6913 if (value == null) {
6914 unsetTableName();
6915 } else {
6916 setTableName((byte[])value);
6917 }
6918 break;
6919
6920 }
6921 }
6922
6923 public void setFieldValue(int fieldID, Object value) {
6924 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6925 }
6926
6927 public Object getFieldValue(_Fields field) {
6928 switch (field) {
6929 case TABLE_NAME:
6930 return getTableName();
6931
6932 }
6933 throw new IllegalStateException();
6934 }
6935
6936 public Object getFieldValue(int fieldId) {
6937 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6938 }
6939
6940
6941 public boolean isSet(_Fields field) {
6942 switch (field) {
6943 case TABLE_NAME:
6944 return isSetTableName();
6945 }
6946 throw new IllegalStateException();
6947 }
6948
6949 public boolean isSet(int fieldID) {
6950 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6951 }
6952
6953 @Override
6954 public boolean equals(Object that) {
6955 if (that == null)
6956 return false;
6957 if (that instanceof getColumnDescriptors_args)
6958 return this.equals((getColumnDescriptors_args)that);
6959 return false;
6960 }
6961
6962 public boolean equals(getColumnDescriptors_args that) {
6963 if (that == null)
6964 return false;
6965
6966 boolean this_present_tableName = true && this.isSetTableName();
6967 boolean that_present_tableName = true && that.isSetTableName();
6968 if (this_present_tableName || that_present_tableName) {
6969 if (!(this_present_tableName && that_present_tableName))
6970 return false;
6971 if (!java.util.Arrays.equals(this.tableName, that.tableName))
6972 return false;
6973 }
6974
6975 return true;
6976 }
6977
6978 @Override
6979 public int hashCode() {
6980 HashCodeBuilder builder = new HashCodeBuilder();
6981
6982 boolean present_tableName = true && (isSetTableName());
6983 builder.append(present_tableName);
6984 if (present_tableName)
6985 builder.append(tableName);
6986
6987 return builder.toHashCode();
6988 }
6989
6990 public int compareTo(getColumnDescriptors_args other) {
6991 if (!getClass().equals(other.getClass())) {
6992 return getClass().getName().compareTo(other.getClass().getName());
6993 }
6994
6995 int lastComparison = 0;
6996 getColumnDescriptors_args typedOther = (getColumnDescriptors_args)other;
6997
6998 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
6999 if (lastComparison != 0) {
7000 return lastComparison;
7001 }
7002 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
7003 if (lastComparison != 0) {
7004 return lastComparison;
7005 }
7006 return 0;
7007 }
7008
7009 public void read(TProtocol iprot) throws TException {
7010 TField field;
7011 iprot.readStructBegin();
7012 while (true)
7013 {
7014 field = iprot.readFieldBegin();
7015 if (field.type == TType.STOP) {
7016 break;
7017 }
7018 _Fields fieldId = _Fields.findByThriftId(field.id);
7019 if (fieldId == null) {
7020 TProtocolUtil.skip(iprot, field.type);
7021 } else {
7022 switch (fieldId) {
7023 case TABLE_NAME:
7024 if (field.type == TType.STRING) {
7025 this.tableName = iprot.readBinary();
7026 } else {
7027 TProtocolUtil.skip(iprot, field.type);
7028 }
7029 break;
7030 }
7031 iprot.readFieldEnd();
7032 }
7033 }
7034 iprot.readStructEnd();
7035
7036
7037 validate();
7038 }
7039
7040 public void write(TProtocol oprot) throws TException {
7041 validate();
7042
7043 oprot.writeStructBegin(STRUCT_DESC);
7044 if (this.tableName != null) {
7045 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
7046 oprot.writeBinary(this.tableName);
7047 oprot.writeFieldEnd();
7048 }
7049 oprot.writeFieldStop();
7050 oprot.writeStructEnd();
7051 }
7052
7053 @Override
7054 public String toString() {
7055 StringBuilder sb = new StringBuilder("getColumnDescriptors_args(");
7056 boolean first = true;
7057
7058 sb.append("tableName:");
7059 if (this.tableName == null) {
7060 sb.append("null");
7061 } else {
7062 sb.append(this.tableName);
7063 }
7064 first = false;
7065 sb.append(")");
7066 return sb.toString();
7067 }
7068
7069 public void validate() throws TException {
7070
7071 }
7072
7073 }
7074
7075 public static class getColumnDescriptors_result implements TBase<getColumnDescriptors_result._Fields>, java.io.Serializable, Cloneable {
7076 private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_result");
7077
7078 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.MAP, (short)0);
7079 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
7080
7081 public Map<byte[],ColumnDescriptor> success;
7082 public IOError io;
7083
7084
7085 public enum _Fields implements TFieldIdEnum {
7086 SUCCESS((short)0, "success"),
7087 IO((short)1, "io");
7088
7089 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7090 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7091
7092 static {
7093 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7094 byId.put((int)field._thriftId, field);
7095 byName.put(field.getFieldName(), field);
7096 }
7097 }
7098
7099
7100
7101
7102 public static _Fields findByThriftId(int fieldId) {
7103 return byId.get(fieldId);
7104 }
7105
7106
7107
7108
7109
7110 public static _Fields findByThriftIdOrThrow(int fieldId) {
7111 _Fields fields = findByThriftId(fieldId);
7112 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7113 return fields;
7114 }
7115
7116
7117
7118
7119 public static _Fields findByName(String name) {
7120 return byName.get(name);
7121 }
7122
7123 private final short _thriftId;
7124 private final String _fieldName;
7125
7126 _Fields(short thriftId, String fieldName) {
7127 _thriftId = thriftId;
7128 _fieldName = fieldName;
7129 }
7130
7131 public short getThriftFieldId() {
7132 return _thriftId;
7133 }
7134
7135 public String getFieldName() {
7136 return _fieldName;
7137 }
7138 }
7139
7140
7141
7142 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7143 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
7144 new MapMetaData(TType.MAP,
7145 new FieldValueMetaData(TType.STRING),
7146 new StructMetaData(TType.STRUCT, ColumnDescriptor.class))));
7147 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
7148 new FieldValueMetaData(TType.STRUCT)));
7149 }});
7150
7151 static {
7152 FieldMetaData.addStructMetaDataMap(getColumnDescriptors_result.class, metaDataMap);
7153 }
7154
7155 public getColumnDescriptors_result() {
7156 }
7157
7158 public getColumnDescriptors_result(
7159 Map<byte[],ColumnDescriptor> success,
7160 IOError io)
7161 {
7162 this();
7163 this.success = success;
7164 this.io = io;
7165 }
7166
7167
7168
7169
7170 public getColumnDescriptors_result(getColumnDescriptors_result other) {
7171 if (other.isSetSuccess()) {
7172 Map<byte[],ColumnDescriptor> __this__success = new HashMap<byte[],ColumnDescriptor>();
7173 for (Map.Entry<byte[], ColumnDescriptor> other_element : other.success.entrySet()) {
7174
7175 byte[] other_element_key = other_element.getKey();
7176 ColumnDescriptor other_element_value = other_element.getValue();
7177
7178 byte[] __this__success_copy_key = other_element_key;
7179
7180 ColumnDescriptor __this__success_copy_value = new ColumnDescriptor(other_element_value);
7181
7182 __this__success.put(__this__success_copy_key, __this__success_copy_value);
7183 }
7184 this.success = __this__success;
7185 }
7186 if (other.isSetIo()) {
7187 this.io = new IOError(other.io);
7188 }
7189 }
7190
7191 public getColumnDescriptors_result deepCopy() {
7192 return new getColumnDescriptors_result(this);
7193 }
7194
7195 @Deprecated
7196 public getColumnDescriptors_result clone() {
7197 return new getColumnDescriptors_result(this);
7198 }
7199
7200 public int getSuccessSize() {
7201 return (this.success == null) ? 0 : this.success.size();
7202 }
7203
7204 public void putToSuccess(byte[] key, ColumnDescriptor val) {
7205 if (this.success == null) {
7206 this.success = new HashMap<byte[],ColumnDescriptor>();
7207 }
7208 this.success.put(key, val);
7209 }
7210
7211 public Map<byte[],ColumnDescriptor> getSuccess() {
7212 return this.success;
7213 }
7214
7215 public getColumnDescriptors_result setSuccess(Map<byte[],ColumnDescriptor> success) {
7216 this.success = success;
7217 return this;
7218 }
7219
7220 public void unsetSuccess() {
7221 this.success = null;
7222 }
7223
7224
7225 public boolean isSetSuccess() {
7226 return this.success != null;
7227 }
7228
7229 public void setSuccessIsSet(boolean value) {
7230 if (!value) {
7231 this.success = null;
7232 }
7233 }
7234
7235 public IOError getIo() {
7236 return this.io;
7237 }
7238
7239 public getColumnDescriptors_result setIo(IOError io) {
7240 this.io = io;
7241 return this;
7242 }
7243
7244 public void unsetIo() {
7245 this.io = null;
7246 }
7247
7248
7249 public boolean isSetIo() {
7250 return this.io != null;
7251 }
7252
7253 public void setIoIsSet(boolean value) {
7254 if (!value) {
7255 this.io = null;
7256 }
7257 }
7258
7259 public void setFieldValue(_Fields field, Object value) {
7260 switch (field) {
7261 case SUCCESS:
7262 if (value == null) {
7263 unsetSuccess();
7264 } else {
7265 setSuccess((Map<byte[],ColumnDescriptor>)value);
7266 }
7267 break;
7268
7269 case IO:
7270 if (value == null) {
7271 unsetIo();
7272 } else {
7273 setIo((IOError)value);
7274 }
7275 break;
7276
7277 }
7278 }
7279
7280 public void setFieldValue(int fieldID, Object value) {
7281 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7282 }
7283
7284 public Object getFieldValue(_Fields field) {
7285 switch (field) {
7286 case SUCCESS:
7287 return getSuccess();
7288
7289 case IO:
7290 return getIo();
7291
7292 }
7293 throw new IllegalStateException();
7294 }
7295
7296 public Object getFieldValue(int fieldId) {
7297 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7298 }
7299
7300
7301 public boolean isSet(_Fields field) {
7302 switch (field) {
7303 case SUCCESS:
7304 return isSetSuccess();
7305 case IO:
7306 return isSetIo();
7307 }
7308 throw new IllegalStateException();
7309 }
7310
7311 public boolean isSet(int fieldID) {
7312 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
7313 }
7314
7315 @Override
7316 public boolean equals(Object that) {
7317 if (that == null)
7318 return false;
7319 if (that instanceof getColumnDescriptors_result)
7320 return this.equals((getColumnDescriptors_result)that);
7321 return false;
7322 }
7323
7324 public boolean equals(getColumnDescriptors_result that) {
7325 if (that == null)
7326 return false;
7327
7328 boolean this_present_success = true && this.isSetSuccess();
7329 boolean that_present_success = true && that.isSetSuccess();
7330 if (this_present_success || that_present_success) {
7331 if (!(this_present_success && that_present_success))
7332 return false;
7333 if (!this.success.equals(that.success))
7334 return false;
7335 }
7336
7337 boolean this_present_io = true && this.isSetIo();
7338 boolean that_present_io = true && that.isSetIo();
7339 if (this_present_io || that_present_io) {
7340 if (!(this_present_io && that_present_io))
7341 return false;
7342 if (!this.io.equals(that.io))
7343 return false;
7344 }
7345
7346 return true;
7347 }
7348
7349 @Override
7350 public int hashCode() {
7351 HashCodeBuilder builder = new HashCodeBuilder();
7352
7353 boolean present_success = true && (isSetSuccess());
7354 builder.append(present_success);
7355 if (present_success)
7356 builder.append(success);
7357
7358 boolean present_io = true && (isSetIo());
7359 builder.append(present_io);
7360 if (present_io)
7361 builder.append(io);
7362
7363 return builder.toHashCode();
7364 }
7365
7366 public void read(TProtocol iprot) throws TException {
7367 TField field;
7368 iprot.readStructBegin();
7369 while (true)
7370 {
7371 field = iprot.readFieldBegin();
7372 if (field.type == TType.STOP) {
7373 break;
7374 }
7375 _Fields fieldId = _Fields.findByThriftId(field.id);
7376 if (fieldId == null) {
7377 TProtocolUtil.skip(iprot, field.type);
7378 } else {
7379 switch (fieldId) {
7380 case SUCCESS:
7381 if (field.type == TType.MAP) {
7382 {
7383 TMap _map13 = iprot.readMapBegin();
7384 this.success = new HashMap<byte[],ColumnDescriptor>(2*_map13.size);
7385 for (int _i14 = 0; _i14 < _map13.size; ++_i14)
7386 {
7387 byte[] _key15;
7388 ColumnDescriptor _val16;
7389 _key15 = iprot.readBinary();
7390 _val16 = new ColumnDescriptor();
7391 _val16.read(iprot);
7392 this.success.put(_key15, _val16);
7393 }
7394 iprot.readMapEnd();
7395 }
7396 } else {
7397 TProtocolUtil.skip(iprot, field.type);
7398 }
7399 break;
7400 case IO:
7401 if (field.type == TType.STRUCT) {
7402 this.io = new IOError();
7403 this.io.read(iprot);
7404 } else {
7405 TProtocolUtil.skip(iprot, field.type);
7406 }
7407 break;
7408 }
7409 iprot.readFieldEnd();
7410 }
7411 }
7412 iprot.readStructEnd();
7413
7414
7415 validate();
7416 }
7417
7418 public void write(TProtocol oprot) throws TException {
7419 oprot.writeStructBegin(STRUCT_DESC);
7420
7421 if (this.isSetSuccess()) {
7422 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
7423 {
7424 oprot.writeMapBegin(new TMap(TType.STRING, TType.STRUCT, this.success.size()));
7425 for (Map.Entry<byte[], ColumnDescriptor> _iter17 : this.success.entrySet())
7426 {
7427 oprot.writeBinary(_iter17.getKey());
7428 _iter17.getValue().write(oprot);
7429 }
7430 oprot.writeMapEnd();
7431 }
7432 oprot.writeFieldEnd();
7433 } else if (this.isSetIo()) {
7434 oprot.writeFieldBegin(IO_FIELD_DESC);
7435 this.io.write(oprot);
7436 oprot.writeFieldEnd();
7437 }
7438 oprot.writeFieldStop();
7439 oprot.writeStructEnd();
7440 }
7441
7442 @Override
7443 public String toString() {
7444 StringBuilder sb = new StringBuilder("getColumnDescriptors_result(");
7445 boolean first = true;
7446
7447 sb.append("success:");
7448 if (this.success == null) {
7449 sb.append("null");
7450 } else {
7451 sb.append(this.success);
7452 }
7453 first = false;
7454 if (!first) sb.append(", ");
7455 sb.append("io:");
7456 if (this.io == null) {
7457 sb.append("null");
7458 } else {
7459 sb.append(this.io);
7460 }
7461 first = false;
7462 sb.append(")");
7463 return sb.toString();
7464 }
7465
7466 public void validate() throws TException {
7467
7468 }
7469
7470 }
7471
7472 public static class getTableRegions_args implements TBase<getTableRegions_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_args> {
7473 private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_args");
7474
7475 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
7476
7477
7478
7479
7480 public byte[] tableName;
7481
7482
7483 public enum _Fields implements TFieldIdEnum {
7484
7485
7486
7487 TABLE_NAME((short)1, "tableName");
7488
7489 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7490 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7491
7492 static {
7493 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7494 byId.put((int)field._thriftId, field);
7495 byName.put(field.getFieldName(), field);
7496 }
7497 }
7498
7499
7500
7501
7502 public static _Fields findByThriftId(int fieldId) {
7503 return byId.get(fieldId);
7504 }
7505
7506
7507
7508
7509
7510 public static _Fields findByThriftIdOrThrow(int fieldId) {
7511 _Fields fields = findByThriftId(fieldId);
7512 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7513 return fields;
7514 }
7515
7516
7517
7518
7519 public static _Fields findByName(String name) {
7520 return byName.get(name);
7521 }
7522
7523 private final short _thriftId;
7524 private final String _fieldName;
7525
7526 _Fields(short thriftId, String fieldName) {
7527 _thriftId = thriftId;
7528 _fieldName = fieldName;
7529 }
7530
7531 public short getThriftFieldId() {
7532 return _thriftId;
7533 }
7534
7535 public String getFieldName() {
7536 return _fieldName;
7537 }
7538 }
7539
7540
7541
7542 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7543 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
7544 new FieldValueMetaData(TType.STRING)));
7545 }});
7546
7547 static {
7548 FieldMetaData.addStructMetaDataMap(getTableRegions_args.class, metaDataMap);
7549 }
7550
7551 public getTableRegions_args() {
7552 }
7553
7554 public getTableRegions_args(
7555 byte[] tableName)
7556 {
7557 this();
7558 this.tableName = tableName;
7559 }
7560
7561
7562
7563
7564 public getTableRegions_args(getTableRegions_args other) {
7565 if (other.isSetTableName()) {
7566 this.tableName = other.tableName;
7567 }
7568 }
7569
7570 public getTableRegions_args deepCopy() {
7571 return new getTableRegions_args(this);
7572 }
7573
7574 @Deprecated
7575 public getTableRegions_args clone() {
7576 return new getTableRegions_args(this);
7577 }
7578
7579
7580
7581
7582 public byte[] getTableName() {
7583 return this.tableName;
7584 }
7585
7586
7587
7588
7589 public getTableRegions_args setTableName(byte[] tableName) {
7590 this.tableName = tableName;
7591 return this;
7592 }
7593
7594 public void unsetTableName() {
7595 this.tableName = null;
7596 }
7597
7598
7599 public boolean isSetTableName() {
7600 return this.tableName != null;
7601 }
7602
7603 public void setTableNameIsSet(boolean value) {
7604 if (!value) {
7605 this.tableName = null;
7606 }
7607 }
7608
7609 public void setFieldValue(_Fields field, Object value) {
7610 switch (field) {
7611 case TABLE_NAME:
7612 if (value == null) {
7613 unsetTableName();
7614 } else {
7615 setTableName((byte[])value);
7616 }
7617 break;
7618
7619 }
7620 }
7621
7622 public void setFieldValue(int fieldID, Object value) {
7623 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7624 }
7625
7626 public Object getFieldValue(_Fields field) {
7627 switch (field) {
7628 case TABLE_NAME:
7629 return getTableName();
7630
7631 }
7632 throw new IllegalStateException();
7633 }
7634
7635 public Object getFieldValue(int fieldId) {
7636 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7637 }
7638
7639
7640 public boolean isSet(_Fields field) {
7641 switch (field) {
7642 case TABLE_NAME:
7643 return isSetTableName();
7644 }
7645 throw new IllegalStateException();
7646 }
7647
7648 public boolean isSet(int fieldID) {
7649 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
7650 }
7651
7652 @Override
7653 public boolean equals(Object that) {
7654 if (that == null)
7655 return false;
7656 if (that instanceof getTableRegions_args)
7657 return this.equals((getTableRegions_args)that);
7658 return false;
7659 }
7660
7661 public boolean equals(getTableRegions_args that) {
7662 if (that == null)
7663 return false;
7664
7665 boolean this_present_tableName = true && this.isSetTableName();
7666 boolean that_present_tableName = true && that.isSetTableName();
7667 if (this_present_tableName || that_present_tableName) {
7668 if (!(this_present_tableName && that_present_tableName))
7669 return false;
7670 if (!java.util.Arrays.equals(this.tableName, that.tableName))
7671 return false;
7672 }
7673
7674 return true;
7675 }
7676
7677 @Override
7678 public int hashCode() {
7679 HashCodeBuilder builder = new HashCodeBuilder();
7680
7681 boolean present_tableName = true && (isSetTableName());
7682 builder.append(present_tableName);
7683 if (present_tableName)
7684 builder.append(tableName);
7685
7686 return builder.toHashCode();
7687 }
7688
7689 public int compareTo(getTableRegions_args other) {
7690 if (!getClass().equals(other.getClass())) {
7691 return getClass().getName().compareTo(other.getClass().getName());
7692 }
7693
7694 int lastComparison = 0;
7695 getTableRegions_args typedOther = (getTableRegions_args)other;
7696
7697 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
7698 if (lastComparison != 0) {
7699 return lastComparison;
7700 }
7701 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
7702 if (lastComparison != 0) {
7703 return lastComparison;
7704 }
7705 return 0;
7706 }
7707
7708 public void read(TProtocol iprot) throws TException {
7709 TField field;
7710 iprot.readStructBegin();
7711 while (true)
7712 {
7713 field = iprot.readFieldBegin();
7714 if (field.type == TType.STOP) {
7715 break;
7716 }
7717 _Fields fieldId = _Fields.findByThriftId(field.id);
7718 if (fieldId == null) {
7719 TProtocolUtil.skip(iprot, field.type);
7720 } else {
7721 switch (fieldId) {
7722 case TABLE_NAME:
7723 if (field.type == TType.STRING) {
7724 this.tableName = iprot.readBinary();
7725 } else {
7726 TProtocolUtil.skip(iprot, field.type);
7727 }
7728 break;
7729 }
7730 iprot.readFieldEnd();
7731 }
7732 }
7733 iprot.readStructEnd();
7734
7735
7736 validate();
7737 }
7738
7739 public void write(TProtocol oprot) throws TException {
7740 validate();
7741
7742 oprot.writeStructBegin(STRUCT_DESC);
7743 if (this.tableName != null) {
7744 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
7745 oprot.writeBinary(this.tableName);
7746 oprot.writeFieldEnd();
7747 }
7748 oprot.writeFieldStop();
7749 oprot.writeStructEnd();
7750 }
7751
7752 @Override
7753 public String toString() {
7754 StringBuilder sb = new StringBuilder("getTableRegions_args(");
7755 boolean first = true;
7756
7757 sb.append("tableName:");
7758 if (this.tableName == null) {
7759 sb.append("null");
7760 } else {
7761 sb.append(this.tableName);
7762 }
7763 first = false;
7764 sb.append(")");
7765 return sb.toString();
7766 }
7767
7768 public void validate() throws TException {
7769
7770 }
7771
7772 }
7773
7774 public static class getTableRegions_result implements TBase<getTableRegions_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_result> {
7775 private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_result");
7776
7777 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
7778 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
7779
7780 public List<TRegionInfo> success;
7781 public IOError io;
7782
7783
7784 public enum _Fields implements TFieldIdEnum {
7785 SUCCESS((short)0, "success"),
7786 IO((short)1, "io");
7787
7788 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7789 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7790
7791 static {
7792 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7793 byId.put((int)field._thriftId, field);
7794 byName.put(field.getFieldName(), field);
7795 }
7796 }
7797
7798
7799
7800
7801 public static _Fields findByThriftId(int fieldId) {
7802 return byId.get(fieldId);
7803 }
7804
7805
7806
7807
7808
7809 public static _Fields findByThriftIdOrThrow(int fieldId) {
7810 _Fields fields = findByThriftId(fieldId);
7811 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7812 return fields;
7813 }
7814
7815
7816
7817
7818 public static _Fields findByName(String name) {
7819 return byName.get(name);
7820 }
7821
7822 private final short _thriftId;
7823 private final String _fieldName;
7824
7825 _Fields(short thriftId, String fieldName) {
7826 _thriftId = thriftId;
7827 _fieldName = fieldName;
7828 }
7829
7830 public short getThriftFieldId() {
7831 return _thriftId;
7832 }
7833
7834 public String getFieldName() {
7835 return _fieldName;
7836 }
7837 }
7838
7839
7840
7841 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7842 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
7843 new ListMetaData(TType.LIST,
7844 new StructMetaData(TType.STRUCT, TRegionInfo.class))));
7845 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
7846 new FieldValueMetaData(TType.STRUCT)));
7847 }});
7848
7849 static {
7850 FieldMetaData.addStructMetaDataMap(getTableRegions_result.class, metaDataMap);
7851 }
7852
7853 public getTableRegions_result() {
7854 }
7855
7856 public getTableRegions_result(
7857 List<TRegionInfo> success,
7858 IOError io)
7859 {
7860 this();
7861 this.success = success;
7862 this.io = io;
7863 }
7864
7865
7866
7867
7868 public getTableRegions_result(getTableRegions_result other) {
7869 if (other.isSetSuccess()) {
7870 List<TRegionInfo> __this__success = new ArrayList<TRegionInfo>();
7871 for (TRegionInfo other_element : other.success) {
7872 __this__success.add(new TRegionInfo(other_element));
7873 }
7874 this.success = __this__success;
7875 }
7876 if (other.isSetIo()) {
7877 this.io = new IOError(other.io);
7878 }
7879 }
7880
7881 public getTableRegions_result deepCopy() {
7882 return new getTableRegions_result(this);
7883 }
7884
7885 @Deprecated
7886 public getTableRegions_result clone() {
7887 return new getTableRegions_result(this);
7888 }
7889
7890 public int getSuccessSize() {
7891 return (this.success == null) ? 0 : this.success.size();
7892 }
7893
7894 public java.util.Iterator<TRegionInfo> getSuccessIterator() {
7895 return (this.success == null) ? null : this.success.iterator();
7896 }
7897
7898 public void addToSuccess(TRegionInfo elem) {
7899 if (this.success == null) {
7900 this.success = new ArrayList<TRegionInfo>();
7901 }
7902 this.success.add(elem);
7903 }
7904
7905 public List<TRegionInfo> getSuccess() {
7906 return this.success;
7907 }
7908
7909 public getTableRegions_result setSuccess(List<TRegionInfo> success) {
7910 this.success = success;
7911 return this;
7912 }
7913
7914 public void unsetSuccess() {
7915 this.success = null;
7916 }
7917
7918
7919 public boolean isSetSuccess() {
7920 return this.success != null;
7921 }
7922
7923 public void setSuccessIsSet(boolean value) {
7924 if (!value) {
7925 this.success = null;
7926 }
7927 }
7928
7929 public IOError getIo() {
7930 return this.io;
7931 }
7932
7933 public getTableRegions_result setIo(IOError io) {
7934 this.io = io;
7935 return this;
7936 }
7937
7938 public void unsetIo() {
7939 this.io = null;
7940 }
7941
7942
7943 public boolean isSetIo() {
7944 return this.io != null;
7945 }
7946
7947 public void setIoIsSet(boolean value) {
7948 if (!value) {
7949 this.io = null;
7950 }
7951 }
7952
7953 public void setFieldValue(_Fields field, Object value) {
7954 switch (field) {
7955 case SUCCESS:
7956 if (value == null) {
7957 unsetSuccess();
7958 } else {
7959 setSuccess((List<TRegionInfo>)value);
7960 }
7961 break;
7962
7963 case IO:
7964 if (value == null) {
7965 unsetIo();
7966 } else {
7967 setIo((IOError)value);
7968 }
7969 break;
7970
7971 }
7972 }
7973
7974 public void setFieldValue(int fieldID, Object value) {
7975 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7976 }
7977
7978 public Object getFieldValue(_Fields field) {
7979 switch (field) {
7980 case SUCCESS:
7981 return getSuccess();
7982
7983 case IO:
7984 return getIo();
7985
7986 }
7987 throw new IllegalStateException();
7988 }
7989
7990 public Object getFieldValue(int fieldId) {
7991 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7992 }
7993
7994
7995 public boolean isSet(_Fields field) {
7996 switch (field) {
7997 case SUCCESS:
7998 return isSetSuccess();
7999 case IO:
8000 return isSetIo();
8001 }
8002 throw new IllegalStateException();
8003 }
8004
8005 public boolean isSet(int fieldID) {
8006 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8007 }
8008
8009 @Override
8010 public boolean equals(Object that) {
8011 if (that == null)
8012 return false;
8013 if (that instanceof getTableRegions_result)
8014 return this.equals((getTableRegions_result)that);
8015 return false;
8016 }
8017
8018 public boolean equals(getTableRegions_result that) {
8019 if (that == null)
8020 return false;
8021
8022 boolean this_present_success = true && this.isSetSuccess();
8023 boolean that_present_success = true && that.isSetSuccess();
8024 if (this_present_success || that_present_success) {
8025 if (!(this_present_success && that_present_success))
8026 return false;
8027 if (!this.success.equals(that.success))
8028 return false;
8029 }
8030
8031 boolean this_present_io = true && this.isSetIo();
8032 boolean that_present_io = true && that.isSetIo();
8033 if (this_present_io || that_present_io) {
8034 if (!(this_present_io && that_present_io))
8035 return false;
8036 if (!this.io.equals(that.io))
8037 return false;
8038 }
8039
8040 return true;
8041 }
8042
8043 @Override
8044 public int hashCode() {
8045 HashCodeBuilder builder = new HashCodeBuilder();
8046
8047 boolean present_success = true && (isSetSuccess());
8048 builder.append(present_success);
8049 if (present_success)
8050 builder.append(success);
8051
8052 boolean present_io = true && (isSetIo());
8053 builder.append(present_io);
8054 if (present_io)
8055 builder.append(io);
8056
8057 return builder.toHashCode();
8058 }
8059
8060 public int compareTo(getTableRegions_result other) {
8061 if (!getClass().equals(other.getClass())) {
8062 return getClass().getName().compareTo(other.getClass().getName());
8063 }
8064
8065 int lastComparison = 0;
8066 getTableRegions_result typedOther = (getTableRegions_result)other;
8067
8068 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
8069 if (lastComparison != 0) {
8070 return lastComparison;
8071 }
8072 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
8073 if (lastComparison != 0) {
8074 return lastComparison;
8075 }
8076 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
8077 if (lastComparison != 0) {
8078 return lastComparison;
8079 }
8080 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
8081 if (lastComparison != 0) {
8082 return lastComparison;
8083 }
8084 return 0;
8085 }
8086
8087 public void read(TProtocol iprot) throws TException {
8088 TField field;
8089 iprot.readStructBegin();
8090 while (true)
8091 {
8092 field = iprot.readFieldBegin();
8093 if (field.type == TType.STOP) {
8094 break;
8095 }
8096 _Fields fieldId = _Fields.findByThriftId(field.id);
8097 if (fieldId == null) {
8098 TProtocolUtil.skip(iprot, field.type);
8099 } else {
8100 switch (fieldId) {
8101 case SUCCESS:
8102 if (field.type == TType.LIST) {
8103 {
8104 TList _list18 = iprot.readListBegin();
8105 this.success = new ArrayList<TRegionInfo>(_list18.size);
8106 for (int _i19 = 0; _i19 < _list18.size; ++_i19)
8107 {
8108 TRegionInfo _elem20;
8109 _elem20 = new TRegionInfo();
8110 _elem20.read(iprot);
8111 this.success.add(_elem20);
8112 }
8113 iprot.readListEnd();
8114 }
8115 } else {
8116 TProtocolUtil.skip(iprot, field.type);
8117 }
8118 break;
8119 case IO:
8120 if (field.type == TType.STRUCT) {
8121 this.io = new IOError();
8122 this.io.read(iprot);
8123 } else {
8124 TProtocolUtil.skip(iprot, field.type);
8125 }
8126 break;
8127 }
8128 iprot.readFieldEnd();
8129 }
8130 }
8131 iprot.readStructEnd();
8132
8133
8134 validate();
8135 }
8136
8137 public void write(TProtocol oprot) throws TException {
8138 oprot.writeStructBegin(STRUCT_DESC);
8139
8140 if (this.isSetSuccess()) {
8141 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
8142 {
8143 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
8144 for (TRegionInfo _iter21 : this.success)
8145 {
8146 _iter21.write(oprot);
8147 }
8148 oprot.writeListEnd();
8149 }
8150 oprot.writeFieldEnd();
8151 } else if (this.isSetIo()) {
8152 oprot.writeFieldBegin(IO_FIELD_DESC);
8153 this.io.write(oprot);
8154 oprot.writeFieldEnd();
8155 }
8156 oprot.writeFieldStop();
8157 oprot.writeStructEnd();
8158 }
8159
8160 @Override
8161 public String toString() {
8162 StringBuilder sb = new StringBuilder("getTableRegions_result(");
8163 boolean first = true;
8164
8165 sb.append("success:");
8166 if (this.success == null) {
8167 sb.append("null");
8168 } else {
8169 sb.append(this.success);
8170 }
8171 first = false;
8172 if (!first) sb.append(", ");
8173 sb.append("io:");
8174 if (this.io == null) {
8175 sb.append("null");
8176 } else {
8177 sb.append(this.io);
8178 }
8179 first = false;
8180 sb.append(")");
8181 return sb.toString();
8182 }
8183
8184 public void validate() throws TException {
8185
8186 }
8187
8188 }
8189
8190 public static class createTable_args implements TBase<createTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_args> {
8191 private static final TStruct STRUCT_DESC = new TStruct("createTable_args");
8192
8193 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
8194 private static final TField COLUMN_FAMILIES_FIELD_DESC = new TField("columnFamilies", TType.LIST, (short)2);
8195
8196
8197
8198
8199 public byte[] tableName;
8200
8201
8202
8203 public List<ColumnDescriptor> columnFamilies;
8204
8205
8206 public enum _Fields implements TFieldIdEnum {
8207
8208
8209
8210 TABLE_NAME((short)1, "tableName"),
8211
8212
8213
8214 COLUMN_FAMILIES((short)2, "columnFamilies");
8215
8216 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
8217 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8218
8219 static {
8220 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8221 byId.put((int)field._thriftId, field);
8222 byName.put(field.getFieldName(), field);
8223 }
8224 }
8225
8226
8227
8228
8229 public static _Fields findByThriftId(int fieldId) {
8230 return byId.get(fieldId);
8231 }
8232
8233
8234
8235
8236
8237 public static _Fields findByThriftIdOrThrow(int fieldId) {
8238 _Fields fields = findByThriftId(fieldId);
8239 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8240 return fields;
8241 }
8242
8243
8244
8245
8246 public static _Fields findByName(String name) {
8247 return byName.get(name);
8248 }
8249
8250 private final short _thriftId;
8251 private final String _fieldName;
8252
8253 _Fields(short thriftId, String fieldName) {
8254 _thriftId = thriftId;
8255 _fieldName = fieldName;
8256 }
8257
8258 public short getThriftFieldId() {
8259 return _thriftId;
8260 }
8261
8262 public String getFieldName() {
8263 return _fieldName;
8264 }
8265 }
8266
8267
8268
8269 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
8270 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
8271 new FieldValueMetaData(TType.STRING)));
8272 put(_Fields.COLUMN_FAMILIES, new FieldMetaData("columnFamilies", TFieldRequirementType.DEFAULT,
8273 new ListMetaData(TType.LIST,
8274 new StructMetaData(TType.STRUCT, ColumnDescriptor.class))));
8275 }});
8276
8277 static {
8278 FieldMetaData.addStructMetaDataMap(createTable_args.class, metaDataMap);
8279 }
8280
8281 public createTable_args() {
8282 }
8283
8284 public createTable_args(
8285 byte[] tableName,
8286 List<ColumnDescriptor> columnFamilies)
8287 {
8288 this();
8289 this.tableName = tableName;
8290 this.columnFamilies = columnFamilies;
8291 }
8292
8293
8294
8295
8296 public createTable_args(createTable_args other) {
8297 if (other.isSetTableName()) {
8298 this.tableName = other.tableName;
8299 }
8300 if (other.isSetColumnFamilies()) {
8301 List<ColumnDescriptor> __this__columnFamilies = new ArrayList<ColumnDescriptor>();
8302 for (ColumnDescriptor other_element : other.columnFamilies) {
8303 __this__columnFamilies.add(new ColumnDescriptor(other_element));
8304 }
8305 this.columnFamilies = __this__columnFamilies;
8306 }
8307 }
8308
8309 public createTable_args deepCopy() {
8310 return new createTable_args(this);
8311 }
8312
8313 @Deprecated
8314 public createTable_args clone() {
8315 return new createTable_args(this);
8316 }
8317
8318
8319
8320
8321 public byte[] getTableName() {
8322 return this.tableName;
8323 }
8324
8325
8326
8327
8328 public createTable_args setTableName(byte[] tableName) {
8329 this.tableName = tableName;
8330 return this;
8331 }
8332
8333 public void unsetTableName() {
8334 this.tableName = null;
8335 }
8336
8337
8338 public boolean isSetTableName() {
8339 return this.tableName != null;
8340 }
8341
8342 public void setTableNameIsSet(boolean value) {
8343 if (!value) {
8344 this.tableName = null;
8345 }
8346 }
8347
8348 public int getColumnFamiliesSize() {
8349 return (this.columnFamilies == null) ? 0 : this.columnFamilies.size();
8350 }
8351
8352 public java.util.Iterator<ColumnDescriptor> getColumnFamiliesIterator() {
8353 return (this.columnFamilies == null) ? null : this.columnFamilies.iterator();
8354 }
8355
8356 public void addToColumnFamilies(ColumnDescriptor elem) {
8357 if (this.columnFamilies == null) {
8358 this.columnFamilies = new ArrayList<ColumnDescriptor>();
8359 }
8360 this.columnFamilies.add(elem);
8361 }
8362
8363
8364
8365
8366 public List<ColumnDescriptor> getColumnFamilies() {
8367 return this.columnFamilies;
8368 }
8369
8370
8371
8372
8373 public createTable_args setColumnFamilies(List<ColumnDescriptor> columnFamilies) {
8374 this.columnFamilies = columnFamilies;
8375 return this;
8376 }
8377
8378 public void unsetColumnFamilies() {
8379 this.columnFamilies = null;
8380 }
8381
8382
8383 public boolean isSetColumnFamilies() {
8384 return this.columnFamilies != null;
8385 }
8386
8387 public void setColumnFamiliesIsSet(boolean value) {
8388 if (!value) {
8389 this.columnFamilies = null;
8390 }
8391 }
8392
8393 public void setFieldValue(_Fields field, Object value) {
8394 switch (field) {
8395 case TABLE_NAME:
8396 if (value == null) {
8397 unsetTableName();
8398 } else {
8399 setTableName((byte[])value);
8400 }
8401 break;
8402
8403 case COLUMN_FAMILIES:
8404 if (value == null) {
8405 unsetColumnFamilies();
8406 } else {
8407 setColumnFamilies((List<ColumnDescriptor>)value);
8408 }
8409 break;
8410
8411 }
8412 }
8413
8414 public void setFieldValue(int fieldID, Object value) {
8415 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8416 }
8417
8418 public Object getFieldValue(_Fields field) {
8419 switch (field) {
8420 case TABLE_NAME:
8421 return getTableName();
8422
8423 case COLUMN_FAMILIES:
8424 return getColumnFamilies();
8425
8426 }
8427 throw new IllegalStateException();
8428 }
8429
8430 public Object getFieldValue(int fieldId) {
8431 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8432 }
8433
8434
8435 public boolean isSet(_Fields field) {
8436 switch (field) {
8437 case TABLE_NAME:
8438 return isSetTableName();
8439 case COLUMN_FAMILIES:
8440 return isSetColumnFamilies();
8441 }
8442 throw new IllegalStateException();
8443 }
8444
8445 public boolean isSet(int fieldID) {
8446 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8447 }
8448
8449 @Override
8450 public boolean equals(Object that) {
8451 if (that == null)
8452 return false;
8453 if (that instanceof createTable_args)
8454 return this.equals((createTable_args)that);
8455 return false;
8456 }
8457
8458 public boolean equals(createTable_args that) {
8459 if (that == null)
8460 return false;
8461
8462 boolean this_present_tableName = true && this.isSetTableName();
8463 boolean that_present_tableName = true && that.isSetTableName();
8464 if (this_present_tableName || that_present_tableName) {
8465 if (!(this_present_tableName && that_present_tableName))
8466 return false;
8467 if (!java.util.Arrays.equals(this.tableName, that.tableName))
8468 return false;
8469 }
8470
8471 boolean this_present_columnFamilies = true && this.isSetColumnFamilies();
8472 boolean that_present_columnFamilies = true && that.isSetColumnFamilies();
8473 if (this_present_columnFamilies || that_present_columnFamilies) {
8474 if (!(this_present_columnFamilies && that_present_columnFamilies))
8475 return false;
8476 if (!this.columnFamilies.equals(that.columnFamilies))
8477 return false;
8478 }
8479
8480 return true;
8481 }
8482
8483 @Override
8484 public int hashCode() {
8485 HashCodeBuilder builder = new HashCodeBuilder();
8486
8487 boolean present_tableName = true && (isSetTableName());
8488 builder.append(present_tableName);
8489 if (present_tableName)
8490 builder.append(tableName);
8491
8492 boolean present_columnFamilies = true && (isSetColumnFamilies());
8493 builder.append(present_columnFamilies);
8494 if (present_columnFamilies)
8495 builder.append(columnFamilies);
8496
8497 return builder.toHashCode();
8498 }
8499
8500 public int compareTo(createTable_args other) {
8501 if (!getClass().equals(other.getClass())) {
8502 return getClass().getName().compareTo(other.getClass().getName());
8503 }
8504
8505 int lastComparison = 0;
8506 createTable_args typedOther = (createTable_args)other;
8507
8508 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
8509 if (lastComparison != 0) {
8510 return lastComparison;
8511 }
8512 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
8513 if (lastComparison != 0) {
8514 return lastComparison;
8515 }
8516 lastComparison = Boolean.valueOf(isSetColumnFamilies()).compareTo(isSetColumnFamilies());
8517 if (lastComparison != 0) {
8518 return lastComparison;
8519 }
8520 lastComparison = TBaseHelper.compareTo(columnFamilies, typedOther.columnFamilies);
8521 if (lastComparison != 0) {
8522 return lastComparison;
8523 }
8524 return 0;
8525 }
8526
8527 public void read(TProtocol iprot) throws TException {
8528 TField field;
8529 iprot.readStructBegin();
8530 while (true)
8531 {
8532 field = iprot.readFieldBegin();
8533 if (field.type == TType.STOP) {
8534 break;
8535 }
8536 _Fields fieldId = _Fields.findByThriftId(field.id);
8537 if (fieldId == null) {
8538 TProtocolUtil.skip(iprot, field.type);
8539 } else {
8540 switch (fieldId) {
8541 case TABLE_NAME:
8542 if (field.type == TType.STRING) {
8543 this.tableName = iprot.readBinary();
8544 } else {
8545 TProtocolUtil.skip(iprot, field.type);
8546 }
8547 break;
8548 case COLUMN_FAMILIES:
8549 if (field.type == TType.LIST) {
8550 {
8551 TList _list22 = iprot.readListBegin();
8552 this.columnFamilies = new ArrayList<ColumnDescriptor>(_list22.size);
8553 for (int _i23 = 0; _i23 < _list22.size; ++_i23)
8554 {
8555 ColumnDescriptor _elem24;
8556 _elem24 = new ColumnDescriptor();
8557 _elem24.read(iprot);
8558 this.columnFamilies.add(_elem24);
8559 }
8560 iprot.readListEnd();
8561 }
8562 } else {
8563 TProtocolUtil.skip(iprot, field.type);
8564 }
8565 break;
8566 }
8567 iprot.readFieldEnd();
8568 }
8569 }
8570 iprot.readStructEnd();
8571
8572
8573 validate();
8574 }
8575
8576 public void write(TProtocol oprot) throws TException {
8577 validate();
8578
8579 oprot.writeStructBegin(STRUCT_DESC);
8580 if (this.tableName != null) {
8581 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
8582 oprot.writeBinary(this.tableName);
8583 oprot.writeFieldEnd();
8584 }
8585 if (this.columnFamilies != null) {
8586 oprot.writeFieldBegin(COLUMN_FAMILIES_FIELD_DESC);
8587 {
8588 oprot.writeListBegin(new TList(TType.STRUCT, this.columnFamilies.size()));
8589 for (ColumnDescriptor _iter25 : this.columnFamilies)
8590 {
8591 _iter25.write(oprot);
8592 }
8593 oprot.writeListEnd();
8594 }
8595 oprot.writeFieldEnd();
8596 }
8597 oprot.writeFieldStop();
8598 oprot.writeStructEnd();
8599 }
8600
8601 @Override
8602 public String toString() {
8603 StringBuilder sb = new StringBuilder("createTable_args(");
8604 boolean first = true;
8605
8606 sb.append("tableName:");
8607 if (this.tableName == null) {
8608 sb.append("null");
8609 } else {
8610 sb.append(this.tableName);
8611 }
8612 first = false;
8613 if (!first) sb.append(", ");
8614 sb.append("columnFamilies:");
8615 if (this.columnFamilies == null) {
8616 sb.append("null");
8617 } else {
8618 sb.append(this.columnFamilies);
8619 }
8620 first = false;
8621 sb.append(")");
8622 return sb.toString();
8623 }
8624
8625 public void validate() throws TException {
8626
8627 }
8628
8629 }
8630
8631 public static class createTable_result implements TBase<createTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_result> {
8632 private static final TStruct STRUCT_DESC = new TStruct("createTable_result");
8633
8634 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
8635 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
8636 private static final TField EXIST_FIELD_DESC = new TField("exist", TType.STRUCT, (short)3);
8637
8638 public IOError io;
8639 public IllegalArgument ia;
8640 public AlreadyExists exist;
8641
8642
8643 public enum _Fields implements TFieldIdEnum {
8644 IO((short)1, "io"),
8645 IA((short)2, "ia"),
8646 EXIST((short)3, "exist");
8647
8648 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
8649 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8650
8651 static {
8652 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8653 byId.put((int)field._thriftId, field);
8654 byName.put(field.getFieldName(), field);
8655 }
8656 }
8657
8658
8659
8660
8661 public static _Fields findByThriftId(int fieldId) {
8662 return byId.get(fieldId);
8663 }
8664
8665
8666
8667
8668
8669 public static _Fields findByThriftIdOrThrow(int fieldId) {
8670 _Fields fields = findByThriftId(fieldId);
8671 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8672 return fields;
8673 }
8674
8675
8676
8677
8678 public static _Fields findByName(String name) {
8679 return byName.get(name);
8680 }
8681
8682 private final short _thriftId;
8683 private final String _fieldName;
8684
8685 _Fields(short thriftId, String fieldName) {
8686 _thriftId = thriftId;
8687 _fieldName = fieldName;
8688 }
8689
8690 public short getThriftFieldId() {
8691 return _thriftId;
8692 }
8693
8694 public String getFieldName() {
8695 return _fieldName;
8696 }
8697 }
8698
8699
8700
8701 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
8702 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
8703 new FieldValueMetaData(TType.STRUCT)));
8704 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
8705 new FieldValueMetaData(TType.STRUCT)));
8706 put(_Fields.EXIST, new FieldMetaData("exist", TFieldRequirementType.DEFAULT,
8707 new FieldValueMetaData(TType.STRUCT)));
8708 }});
8709
8710 static {
8711 FieldMetaData.addStructMetaDataMap(createTable_result.class, metaDataMap);
8712 }
8713
8714 public createTable_result() {
8715 }
8716
8717 public createTable_result(
8718 IOError io,
8719 IllegalArgument ia,
8720 AlreadyExists exist)
8721 {
8722 this();
8723 this.io = io;
8724 this.ia = ia;
8725 this.exist = exist;
8726 }
8727
8728
8729
8730
8731 public createTable_result(createTable_result other) {
8732 if (other.isSetIo()) {
8733 this.io = new IOError(other.io);
8734 }
8735 if (other.isSetIa()) {
8736 this.ia = new IllegalArgument(other.ia);
8737 }
8738 if (other.isSetExist()) {
8739 this.exist = new AlreadyExists(other.exist);
8740 }
8741 }
8742
8743 public createTable_result deepCopy() {
8744 return new createTable_result(this);
8745 }
8746
8747 @Deprecated
8748 public createTable_result clone() {
8749 return new createTable_result(this);
8750 }
8751
8752 public IOError getIo() {
8753 return this.io;
8754 }
8755
8756 public createTable_result setIo(IOError io) {
8757 this.io = io;
8758 return this;
8759 }
8760
8761 public void unsetIo() {
8762 this.io = null;
8763 }
8764
8765
8766 public boolean isSetIo() {
8767 return this.io != null;
8768 }
8769
8770 public void setIoIsSet(boolean value) {
8771 if (!value) {
8772 this.io = null;
8773 }
8774 }
8775
8776 public IllegalArgument getIa() {
8777 return this.ia;
8778 }
8779
8780 public createTable_result setIa(IllegalArgument ia) {
8781 this.ia = ia;
8782 return this;
8783 }
8784
8785 public void unsetIa() {
8786 this.ia = null;
8787 }
8788
8789
8790 public boolean isSetIa() {
8791 return this.ia != null;
8792 }
8793
8794 public void setIaIsSet(boolean value) {
8795 if (!value) {
8796 this.ia = null;
8797 }
8798 }
8799
8800 public AlreadyExists getExist() {
8801 return this.exist;
8802 }
8803
8804 public createTable_result setExist(AlreadyExists exist) {
8805 this.exist = exist;
8806 return this;
8807 }
8808
8809 public void unsetExist() {
8810 this.exist = null;
8811 }
8812
8813
8814 public boolean isSetExist() {
8815 return this.exist != null;
8816 }
8817
8818 public void setExistIsSet(boolean value) {
8819 if (!value) {
8820 this.exist = null;
8821 }
8822 }
8823
8824 public void setFieldValue(_Fields field, Object value) {
8825 switch (field) {
8826 case IO:
8827 if (value == null) {
8828 unsetIo();
8829 } else {
8830 setIo((IOError)value);
8831 }
8832 break;
8833
8834 case IA:
8835 if (value == null) {
8836 unsetIa();
8837 } else {
8838 setIa((IllegalArgument)value);
8839 }
8840 break;
8841
8842 case EXIST:
8843 if (value == null) {
8844 unsetExist();
8845 } else {
8846 setExist((AlreadyExists)value);
8847 }
8848 break;
8849
8850 }
8851 }
8852
8853 public void setFieldValue(int fieldID, Object value) {
8854 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8855 }
8856
8857 public Object getFieldValue(_Fields field) {
8858 switch (field) {
8859 case IO:
8860 return getIo();
8861
8862 case IA:
8863 return getIa();
8864
8865 case EXIST:
8866 return getExist();
8867
8868 }
8869 throw new IllegalStateException();
8870 }
8871
8872 public Object getFieldValue(int fieldId) {
8873 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8874 }
8875
8876
8877 public boolean isSet(_Fields field) {
8878 switch (field) {
8879 case IO:
8880 return isSetIo();
8881 case IA:
8882 return isSetIa();
8883 case EXIST:
8884 return isSetExist();
8885 }
8886 throw new IllegalStateException();
8887 }
8888
8889 public boolean isSet(int fieldID) {
8890 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8891 }
8892
8893 @Override
8894 public boolean equals(Object that) {
8895 if (that == null)
8896 return false;
8897 if (that instanceof createTable_result)
8898 return this.equals((createTable_result)that);
8899 return false;
8900 }
8901
8902 public boolean equals(createTable_result that) {
8903 if (that == null)
8904 return false;
8905
8906 boolean this_present_io = true && this.isSetIo();
8907 boolean that_present_io = true && that.isSetIo();
8908 if (this_present_io || that_present_io) {
8909 if (!(this_present_io && that_present_io))
8910 return false;
8911 if (!this.io.equals(that.io))
8912 return false;
8913 }
8914
8915 boolean this_present_ia = true && this.isSetIa();
8916 boolean that_present_ia = true && that.isSetIa();
8917 if (this_present_ia || that_present_ia) {
8918 if (!(this_present_ia && that_present_ia))
8919 return false;
8920 if (!this.ia.equals(that.ia))
8921 return false;
8922 }
8923
8924 boolean this_present_exist = true && this.isSetExist();
8925 boolean that_present_exist = true && that.isSetExist();
8926 if (this_present_exist || that_present_exist) {
8927 if (!(this_present_exist && that_present_exist))
8928 return false;
8929 if (!this.exist.equals(that.exist))
8930 return false;
8931 }
8932
8933 return true;
8934 }
8935
8936 @Override
8937 public int hashCode() {
8938 HashCodeBuilder builder = new HashCodeBuilder();
8939
8940 boolean present_io = true && (isSetIo());
8941 builder.append(present_io);
8942 if (present_io)
8943 builder.append(io);
8944
8945 boolean present_ia = true && (isSetIa());
8946 builder.append(present_ia);
8947 if (present_ia)
8948 builder.append(ia);
8949
8950 boolean present_exist = true && (isSetExist());
8951 builder.append(present_exist);
8952 if (present_exist)
8953 builder.append(exist);
8954
8955 return builder.toHashCode();
8956 }
8957
8958 public int compareTo(createTable_result other) {
8959 if (!getClass().equals(other.getClass())) {
8960 return getClass().getName().compareTo(other.getClass().getName());
8961 }
8962
8963 int lastComparison = 0;
8964 createTable_result typedOther = (createTable_result)other;
8965
8966 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
8967 if (lastComparison != 0) {
8968 return lastComparison;
8969 }
8970 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
8971 if (lastComparison != 0) {
8972 return lastComparison;
8973 }
8974 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
8975 if (lastComparison != 0) {
8976 return lastComparison;
8977 }
8978 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
8979 if (lastComparison != 0) {
8980 return lastComparison;
8981 }
8982 lastComparison = Boolean.valueOf(isSetExist()).compareTo(isSetExist());
8983 if (lastComparison != 0) {
8984 return lastComparison;
8985 }
8986 lastComparison = TBaseHelper.compareTo(exist, typedOther.exist);
8987 if (lastComparison != 0) {
8988 return lastComparison;
8989 }
8990 return 0;
8991 }
8992
8993 public void read(TProtocol iprot) throws TException {
8994 TField field;
8995 iprot.readStructBegin();
8996 while (true)
8997 {
8998 field = iprot.readFieldBegin();
8999 if (field.type == TType.STOP) {
9000 break;
9001 }
9002 _Fields fieldId = _Fields.findByThriftId(field.id);
9003 if (fieldId == null) {
9004 TProtocolUtil.skip(iprot, field.type);
9005 } else {
9006 switch (fieldId) {
9007 case IO:
9008 if (field.type == TType.STRUCT) {
9009 this.io = new IOError();
9010 this.io.read(iprot);
9011 } else {
9012 TProtocolUtil.skip(iprot, field.type);
9013 }
9014 break;
9015 case IA:
9016 if (field.type == TType.STRUCT) {
9017 this.ia = new IllegalArgument();
9018 this.ia.read(iprot);
9019 } else {
9020 TProtocolUtil.skip(iprot, field.type);
9021 }
9022 break;
9023 case EXIST:
9024 if (field.type == TType.STRUCT) {
9025 this.exist = new AlreadyExists();
9026 this.exist.read(iprot);
9027 } else {
9028 TProtocolUtil.skip(iprot, field.type);
9029 }
9030 break;
9031 }
9032 iprot.readFieldEnd();
9033 }
9034 }
9035 iprot.readStructEnd();
9036
9037
9038 validate();
9039 }
9040
9041 public void write(TProtocol oprot) throws TException {
9042 oprot.writeStructBegin(STRUCT_DESC);
9043
9044 if (this.isSetIo()) {
9045 oprot.writeFieldBegin(IO_FIELD_DESC);
9046 this.io.write(oprot);
9047 oprot.writeFieldEnd();
9048 } else if (this.isSetIa()) {
9049 oprot.writeFieldBegin(IA_FIELD_DESC);
9050 this.ia.write(oprot);
9051 oprot.writeFieldEnd();
9052 } else if (this.isSetExist()) {
9053 oprot.writeFieldBegin(EXIST_FIELD_DESC);
9054 this.exist.write(oprot);
9055 oprot.writeFieldEnd();
9056 }
9057 oprot.writeFieldStop();
9058 oprot.writeStructEnd();
9059 }
9060
9061 @Override
9062 public String toString() {
9063 StringBuilder sb = new StringBuilder("createTable_result(");
9064 boolean first = true;
9065
9066 sb.append("io:");
9067 if (this.io == null) {
9068 sb.append("null");
9069 } else {
9070 sb.append(this.io);
9071 }
9072 first = false;
9073 if (!first) sb.append(", ");
9074 sb.append("ia:");
9075 if (this.ia == null) {
9076 sb.append("null");
9077 } else {
9078 sb.append(this.ia);
9079 }
9080 first = false;
9081 if (!first) sb.append(", ");
9082 sb.append("exist:");
9083 if (this.exist == null) {
9084 sb.append("null");
9085 } else {
9086 sb.append(this.exist);
9087 }
9088 first = false;
9089 sb.append(")");
9090 return sb.toString();
9091 }
9092
9093 public void validate() throws TException {
9094
9095 }
9096
9097 }
9098
9099 public static class deleteTable_args implements TBase<deleteTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_args> {
9100 private static final TStruct STRUCT_DESC = new TStruct("deleteTable_args");
9101
9102 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
9103
9104
9105
9106
9107 public byte[] tableName;
9108
9109
9110 public enum _Fields implements TFieldIdEnum {
9111
9112
9113
9114 TABLE_NAME((short)1, "tableName");
9115
9116 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9117 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9118
9119 static {
9120 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9121 byId.put((int)field._thriftId, field);
9122 byName.put(field.getFieldName(), field);
9123 }
9124 }
9125
9126
9127
9128
9129 public static _Fields findByThriftId(int fieldId) {
9130 return byId.get(fieldId);
9131 }
9132
9133
9134
9135
9136
9137 public static _Fields findByThriftIdOrThrow(int fieldId) {
9138 _Fields fields = findByThriftId(fieldId);
9139 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9140 return fields;
9141 }
9142
9143
9144
9145
9146 public static _Fields findByName(String name) {
9147 return byName.get(name);
9148 }
9149
9150 private final short _thriftId;
9151 private final String _fieldName;
9152
9153 _Fields(short thriftId, String fieldName) {
9154 _thriftId = thriftId;
9155 _fieldName = fieldName;
9156 }
9157
9158 public short getThriftFieldId() {
9159 return _thriftId;
9160 }
9161
9162 public String getFieldName() {
9163 return _fieldName;
9164 }
9165 }
9166
9167
9168
9169 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9170 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
9171 new FieldValueMetaData(TType.STRING)));
9172 }});
9173
9174 static {
9175 FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap);
9176 }
9177
9178 public deleteTable_args() {
9179 }
9180
9181 public deleteTable_args(
9182 byte[] tableName)
9183 {
9184 this();
9185 this.tableName = tableName;
9186 }
9187
9188
9189
9190
9191 public deleteTable_args(deleteTable_args other) {
9192 if (other.isSetTableName()) {
9193 this.tableName = other.tableName;
9194 }
9195 }
9196
9197 public deleteTable_args deepCopy() {
9198 return new deleteTable_args(this);
9199 }
9200
9201 @Deprecated
9202 public deleteTable_args clone() {
9203 return new deleteTable_args(this);
9204 }
9205
9206
9207
9208
9209 public byte[] getTableName() {
9210 return this.tableName;
9211 }
9212
9213
9214
9215
9216 public deleteTable_args setTableName(byte[] tableName) {
9217 this.tableName = tableName;
9218 return this;
9219 }
9220
9221 public void unsetTableName() {
9222 this.tableName = null;
9223 }
9224
9225
9226 public boolean isSetTableName() {
9227 return this.tableName != null;
9228 }
9229
9230 public void setTableNameIsSet(boolean value) {
9231 if (!value) {
9232 this.tableName = null;
9233 }
9234 }
9235
9236 public void setFieldValue(_Fields field, Object value) {
9237 switch (field) {
9238 case TABLE_NAME:
9239 if (value == null) {
9240 unsetTableName();
9241 } else {
9242 setTableName((byte[])value);
9243 }
9244 break;
9245
9246 }
9247 }
9248
9249 public void setFieldValue(int fieldID, Object value) {
9250 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9251 }
9252
9253 public Object getFieldValue(_Fields field) {
9254 switch (field) {
9255 case TABLE_NAME:
9256 return getTableName();
9257
9258 }
9259 throw new IllegalStateException();
9260 }
9261
9262 public Object getFieldValue(int fieldId) {
9263 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9264 }
9265
9266
9267 public boolean isSet(_Fields field) {
9268 switch (field) {
9269 case TABLE_NAME:
9270 return isSetTableName();
9271 }
9272 throw new IllegalStateException();
9273 }
9274
9275 public boolean isSet(int fieldID) {
9276 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9277 }
9278
9279 @Override
9280 public boolean equals(Object that) {
9281 if (that == null)
9282 return false;
9283 if (that instanceof deleteTable_args)
9284 return this.equals((deleteTable_args)that);
9285 return false;
9286 }
9287
9288 public boolean equals(deleteTable_args that) {
9289 if (that == null)
9290 return false;
9291
9292 boolean this_present_tableName = true && this.isSetTableName();
9293 boolean that_present_tableName = true && that.isSetTableName();
9294 if (this_present_tableName || that_present_tableName) {
9295 if (!(this_present_tableName && that_present_tableName))
9296 return false;
9297 if (!java.util.Arrays.equals(this.tableName, that.tableName))
9298 return false;
9299 }
9300
9301 return true;
9302 }
9303
9304 @Override
9305 public int hashCode() {
9306 HashCodeBuilder builder = new HashCodeBuilder();
9307
9308 boolean present_tableName = true && (isSetTableName());
9309 builder.append(present_tableName);
9310 if (present_tableName)
9311 builder.append(tableName);
9312
9313 return builder.toHashCode();
9314 }
9315
9316 public int compareTo(deleteTable_args other) {
9317 if (!getClass().equals(other.getClass())) {
9318 return getClass().getName().compareTo(other.getClass().getName());
9319 }
9320
9321 int lastComparison = 0;
9322 deleteTable_args typedOther = (deleteTable_args)other;
9323
9324 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
9325 if (lastComparison != 0) {
9326 return lastComparison;
9327 }
9328 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
9329 if (lastComparison != 0) {
9330 return lastComparison;
9331 }
9332 return 0;
9333 }
9334
9335 public void read(TProtocol iprot) throws TException {
9336 TField field;
9337 iprot.readStructBegin();
9338 while (true)
9339 {
9340 field = iprot.readFieldBegin();
9341 if (field.type == TType.STOP) {
9342 break;
9343 }
9344 _Fields fieldId = _Fields.findByThriftId(field.id);
9345 if (fieldId == null) {
9346 TProtocolUtil.skip(iprot, field.type);
9347 } else {
9348 switch (fieldId) {
9349 case TABLE_NAME:
9350 if (field.type == TType.STRING) {
9351 this.tableName = iprot.readBinary();
9352 } else {
9353 TProtocolUtil.skip(iprot, field.type);
9354 }
9355 break;
9356 }
9357 iprot.readFieldEnd();
9358 }
9359 }
9360 iprot.readStructEnd();
9361
9362
9363 validate();
9364 }
9365
9366 public void write(TProtocol oprot) throws TException {
9367 validate();
9368
9369 oprot.writeStructBegin(STRUCT_DESC);
9370 if (this.tableName != null) {
9371 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
9372 oprot.writeBinary(this.tableName);
9373 oprot.writeFieldEnd();
9374 }
9375 oprot.writeFieldStop();
9376 oprot.writeStructEnd();
9377 }
9378
9379 @Override
9380 public String toString() {
9381 StringBuilder sb = new StringBuilder("deleteTable_args(");
9382 boolean first = true;
9383
9384 sb.append("tableName:");
9385 if (this.tableName == null) {
9386 sb.append("null");
9387 } else {
9388 sb.append(this.tableName);
9389 }
9390 first = false;
9391 sb.append(")");
9392 return sb.toString();
9393 }
9394
9395 public void validate() throws TException {
9396
9397 }
9398
9399 }
9400
9401 public static class deleteTable_result implements TBase<deleteTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_result> {
9402 private static final TStruct STRUCT_DESC = new TStruct("deleteTable_result");
9403
9404 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
9405
9406 public IOError io;
9407
9408
9409 public enum _Fields implements TFieldIdEnum {
9410 IO((short)1, "io");
9411
9412 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9413 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9414
9415 static {
9416 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9417 byId.put((int)field._thriftId, field);
9418 byName.put(field.getFieldName(), field);
9419 }
9420 }
9421
9422
9423
9424
9425 public static _Fields findByThriftId(int fieldId) {
9426 return byId.get(fieldId);
9427 }
9428
9429
9430
9431
9432
9433 public static _Fields findByThriftIdOrThrow(int fieldId) {
9434 _Fields fields = findByThriftId(fieldId);
9435 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9436 return fields;
9437 }
9438
9439
9440
9441
9442 public static _Fields findByName(String name) {
9443 return byName.get(name);
9444 }
9445
9446 private final short _thriftId;
9447 private final String _fieldName;
9448
9449 _Fields(short thriftId, String fieldName) {
9450 _thriftId = thriftId;
9451 _fieldName = fieldName;
9452 }
9453
9454 public short getThriftFieldId() {
9455 return _thriftId;
9456 }
9457
9458 public String getFieldName() {
9459 return _fieldName;
9460 }
9461 }
9462
9463
9464
9465 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9466 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
9467 new FieldValueMetaData(TType.STRUCT)));
9468 }});
9469
9470 static {
9471 FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap);
9472 }
9473
9474 public deleteTable_result() {
9475 }
9476
9477 public deleteTable_result(
9478 IOError io)
9479 {
9480 this();
9481 this.io = io;
9482 }
9483
9484
9485
9486
9487 public deleteTable_result(deleteTable_result other) {
9488 if (other.isSetIo()) {
9489 this.io = new IOError(other.io);
9490 }
9491 }
9492
9493 public deleteTable_result deepCopy() {
9494 return new deleteTable_result(this);
9495 }
9496
9497 @Deprecated
9498 public deleteTable_result clone() {
9499 return new deleteTable_result(this);
9500 }
9501
9502 public IOError getIo() {
9503 return this.io;
9504 }
9505
9506 public deleteTable_result setIo(IOError io) {
9507 this.io = io;
9508 return this;
9509 }
9510
9511 public void unsetIo() {
9512 this.io = null;
9513 }
9514
9515
9516 public boolean isSetIo() {
9517 return this.io != null;
9518 }
9519
9520 public void setIoIsSet(boolean value) {
9521 if (!value) {
9522 this.io = null;
9523 }
9524 }
9525
9526 public void setFieldValue(_Fields field, Object value) {
9527 switch (field) {
9528 case IO:
9529 if (value == null) {
9530 unsetIo();
9531 } else {
9532 setIo((IOError)value);
9533 }
9534 break;
9535
9536 }
9537 }
9538
9539 public void setFieldValue(int fieldID, Object value) {
9540 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9541 }
9542
9543 public Object getFieldValue(_Fields field) {
9544 switch (field) {
9545 case IO:
9546 return getIo();
9547
9548 }
9549 throw new IllegalStateException();
9550 }
9551
9552 public Object getFieldValue(int fieldId) {
9553 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9554 }
9555
9556
9557 public boolean isSet(_Fields field) {
9558 switch (field) {
9559 case IO:
9560 return isSetIo();
9561 }
9562 throw new IllegalStateException();
9563 }
9564
9565 public boolean isSet(int fieldID) {
9566 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9567 }
9568
9569 @Override
9570 public boolean equals(Object that) {
9571 if (that == null)
9572 return false;
9573 if (that instanceof deleteTable_result)
9574 return this.equals((deleteTable_result)that);
9575 return false;
9576 }
9577
9578 public boolean equals(deleteTable_result that) {
9579 if (that == null)
9580 return false;
9581
9582 boolean this_present_io = true && this.isSetIo();
9583 boolean that_present_io = true && that.isSetIo();
9584 if (this_present_io || that_present_io) {
9585 if (!(this_present_io && that_present_io))
9586 return false;
9587 if (!this.io.equals(that.io))
9588 return false;
9589 }
9590
9591 return true;
9592 }
9593
9594 @Override
9595 public int hashCode() {
9596 HashCodeBuilder builder = new HashCodeBuilder();
9597
9598 boolean present_io = true && (isSetIo());
9599 builder.append(present_io);
9600 if (present_io)
9601 builder.append(io);
9602
9603 return builder.toHashCode();
9604 }
9605
9606 public int compareTo(deleteTable_result other) {
9607 if (!getClass().equals(other.getClass())) {
9608 return getClass().getName().compareTo(other.getClass().getName());
9609 }
9610
9611 int lastComparison = 0;
9612 deleteTable_result typedOther = (deleteTable_result)other;
9613
9614 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
9615 if (lastComparison != 0) {
9616 return lastComparison;
9617 }
9618 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
9619 if (lastComparison != 0) {
9620 return lastComparison;
9621 }
9622 return 0;
9623 }
9624
9625 public void read(TProtocol iprot) throws TException {
9626 TField field;
9627 iprot.readStructBegin();
9628 while (true)
9629 {
9630 field = iprot.readFieldBegin();
9631 if (field.type == TType.STOP) {
9632 break;
9633 }
9634 _Fields fieldId = _Fields.findByThriftId(field.id);
9635 if (fieldId == null) {
9636 TProtocolUtil.skip(iprot, field.type);
9637 } else {
9638 switch (fieldId) {
9639 case IO:
9640 if (field.type == TType.STRUCT) {
9641 this.io = new IOError();
9642 this.io.read(iprot);
9643 } else {
9644 TProtocolUtil.skip(iprot, field.type);
9645 }
9646 break;
9647 }
9648 iprot.readFieldEnd();
9649 }
9650 }
9651 iprot.readStructEnd();
9652
9653
9654 validate();
9655 }
9656
9657 public void write(TProtocol oprot) throws TException {
9658 oprot.writeStructBegin(STRUCT_DESC);
9659
9660 if (this.isSetIo()) {
9661 oprot.writeFieldBegin(IO_FIELD_DESC);
9662 this.io.write(oprot);
9663 oprot.writeFieldEnd();
9664 }
9665 oprot.writeFieldStop();
9666 oprot.writeStructEnd();
9667 }
9668
9669 @Override
9670 public String toString() {
9671 StringBuilder sb = new StringBuilder("deleteTable_result(");
9672 boolean first = true;
9673
9674 sb.append("io:");
9675 if (this.io == null) {
9676 sb.append("null");
9677 } else {
9678 sb.append(this.io);
9679 }
9680 first = false;
9681 sb.append(")");
9682 return sb.toString();
9683 }
9684
9685 public void validate() throws TException {
9686
9687 }
9688
9689 }
9690
9691 public static class get_args implements TBase<get_args._Fields>, java.io.Serializable, Cloneable, Comparable<get_args> {
9692 private static final TStruct STRUCT_DESC = new TStruct("get_args");
9693
9694 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
9695 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
9696 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
9697
9698
9699
9700
9701 public byte[] tableName;
9702
9703
9704
9705 public byte[] row;
9706
9707
9708
9709 public byte[] column;
9710
9711
9712 public enum _Fields implements TFieldIdEnum {
9713
9714
9715
9716 TABLE_NAME((short)1, "tableName"),
9717
9718
9719
9720 ROW((short)2, "row"),
9721
9722
9723
9724 COLUMN((short)3, "column");
9725
9726 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9727 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9728
9729 static {
9730 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9731 byId.put((int)field._thriftId, field);
9732 byName.put(field.getFieldName(), field);
9733 }
9734 }
9735
9736
9737
9738
9739 public static _Fields findByThriftId(int fieldId) {
9740 return byId.get(fieldId);
9741 }
9742
9743
9744
9745
9746
9747 public static _Fields findByThriftIdOrThrow(int fieldId) {
9748 _Fields fields = findByThriftId(fieldId);
9749 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9750 return fields;
9751 }
9752
9753
9754
9755
9756 public static _Fields findByName(String name) {
9757 return byName.get(name);
9758 }
9759
9760 private final short _thriftId;
9761 private final String _fieldName;
9762
9763 _Fields(short thriftId, String fieldName) {
9764 _thriftId = thriftId;
9765 _fieldName = fieldName;
9766 }
9767
9768 public short getThriftFieldId() {
9769 return _thriftId;
9770 }
9771
9772 public String getFieldName() {
9773 return _fieldName;
9774 }
9775 }
9776
9777
9778
9779 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9780 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
9781 new FieldValueMetaData(TType.STRING)));
9782 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
9783 new FieldValueMetaData(TType.STRING)));
9784 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
9785 new FieldValueMetaData(TType.STRING)));
9786 }});
9787
9788 static {
9789 FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
9790 }
9791
9792 public get_args() {
9793 }
9794
9795 public get_args(
9796 byte[] tableName,
9797 byte[] row,
9798 byte[] column)
9799 {
9800 this();
9801 this.tableName = tableName;
9802 this.row = row;
9803 this.column = column;
9804 }
9805
9806
9807
9808
9809 public get_args(get_args other) {
9810 if (other.isSetTableName()) {
9811 this.tableName = other.tableName;
9812 }
9813 if (other.isSetRow()) {
9814 this.row = other.row;
9815 }
9816 if (other.isSetColumn()) {
9817 this.column = other.column;
9818 }
9819 }
9820
9821 public get_args deepCopy() {
9822 return new get_args(this);
9823 }
9824
9825 @Deprecated
9826 public get_args clone() {
9827 return new get_args(this);
9828 }
9829
9830
9831
9832
9833 public byte[] getTableName() {
9834 return this.tableName;
9835 }
9836
9837
9838
9839
9840 public get_args setTableName(byte[] tableName) {
9841 this.tableName = tableName;
9842 return this;
9843 }
9844
9845 public void unsetTableName() {
9846 this.tableName = null;
9847 }
9848
9849
9850 public boolean isSetTableName() {
9851 return this.tableName != null;
9852 }
9853
9854 public void setTableNameIsSet(boolean value) {
9855 if (!value) {
9856 this.tableName = null;
9857 }
9858 }
9859
9860
9861
9862
9863 public byte[] getRow() {
9864 return this.row;
9865 }
9866
9867
9868
9869
9870 public get_args setRow(byte[] row) {
9871 this.row = row;
9872 return this;
9873 }
9874
9875 public void unsetRow() {
9876 this.row = null;
9877 }
9878
9879
9880 public boolean isSetRow() {
9881 return this.row != null;
9882 }
9883
9884 public void setRowIsSet(boolean value) {
9885 if (!value) {
9886 this.row = null;
9887 }
9888 }
9889
9890
9891
9892
9893 public byte[] getColumn() {
9894 return this.column;
9895 }
9896
9897
9898
9899
9900 public get_args setColumn(byte[] column) {
9901 this.column = column;
9902 return this;
9903 }
9904
9905 public void unsetColumn() {
9906 this.column = null;
9907 }
9908
9909
9910 public boolean isSetColumn() {
9911 return this.column != null;
9912 }
9913
9914 public void setColumnIsSet(boolean value) {
9915 if (!value) {
9916 this.column = null;
9917 }
9918 }
9919
9920 public void setFieldValue(_Fields field, Object value) {
9921 switch (field) {
9922 case TABLE_NAME:
9923 if (value == null) {
9924 unsetTableName();
9925 } else {
9926 setTableName((byte[])value);
9927 }
9928 break;
9929
9930 case ROW:
9931 if (value == null) {
9932 unsetRow();
9933 } else {
9934 setRow((byte[])value);
9935 }
9936 break;
9937
9938 case COLUMN:
9939 if (value == null) {
9940 unsetColumn();
9941 } else {
9942 setColumn((byte[])value);
9943 }
9944 break;
9945
9946 }
9947 }
9948
9949 public void setFieldValue(int fieldID, Object value) {
9950 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9951 }
9952
9953 public Object getFieldValue(_Fields field) {
9954 switch (field) {
9955 case TABLE_NAME:
9956 return getTableName();
9957
9958 case ROW:
9959 return getRow();
9960
9961 case COLUMN:
9962 return getColumn();
9963
9964 }
9965 throw new IllegalStateException();
9966 }
9967
9968 public Object getFieldValue(int fieldId) {
9969 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9970 }
9971
9972
9973 public boolean isSet(_Fields field) {
9974 switch (field) {
9975 case TABLE_NAME:
9976 return isSetTableName();
9977 case ROW:
9978 return isSetRow();
9979 case COLUMN:
9980 return isSetColumn();
9981 }
9982 throw new IllegalStateException();
9983 }
9984
9985 public boolean isSet(int fieldID) {
9986 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9987 }
9988
9989 @Override
9990 public boolean equals(Object that) {
9991 if (that == null)
9992 return false;
9993 if (that instanceof get_args)
9994 return this.equals((get_args)that);
9995 return false;
9996 }
9997
9998 public boolean equals(get_args that) {
9999 if (that == null)
10000 return false;
10001
10002 boolean this_present_tableName = true && this.isSetTableName();
10003 boolean that_present_tableName = true && that.isSetTableName();
10004 if (this_present_tableName || that_present_tableName) {
10005 if (!(this_present_tableName && that_present_tableName))
10006 return false;
10007 if (!java.util.Arrays.equals(this.tableName, that.tableName))
10008 return false;
10009 }
10010
10011 boolean this_present_row = true && this.isSetRow();
10012 boolean that_present_row = true && that.isSetRow();
10013 if (this_present_row || that_present_row) {
10014 if (!(this_present_row && that_present_row))
10015 return false;
10016 if (!java.util.Arrays.equals(this.row, that.row))
10017 return false;
10018 }
10019
10020 boolean this_present_column = true && this.isSetColumn();
10021 boolean that_present_column = true && that.isSetColumn();
10022 if (this_present_column || that_present_column) {
10023 if (!(this_present_column && that_present_column))
10024 return false;
10025 if (!java.util.Arrays.equals(this.column, that.column))
10026 return false;
10027 }
10028
10029 return true;
10030 }
10031
10032 @Override
10033 public int hashCode() {
10034 HashCodeBuilder builder = new HashCodeBuilder();
10035
10036 boolean present_tableName = true && (isSetTableName());
10037 builder.append(present_tableName);
10038 if (present_tableName)
10039 builder.append(tableName);
10040
10041 boolean present_row = true && (isSetRow());
10042 builder.append(present_row);
10043 if (present_row)
10044 builder.append(row);
10045
10046 boolean present_column = true && (isSetColumn());
10047 builder.append(present_column);
10048 if (present_column)
10049 builder.append(column);
10050
10051 return builder.toHashCode();
10052 }
10053
10054 public int compareTo(get_args other) {
10055 if (!getClass().equals(other.getClass())) {
10056 return getClass().getName().compareTo(other.getClass().getName());
10057 }
10058
10059 int lastComparison = 0;
10060 get_args typedOther = (get_args)other;
10061
10062 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
10063 if (lastComparison != 0) {
10064 return lastComparison;
10065 }
10066 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
10067 if (lastComparison != 0) {
10068 return lastComparison;
10069 }
10070 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
10071 if (lastComparison != 0) {
10072 return lastComparison;
10073 }
10074 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
10075 if (lastComparison != 0) {
10076 return lastComparison;
10077 }
10078 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
10079 if (lastComparison != 0) {
10080 return lastComparison;
10081 }
10082 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
10083 if (lastComparison != 0) {
10084 return lastComparison;
10085 }
10086 return 0;
10087 }
10088
10089 public void read(TProtocol iprot) throws TException {
10090 TField field;
10091 iprot.readStructBegin();
10092 while (true)
10093 {
10094 field = iprot.readFieldBegin();
10095 if (field.type == TType.STOP) {
10096 break;
10097 }
10098 _Fields fieldId = _Fields.findByThriftId(field.id);
10099 if (fieldId == null) {
10100 TProtocolUtil.skip(iprot, field.type);
10101 } else {
10102 switch (fieldId) {
10103 case TABLE_NAME:
10104 if (field.type == TType.STRING) {
10105 this.tableName = iprot.readBinary();
10106 } else {
10107 TProtocolUtil.skip(iprot, field.type);
10108 }
10109 break;
10110 case ROW:
10111 if (field.type == TType.STRING) {
10112 this.row = iprot.readBinary();
10113 } else {
10114 TProtocolUtil.skip(iprot, field.type);
10115 }
10116 break;
10117 case COLUMN:
10118 if (field.type == TType.STRING) {
10119 this.column = iprot.readBinary();
10120 } else {
10121 TProtocolUtil.skip(iprot, field.type);
10122 }
10123 break;
10124 }
10125 iprot.readFieldEnd();
10126 }
10127 }
10128 iprot.readStructEnd();
10129
10130
10131 validate();
10132 }
10133
10134 public void write(TProtocol oprot) throws TException {
10135 validate();
10136
10137 oprot.writeStructBegin(STRUCT_DESC);
10138 if (this.tableName != null) {
10139 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
10140 oprot.writeBinary(this.tableName);
10141 oprot.writeFieldEnd();
10142 }
10143 if (this.row != null) {
10144 oprot.writeFieldBegin(ROW_FIELD_DESC);
10145 oprot.writeBinary(this.row);
10146 oprot.writeFieldEnd();
10147 }
10148 if (this.column != null) {
10149 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
10150 oprot.writeBinary(this.column);
10151 oprot.writeFieldEnd();
10152 }
10153 oprot.writeFieldStop();
10154 oprot.writeStructEnd();
10155 }
10156
10157 @Override
10158 public String toString() {
10159 StringBuilder sb = new StringBuilder("get_args(");
10160 boolean first = true;
10161
10162 sb.append("tableName:");
10163 if (this.tableName == null) {
10164 sb.append("null");
10165 } else {
10166 sb.append(this.tableName);
10167 }
10168 first = false;
10169 if (!first) sb.append(", ");
10170 sb.append("row:");
10171 if (this.row == null) {
10172 sb.append("null");
10173 } else {
10174 sb.append(this.row);
10175 }
10176 first = false;
10177 if (!first) sb.append(", ");
10178 sb.append("column:");
10179 if (this.column == null) {
10180 sb.append("null");
10181 } else {
10182 sb.append(this.column);
10183 }
10184 first = false;
10185 sb.append(")");
10186 return sb.toString();
10187 }
10188
10189 public void validate() throws TException {
10190
10191 }
10192
10193 }
10194
10195 public static class get_result implements TBase<get_result._Fields>, java.io.Serializable, Cloneable, Comparable<get_result> {
10196 private static final TStruct STRUCT_DESC = new TStruct("get_result");
10197
10198 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
10199 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
10200
10201 public List<TCell> success;
10202 public IOError io;
10203
10204
10205 public enum _Fields implements TFieldIdEnum {
10206 SUCCESS((short)0, "success"),
10207 IO((short)1, "io");
10208
10209 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
10210 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10211
10212 static {
10213 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10214 byId.put((int)field._thriftId, field);
10215 byName.put(field.getFieldName(), field);
10216 }
10217 }
10218
10219
10220
10221
10222 public static _Fields findByThriftId(int fieldId) {
10223 return byId.get(fieldId);
10224 }
10225
10226
10227
10228
10229
10230 public static _Fields findByThriftIdOrThrow(int fieldId) {
10231 _Fields fields = findByThriftId(fieldId);
10232 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10233 return fields;
10234 }
10235
10236
10237
10238
10239 public static _Fields findByName(String name) {
10240 return byName.get(name);
10241 }
10242
10243 private final short _thriftId;
10244 private final String _fieldName;
10245
10246 _Fields(short thriftId, String fieldName) {
10247 _thriftId = thriftId;
10248 _fieldName = fieldName;
10249 }
10250
10251 public short getThriftFieldId() {
10252 return _thriftId;
10253 }
10254
10255 public String getFieldName() {
10256 return _fieldName;
10257 }
10258 }
10259
10260
10261
10262 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
10263 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
10264 new ListMetaData(TType.LIST,
10265 new StructMetaData(TType.STRUCT, TCell.class))));
10266 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
10267 new FieldValueMetaData(TType.STRUCT)));
10268 }});
10269
10270 static {
10271 FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
10272 }
10273
10274 public get_result() {
10275 }
10276
10277 public get_result(
10278 List<TCell> success,
10279 IOError io)
10280 {
10281 this();
10282 this.success = success;
10283 this.io = io;
10284 }
10285
10286
10287
10288
10289 public get_result(get_result other) {
10290 if (other.isSetSuccess()) {
10291 List<TCell> __this__success = new ArrayList<TCell>();
10292 for (TCell other_element : other.success) {
10293 __this__success.add(new TCell(other_element));
10294 }
10295 this.success = __this__success;
10296 }
10297 if (other.isSetIo()) {
10298 this.io = new IOError(other.io);
10299 }
10300 }
10301
10302 public get_result deepCopy() {
10303 return new get_result(this);
10304 }
10305
10306 @Deprecated
10307 public get_result clone() {
10308 return new get_result(this);
10309 }
10310
10311 public int getSuccessSize() {
10312 return (this.success == null) ? 0 : this.success.size();
10313 }
10314
10315 public java.util.Iterator<TCell> getSuccessIterator() {
10316 return (this.success == null) ? null : this.success.iterator();
10317 }
10318
10319 public void addToSuccess(TCell elem) {
10320 if (this.success == null) {
10321 this.success = new ArrayList<TCell>();
10322 }
10323 this.success.add(elem);
10324 }
10325
10326 public List<TCell> getSuccess() {
10327 return this.success;
10328 }
10329
10330 public get_result setSuccess(List<TCell> success) {
10331 this.success = success;
10332 return this;
10333 }
10334
10335 public void unsetSuccess() {
10336 this.success = null;
10337 }
10338
10339
10340 public boolean isSetSuccess() {
10341 return this.success != null;
10342 }
10343
10344 public void setSuccessIsSet(boolean value) {
10345 if (!value) {
10346 this.success = null;
10347 }
10348 }
10349
10350 public IOError getIo() {
10351 return this.io;
10352 }
10353
10354 public get_result setIo(IOError io) {
10355 this.io = io;
10356 return this;
10357 }
10358
10359 public void unsetIo() {
10360 this.io = null;
10361 }
10362
10363
10364 public boolean isSetIo() {
10365 return this.io != null;
10366 }
10367
10368 public void setIoIsSet(boolean value) {
10369 if (!value) {
10370 this.io = null;
10371 }
10372 }
10373
10374 public void setFieldValue(_Fields field, Object value) {
10375 switch (field) {
10376 case SUCCESS:
10377 if (value == null) {
10378 unsetSuccess();
10379 } else {
10380 setSuccess((List<TCell>)value);
10381 }
10382 break;
10383
10384 case IO:
10385 if (value == null) {
10386 unsetIo();
10387 } else {
10388 setIo((IOError)value);
10389 }
10390 break;
10391
10392 }
10393 }
10394
10395 public void setFieldValue(int fieldID, Object value) {
10396 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
10397 }
10398
10399 public Object getFieldValue(_Fields field) {
10400 switch (field) {
10401 case SUCCESS:
10402 return getSuccess();
10403
10404 case IO:
10405 return getIo();
10406
10407 }
10408 throw new IllegalStateException();
10409 }
10410
10411 public Object getFieldValue(int fieldId) {
10412 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
10413 }
10414
10415
10416 public boolean isSet(_Fields field) {
10417 switch (field) {
10418 case SUCCESS:
10419 return isSetSuccess();
10420 case IO:
10421 return isSetIo();
10422 }
10423 throw new IllegalStateException();
10424 }
10425
10426 public boolean isSet(int fieldID) {
10427 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
10428 }
10429
10430 @Override
10431 public boolean equals(Object that) {
10432 if (that == null)
10433 return false;
10434 if (that instanceof get_result)
10435 return this.equals((get_result)that);
10436 return false;
10437 }
10438
10439 public boolean equals(get_result that) {
10440 if (that == null)
10441 return false;
10442
10443 boolean this_present_success = true && this.isSetSuccess();
10444 boolean that_present_success = true && that.isSetSuccess();
10445 if (this_present_success || that_present_success) {
10446 if (!(this_present_success && that_present_success))
10447 return false;
10448 if (!this.success.equals(that.success))
10449 return false;
10450 }
10451
10452 boolean this_present_io = true && this.isSetIo();
10453 boolean that_present_io = true && that.isSetIo();
10454 if (this_present_io || that_present_io) {
10455 if (!(this_present_io && that_present_io))
10456 return false;
10457 if (!this.io.equals(that.io))
10458 return false;
10459 }
10460
10461 return true;
10462 }
10463
10464 @Override
10465 public int hashCode() {
10466 HashCodeBuilder builder = new HashCodeBuilder();
10467
10468 boolean present_success = true && (isSetSuccess());
10469 builder.append(present_success);
10470 if (present_success)
10471 builder.append(success);
10472
10473 boolean present_io = true && (isSetIo());
10474 builder.append(present_io);
10475 if (present_io)
10476 builder.append(io);
10477
10478 return builder.toHashCode();
10479 }
10480
10481 public int compareTo(get_result other) {
10482 if (!getClass().equals(other.getClass())) {
10483 return getClass().getName().compareTo(other.getClass().getName());
10484 }
10485
10486 int lastComparison = 0;
10487 get_result typedOther = (get_result)other;
10488
10489 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
10490 if (lastComparison != 0) {
10491 return lastComparison;
10492 }
10493 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
10494 if (lastComparison != 0) {
10495 return lastComparison;
10496 }
10497 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
10498 if (lastComparison != 0) {
10499 return lastComparison;
10500 }
10501 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
10502 if (lastComparison != 0) {
10503 return lastComparison;
10504 }
10505 return 0;
10506 }
10507
10508 public void read(TProtocol iprot) throws TException {
10509 TField field;
10510 iprot.readStructBegin();
10511 while (true)
10512 {
10513 field = iprot.readFieldBegin();
10514 if (field.type == TType.STOP) {
10515 break;
10516 }
10517 _Fields fieldId = _Fields.findByThriftId(field.id);
10518 if (fieldId == null) {
10519 TProtocolUtil.skip(iprot, field.type);
10520 } else {
10521 switch (fieldId) {
10522 case SUCCESS:
10523 if (field.type == TType.LIST) {
10524 {
10525 TList _list26 = iprot.readListBegin();
10526 this.success = new ArrayList<TCell>(_list26.size);
10527 for (int _i27 = 0; _i27 < _list26.size; ++_i27)
10528 {
10529 TCell _elem28;
10530 _elem28 = new TCell();
10531 _elem28.read(iprot);
10532 this.success.add(_elem28);
10533 }
10534 iprot.readListEnd();
10535 }
10536 } else {
10537 TProtocolUtil.skip(iprot, field.type);
10538 }
10539 break;
10540 case IO:
10541 if (field.type == TType.STRUCT) {
10542 this.io = new IOError();
10543 this.io.read(iprot);
10544 } else {
10545 TProtocolUtil.skip(iprot, field.type);
10546 }
10547 break;
10548 }
10549 iprot.readFieldEnd();
10550 }
10551 }
10552 iprot.readStructEnd();
10553
10554
10555 validate();
10556 }
10557
10558 public void write(TProtocol oprot) throws TException {
10559 oprot.writeStructBegin(STRUCT_DESC);
10560
10561 if (this.isSetSuccess()) {
10562 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
10563 {
10564 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
10565 for (TCell _iter29 : this.success)
10566 {
10567 _iter29.write(oprot);
10568 }
10569 oprot.writeListEnd();
10570 }
10571 oprot.writeFieldEnd();
10572 } else if (this.isSetIo()) {
10573 oprot.writeFieldBegin(IO_FIELD_DESC);
10574 this.io.write(oprot);
10575 oprot.writeFieldEnd();
10576 }
10577 oprot.writeFieldStop();
10578 oprot.writeStructEnd();
10579 }
10580
10581 @Override
10582 public String toString() {
10583 StringBuilder sb = new StringBuilder("get_result(");
10584 boolean first = true;
10585
10586 sb.append("success:");
10587 if (this.success == null) {
10588 sb.append("null");
10589 } else {
10590 sb.append(this.success);
10591 }
10592 first = false;
10593 if (!first) sb.append(", ");
10594 sb.append("io:");
10595 if (this.io == null) {
10596 sb.append("null");
10597 } else {
10598 sb.append(this.io);
10599 }
10600 first = false;
10601 sb.append(")");
10602 return sb.toString();
10603 }
10604
10605 public void validate() throws TException {
10606
10607 }
10608
10609 }
10610
10611 public static class getVer_args implements TBase<getVer_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_args> {
10612 private static final TStruct STRUCT_DESC = new TStruct("getVer_args");
10613
10614 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
10615 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
10616 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
10617 private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)4);
10618
10619
10620
10621
10622 public byte[] tableName;
10623
10624
10625
10626 public byte[] row;
10627
10628
10629
10630 public byte[] column;
10631
10632
10633
10634 public int numVersions;
10635
10636
10637 public enum _Fields implements TFieldIdEnum {
10638
10639
10640
10641 TABLE_NAME((short)1, "tableName"),
10642
10643
10644
10645 ROW((short)2, "row"),
10646
10647
10648
10649 COLUMN((short)3, "column"),
10650
10651
10652
10653 NUM_VERSIONS((short)4, "numVersions");
10654
10655 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
10656 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10657
10658 static {
10659 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10660 byId.put((int)field._thriftId, field);
10661 byName.put(field.getFieldName(), field);
10662 }
10663 }
10664
10665
10666
10667
10668 public static _Fields findByThriftId(int fieldId) {
10669 return byId.get(fieldId);
10670 }
10671
10672
10673
10674
10675
10676 public static _Fields findByThriftIdOrThrow(int fieldId) {
10677 _Fields fields = findByThriftId(fieldId);
10678 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10679 return fields;
10680 }
10681
10682
10683
10684
10685 public static _Fields findByName(String name) {
10686 return byName.get(name);
10687 }
10688
10689 private final short _thriftId;
10690 private final String _fieldName;
10691
10692 _Fields(short thriftId, String fieldName) {
10693 _thriftId = thriftId;
10694 _fieldName = fieldName;
10695 }
10696
10697 public short getThriftFieldId() {
10698 return _thriftId;
10699 }
10700
10701 public String getFieldName() {
10702 return _fieldName;
10703 }
10704 }
10705
10706
10707 private static final int __NUMVERSIONS_ISSET_ID = 0;
10708 private BitSet __isset_bit_vector = new BitSet(1);
10709
10710 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
10711 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
10712 new FieldValueMetaData(TType.STRING)));
10713 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
10714 new FieldValueMetaData(TType.STRING)));
10715 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
10716 new FieldValueMetaData(TType.STRING)));
10717 put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT,
10718 new FieldValueMetaData(TType.I32)));
10719 }});
10720
10721 static {
10722 FieldMetaData.addStructMetaDataMap(getVer_args.class, metaDataMap);
10723 }
10724
10725 public getVer_args() {
10726 }
10727
10728 public getVer_args(
10729 byte[] tableName,
10730 byte[] row,
10731 byte[] column,
10732 int numVersions)
10733 {
10734 this();
10735 this.tableName = tableName;
10736 this.row = row;
10737 this.column = column;
10738 this.numVersions = numVersions;
10739 setNumVersionsIsSet(true);
10740 }
10741
10742
10743
10744
10745 public getVer_args(getVer_args other) {
10746 __isset_bit_vector.clear();
10747 __isset_bit_vector.or(other.__isset_bit_vector);
10748 if (other.isSetTableName()) {
10749 this.tableName = other.tableName;
10750 }
10751 if (other.isSetRow()) {
10752 this.row = other.row;
10753 }
10754 if (other.isSetColumn()) {
10755 this.column = other.column;
10756 }
10757 this.numVersions = other.numVersions;
10758 }
10759
10760 public getVer_args deepCopy() {
10761 return new getVer_args(this);
10762 }
10763
10764 @Deprecated
10765 public getVer_args clone() {
10766 return new getVer_args(this);
10767 }
10768
10769
10770
10771
10772 public byte[] getTableName() {
10773 return this.tableName;
10774 }
10775
10776
10777
10778
10779 public getVer_args setTableName(byte[] tableName) {
10780 this.tableName = tableName;
10781 return this;
10782 }
10783
10784 public void unsetTableName() {
10785 this.tableName = null;
10786 }
10787
10788
10789 public boolean isSetTableName() {
10790 return this.tableName != null;
10791 }
10792
10793 public void setTableNameIsSet(boolean value) {
10794 if (!value) {
10795 this.tableName = null;
10796 }
10797 }
10798
10799
10800
10801
10802 public byte[] getRow() {
10803 return this.row;
10804 }
10805
10806
10807
10808
10809 public getVer_args setRow(byte[] row) {
10810 this.row = row;
10811 return this;
10812 }
10813
10814 public void unsetRow() {
10815 this.row = null;
10816 }
10817
10818
10819 public boolean isSetRow() {
10820 return this.row != null;
10821 }
10822
10823 public void setRowIsSet(boolean value) {
10824 if (!value) {
10825 this.row = null;
10826 }
10827 }
10828
10829
10830
10831
10832 public byte[] getColumn() {
10833 return this.column;
10834 }
10835
10836
10837
10838
10839 public getVer_args setColumn(byte[] column) {
10840 this.column = column;
10841 return this;
10842 }
10843
10844 public void unsetColumn() {
10845 this.column = null;
10846 }
10847
10848
10849 public boolean isSetColumn() {
10850 return this.column != null;
10851 }
10852
10853 public void setColumnIsSet(boolean value) {
10854 if (!value) {
10855 this.column = null;
10856 }
10857 }
10858
10859
10860
10861
10862 public int getNumVersions() {
10863 return this.numVersions;
10864 }
10865
10866
10867
10868
10869 public getVer_args setNumVersions(int numVersions) {
10870 this.numVersions = numVersions;
10871 setNumVersionsIsSet(true);
10872 return this;
10873 }
10874
10875 public void unsetNumVersions() {
10876 __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID);
10877 }
10878
10879
10880 public boolean isSetNumVersions() {
10881 return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID);
10882 }
10883
10884 public void setNumVersionsIsSet(boolean value) {
10885 __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value);
10886 }
10887
10888 public void setFieldValue(_Fields field, Object value) {
10889 switch (field) {
10890 case TABLE_NAME:
10891 if (value == null) {
10892 unsetTableName();
10893 } else {
10894 setTableName((byte[])value);
10895 }
10896 break;
10897
10898 case ROW:
10899 if (value == null) {
10900 unsetRow();
10901 } else {
10902 setRow((byte[])value);
10903 }
10904 break;
10905
10906 case COLUMN:
10907 if (value == null) {
10908 unsetColumn();
10909 } else {
10910 setColumn((byte[])value);
10911 }
10912 break;
10913
10914 case NUM_VERSIONS:
10915 if (value == null) {
10916 unsetNumVersions();
10917 } else {
10918 setNumVersions((Integer)value);
10919 }
10920 break;
10921
10922 }
10923 }
10924
10925 public void setFieldValue(int fieldID, Object value) {
10926 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
10927 }
10928
10929 public Object getFieldValue(_Fields field) {
10930 switch (field) {
10931 case TABLE_NAME:
10932 return getTableName();
10933
10934 case ROW:
10935 return getRow();
10936
10937 case COLUMN:
10938 return getColumn();
10939
10940 case NUM_VERSIONS:
10941 return new Integer(getNumVersions());
10942
10943 }
10944 throw new IllegalStateException();
10945 }
10946
10947 public Object getFieldValue(int fieldId) {
10948 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
10949 }
10950
10951
10952 public boolean isSet(_Fields field) {
10953 switch (field) {
10954 case TABLE_NAME:
10955 return isSetTableName();
10956 case ROW:
10957 return isSetRow();
10958 case COLUMN:
10959 return isSetColumn();
10960 case NUM_VERSIONS:
10961 return isSetNumVersions();
10962 }
10963 throw new IllegalStateException();
10964 }
10965
10966 public boolean isSet(int fieldID) {
10967 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
10968 }
10969
10970 @Override
10971 public boolean equals(Object that) {
10972 if (that == null)
10973 return false;
10974 if (that instanceof getVer_args)
10975 return this.equals((getVer_args)that);
10976 return false;
10977 }
10978
10979 public boolean equals(getVer_args that) {
10980 if (that == null)
10981 return false;
10982
10983 boolean this_present_tableName = true && this.isSetTableName();
10984 boolean that_present_tableName = true && that.isSetTableName();
10985 if (this_present_tableName || that_present_tableName) {
10986 if (!(this_present_tableName && that_present_tableName))
10987 return false;
10988 if (!java.util.Arrays.equals(this.tableName, that.tableName))
10989 return false;
10990 }
10991
10992 boolean this_present_row = true && this.isSetRow();
10993 boolean that_present_row = true && that.isSetRow();
10994 if (this_present_row || that_present_row) {
10995 if (!(this_present_row && that_present_row))
10996 return false;
10997 if (!java.util.Arrays.equals(this.row, that.row))
10998 return false;
10999 }
11000
11001 boolean this_present_column = true && this.isSetColumn();
11002 boolean that_present_column = true && that.isSetColumn();
11003 if (this_present_column || that_present_column) {
11004 if (!(this_present_column && that_present_column))
11005 return false;
11006 if (!java.util.Arrays.equals(this.column, that.column))
11007 return false;
11008 }
11009
11010 boolean this_present_numVersions = true;
11011 boolean that_present_numVersions = true;
11012 if (this_present_numVersions || that_present_numVersions) {
11013 if (!(this_present_numVersions && that_present_numVersions))
11014 return false;
11015 if (this.numVersions != that.numVersions)
11016 return false;
11017 }
11018
11019 return true;
11020 }
11021
11022 @Override
11023 public int hashCode() {
11024 HashCodeBuilder builder = new HashCodeBuilder();
11025
11026 boolean present_tableName = true && (isSetTableName());
11027 builder.append(present_tableName);
11028 if (present_tableName)
11029 builder.append(tableName);
11030
11031 boolean present_row = true && (isSetRow());
11032 builder.append(present_row);
11033 if (present_row)
11034 builder.append(row);
11035
11036 boolean present_column = true && (isSetColumn());
11037 builder.append(present_column);
11038 if (present_column)
11039 builder.append(column);
11040
11041 boolean present_numVersions = true;
11042 builder.append(present_numVersions);
11043 if (present_numVersions)
11044 builder.append(numVersions);
11045
11046 return builder.toHashCode();
11047 }
11048
11049 public int compareTo(getVer_args other) {
11050 if (!getClass().equals(other.getClass())) {
11051 return getClass().getName().compareTo(other.getClass().getName());
11052 }
11053
11054 int lastComparison = 0;
11055 getVer_args typedOther = (getVer_args)other;
11056
11057 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
11058 if (lastComparison != 0) {
11059 return lastComparison;
11060 }
11061 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
11062 if (lastComparison != 0) {
11063 return lastComparison;
11064 }
11065 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
11066 if (lastComparison != 0) {
11067 return lastComparison;
11068 }
11069 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
11070 if (lastComparison != 0) {
11071 return lastComparison;
11072 }
11073 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
11074 if (lastComparison != 0) {
11075 return lastComparison;
11076 }
11077 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
11078 if (lastComparison != 0) {
11079 return lastComparison;
11080 }
11081 lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(isSetNumVersions());
11082 if (lastComparison != 0) {
11083 return lastComparison;
11084 }
11085 lastComparison = TBaseHelper.compareTo(numVersions, typedOther.numVersions);
11086 if (lastComparison != 0) {
11087 return lastComparison;
11088 }
11089 return 0;
11090 }
11091
11092 public void read(TProtocol iprot) throws TException {
11093 TField field;
11094 iprot.readStructBegin();
11095 while (true)
11096 {
11097 field = iprot.readFieldBegin();
11098 if (field.type == TType.STOP) {
11099 break;
11100 }
11101 _Fields fieldId = _Fields.findByThriftId(field.id);
11102 if (fieldId == null) {
11103 TProtocolUtil.skip(iprot, field.type);
11104 } else {
11105 switch (fieldId) {
11106 case TABLE_NAME:
11107 if (field.type == TType.STRING) {
11108 this.tableName = iprot.readBinary();
11109 } else {
11110 TProtocolUtil.skip(iprot, field.type);
11111 }
11112 break;
11113 case ROW:
11114 if (field.type == TType.STRING) {
11115 this.row = iprot.readBinary();
11116 } else {
11117 TProtocolUtil.skip(iprot, field.type);
11118 }
11119 break;
11120 case COLUMN:
11121 if (field.type == TType.STRING) {
11122 this.column = iprot.readBinary();
11123 } else {
11124 TProtocolUtil.skip(iprot, field.type);
11125 }
11126 break;
11127 case NUM_VERSIONS:
11128 if (field.type == TType.I32) {
11129 this.numVersions = iprot.readI32();
11130 setNumVersionsIsSet(true);
11131 } else {
11132 TProtocolUtil.skip(iprot, field.type);
11133 }
11134 break;
11135 }
11136 iprot.readFieldEnd();
11137 }
11138 }
11139 iprot.readStructEnd();
11140
11141
11142 validate();
11143 }
11144
11145 public void write(TProtocol oprot) throws TException {
11146 validate();
11147
11148 oprot.writeStructBegin(STRUCT_DESC);
11149 if (this.tableName != null) {
11150 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
11151 oprot.writeBinary(this.tableName);
11152 oprot.writeFieldEnd();
11153 }
11154 if (this.row != null) {
11155 oprot.writeFieldBegin(ROW_FIELD_DESC);
11156 oprot.writeBinary(this.row);
11157 oprot.writeFieldEnd();
11158 }
11159 if (this.column != null) {
11160 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
11161 oprot.writeBinary(this.column);
11162 oprot.writeFieldEnd();
11163 }
11164 oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
11165 oprot.writeI32(this.numVersions);
11166 oprot.writeFieldEnd();
11167 oprot.writeFieldStop();
11168 oprot.writeStructEnd();
11169 }
11170
11171 @Override
11172 public String toString() {
11173 StringBuilder sb = new StringBuilder("getVer_args(");
11174 boolean first = true;
11175
11176 sb.append("tableName:");
11177 if (this.tableName == null) {
11178 sb.append("null");
11179 } else {
11180 sb.append(this.tableName);
11181 }
11182 first = false;
11183 if (!first) sb.append(", ");
11184 sb.append("row:");
11185 if (this.row == null) {
11186 sb.append("null");
11187 } else {
11188 sb.append(this.row);
11189 }
11190 first = false;
11191 if (!first) sb.append(", ");
11192 sb.append("column:");
11193 if (this.column == null) {
11194 sb.append("null");
11195 } else {
11196 sb.append(this.column);
11197 }
11198 first = false;
11199 if (!first) sb.append(", ");
11200 sb.append("numVersions:");
11201 sb.append(this.numVersions);
11202 first = false;
11203 sb.append(")");
11204 return sb.toString();
11205 }
11206
11207 public void validate() throws TException {
11208
11209 }
11210
11211 }
11212
11213 public static class getVer_result implements TBase<getVer_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_result> {
11214 private static final TStruct STRUCT_DESC = new TStruct("getVer_result");
11215
11216 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
11217 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
11218
11219 public List<TCell> success;
11220 public IOError io;
11221
11222
11223 public enum _Fields implements TFieldIdEnum {
11224 SUCCESS((short)0, "success"),
11225 IO((short)1, "io");
11226
11227 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
11228 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11229
11230 static {
11231 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11232 byId.put((int)field._thriftId, field);
11233 byName.put(field.getFieldName(), field);
11234 }
11235 }
11236
11237
11238
11239
11240 public static _Fields findByThriftId(int fieldId) {
11241 return byId.get(fieldId);
11242 }
11243
11244
11245
11246
11247
11248 public static _Fields findByThriftIdOrThrow(int fieldId) {
11249 _Fields fields = findByThriftId(fieldId);
11250 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11251 return fields;
11252 }
11253
11254
11255
11256
11257 public static _Fields findByName(String name) {
11258 return byName.get(name);
11259 }
11260
11261 private final short _thriftId;
11262 private final String _fieldName;
11263
11264 _Fields(short thriftId, String fieldName) {
11265 _thriftId = thriftId;
11266 _fieldName = fieldName;
11267 }
11268
11269 public short getThriftFieldId() {
11270 return _thriftId;
11271 }
11272
11273 public String getFieldName() {
11274 return _fieldName;
11275 }
11276 }
11277
11278
11279
11280 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
11281 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
11282 new ListMetaData(TType.LIST,
11283 new StructMetaData(TType.STRUCT, TCell.class))));
11284 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
11285 new FieldValueMetaData(TType.STRUCT)));
11286 }});
11287
11288 static {
11289 FieldMetaData.addStructMetaDataMap(getVer_result.class, metaDataMap);
11290 }
11291
11292 public getVer_result() {
11293 }
11294
11295 public getVer_result(
11296 List<TCell> success,
11297 IOError io)
11298 {
11299 this();
11300 this.success = success;
11301 this.io = io;
11302 }
11303
11304
11305
11306
11307 public getVer_result(getVer_result other) {
11308 if (other.isSetSuccess()) {
11309 List<TCell> __this__success = new ArrayList<TCell>();
11310 for (TCell other_element : other.success) {
11311 __this__success.add(new TCell(other_element));
11312 }
11313 this.success = __this__success;
11314 }
11315 if (other.isSetIo()) {
11316 this.io = new IOError(other.io);
11317 }
11318 }
11319
11320 public getVer_result deepCopy() {
11321 return new getVer_result(this);
11322 }
11323
11324 @Deprecated
11325 public getVer_result clone() {
11326 return new getVer_result(this);
11327 }
11328
11329 public int getSuccessSize() {
11330 return (this.success == null) ? 0 : this.success.size();
11331 }
11332
11333 public java.util.Iterator<TCell> getSuccessIterator() {
11334 return (this.success == null) ? null : this.success.iterator();
11335 }
11336
11337 public void addToSuccess(TCell elem) {
11338 if (this.success == null) {
11339 this.success = new ArrayList<TCell>();
11340 }
11341 this.success.add(elem);
11342 }
11343
11344 public List<TCell> getSuccess() {
11345 return this.success;
11346 }
11347
11348 public getVer_result setSuccess(List<TCell> success) {
11349 this.success = success;
11350 return this;
11351 }
11352
11353 public void unsetSuccess() {
11354 this.success = null;
11355 }
11356
11357
11358 public boolean isSetSuccess() {
11359 return this.success != null;
11360 }
11361
11362 public void setSuccessIsSet(boolean value) {
11363 if (!value) {
11364 this.success = null;
11365 }
11366 }
11367
11368 public IOError getIo() {
11369 return this.io;
11370 }
11371
11372 public getVer_result setIo(IOError io) {
11373 this.io = io;
11374 return this;
11375 }
11376
11377 public void unsetIo() {
11378 this.io = null;
11379 }
11380
11381
11382 public boolean isSetIo() {
11383 return this.io != null;
11384 }
11385
11386 public void setIoIsSet(boolean value) {
11387 if (!value) {
11388 this.io = null;
11389 }
11390 }
11391
11392 public void setFieldValue(_Fields field, Object value) {
11393 switch (field) {
11394 case SUCCESS:
11395 if (value == null) {
11396 unsetSuccess();
11397 } else {
11398 setSuccess((List<TCell>)value);
11399 }
11400 break;
11401
11402 case IO:
11403 if (value == null) {
11404 unsetIo();
11405 } else {
11406 setIo((IOError)value);
11407 }
11408 break;
11409
11410 }
11411 }
11412
11413 public void setFieldValue(int fieldID, Object value) {
11414 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
11415 }
11416
11417 public Object getFieldValue(_Fields field) {
11418 switch (field) {
11419 case SUCCESS:
11420 return getSuccess();
11421
11422 case IO:
11423 return getIo();
11424
11425 }
11426 throw new IllegalStateException();
11427 }
11428
11429 public Object getFieldValue(int fieldId) {
11430 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
11431 }
11432
11433
11434 public boolean isSet(_Fields field) {
11435 switch (field) {
11436 case SUCCESS:
11437 return isSetSuccess();
11438 case IO:
11439 return isSetIo();
11440 }
11441 throw new IllegalStateException();
11442 }
11443
11444 public boolean isSet(int fieldID) {
11445 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
11446 }
11447
11448 @Override
11449 public boolean equals(Object that) {
11450 if (that == null)
11451 return false;
11452 if (that instanceof getVer_result)
11453 return this.equals((getVer_result)that);
11454 return false;
11455 }
11456
11457 public boolean equals(getVer_result that) {
11458 if (that == null)
11459 return false;
11460
11461 boolean this_present_success = true && this.isSetSuccess();
11462 boolean that_present_success = true && that.isSetSuccess();
11463 if (this_present_success || that_present_success) {
11464 if (!(this_present_success && that_present_success))
11465 return false;
11466 if (!this.success.equals(that.success))
11467 return false;
11468 }
11469
11470 boolean this_present_io = true && this.isSetIo();
11471 boolean that_present_io = true && that.isSetIo();
11472 if (this_present_io || that_present_io) {
11473 if (!(this_present_io && that_present_io))
11474 return false;
11475 if (!this.io.equals(that.io))
11476 return false;
11477 }
11478
11479 return true;
11480 }
11481
11482 @Override
11483 public int hashCode() {
11484 HashCodeBuilder builder = new HashCodeBuilder();
11485
11486 boolean present_success = true && (isSetSuccess());
11487 builder.append(present_success);
11488 if (present_success)
11489 builder.append(success);
11490
11491 boolean present_io = true && (isSetIo());
11492 builder.append(present_io);
11493 if (present_io)
11494 builder.append(io);
11495
11496 return builder.toHashCode();
11497 }
11498
11499 public int compareTo(getVer_result other) {
11500 if (!getClass().equals(other.getClass())) {
11501 return getClass().getName().compareTo(other.getClass().getName());
11502 }
11503
11504 int lastComparison = 0;
11505 getVer_result typedOther = (getVer_result)other;
11506
11507 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
11508 if (lastComparison != 0) {
11509 return lastComparison;
11510 }
11511 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
11512 if (lastComparison != 0) {
11513 return lastComparison;
11514 }
11515 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
11516 if (lastComparison != 0) {
11517 return lastComparison;
11518 }
11519 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
11520 if (lastComparison != 0) {
11521 return lastComparison;
11522 }
11523 return 0;
11524 }
11525
11526 public void read(TProtocol iprot) throws TException {
11527 TField field;
11528 iprot.readStructBegin();
11529 while (true)
11530 {
11531 field = iprot.readFieldBegin();
11532 if (field.type == TType.STOP) {
11533 break;
11534 }
11535 _Fields fieldId = _Fields.findByThriftId(field.id);
11536 if (fieldId == null) {
11537 TProtocolUtil.skip(iprot, field.type);
11538 } else {
11539 switch (fieldId) {
11540 case SUCCESS:
11541 if (field.type == TType.LIST) {
11542 {
11543 TList _list30 = iprot.readListBegin();
11544 this.success = new ArrayList<TCell>(_list30.size);
11545 for (int _i31 = 0; _i31 < _list30.size; ++_i31)
11546 {
11547 TCell _elem32;
11548 _elem32 = new TCell();
11549 _elem32.read(iprot);
11550 this.success.add(_elem32);
11551 }
11552 iprot.readListEnd();
11553 }
11554 } else {
11555 TProtocolUtil.skip(iprot, field.type);
11556 }
11557 break;
11558 case IO:
11559 if (field.type == TType.STRUCT) {
11560 this.io = new IOError();
11561 this.io.read(iprot);
11562 } else {
11563 TProtocolUtil.skip(iprot, field.type);
11564 }
11565 break;
11566 }
11567 iprot.readFieldEnd();
11568 }
11569 }
11570 iprot.readStructEnd();
11571
11572
11573 validate();
11574 }
11575
11576 public void write(TProtocol oprot) throws TException {
11577 oprot.writeStructBegin(STRUCT_DESC);
11578
11579 if (this.isSetSuccess()) {
11580 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11581 {
11582 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
11583 for (TCell _iter33 : this.success)
11584 {
11585 _iter33.write(oprot);
11586 }
11587 oprot.writeListEnd();
11588 }
11589 oprot.writeFieldEnd();
11590 } else if (this.isSetIo()) {
11591 oprot.writeFieldBegin(IO_FIELD_DESC);
11592 this.io.write(oprot);
11593 oprot.writeFieldEnd();
11594 }
11595 oprot.writeFieldStop();
11596 oprot.writeStructEnd();
11597 }
11598
11599 @Override
11600 public String toString() {
11601 StringBuilder sb = new StringBuilder("getVer_result(");
11602 boolean first = true;
11603
11604 sb.append("success:");
11605 if (this.success == null) {
11606 sb.append("null");
11607 } else {
11608 sb.append(this.success);
11609 }
11610 first = false;
11611 if (!first) sb.append(", ");
11612 sb.append("io:");
11613 if (this.io == null) {
11614 sb.append("null");
11615 } else {
11616 sb.append(this.io);
11617 }
11618 first = false;
11619 sb.append(")");
11620 return sb.toString();
11621 }
11622
11623 public void validate() throws TException {
11624
11625 }
11626
11627 }
11628
11629 public static class getVerTs_args implements TBase<getVerTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_args> {
11630 private static final TStruct STRUCT_DESC = new TStruct("getVerTs_args");
11631
11632 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
11633 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
11634 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
11635 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
11636 private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)5);
11637
11638
11639
11640
11641 public byte[] tableName;
11642
11643
11644
11645 public byte[] row;
11646
11647
11648
11649 public byte[] column;
11650
11651
11652
11653 public long timestamp;
11654
11655
11656
11657 public int numVersions;
11658
11659
11660 public enum _Fields implements TFieldIdEnum {
11661
11662
11663
11664 TABLE_NAME((short)1, "tableName"),
11665
11666
11667
11668 ROW((short)2, "row"),
11669
11670
11671
11672 COLUMN((short)3, "column"),
11673
11674
11675
11676 TIMESTAMP((short)4, "timestamp"),
11677
11678
11679
11680 NUM_VERSIONS((short)5, "numVersions");
11681
11682 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
11683 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11684
11685 static {
11686 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11687 byId.put((int)field._thriftId, field);
11688 byName.put(field.getFieldName(), field);
11689 }
11690 }
11691
11692
11693
11694
11695 public static _Fields findByThriftId(int fieldId) {
11696 return byId.get(fieldId);
11697 }
11698
11699
11700
11701
11702
11703 public static _Fields findByThriftIdOrThrow(int fieldId) {
11704 _Fields fields = findByThriftId(fieldId);
11705 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11706 return fields;
11707 }
11708
11709
11710
11711
11712 public static _Fields findByName(String name) {
11713 return byName.get(name);
11714 }
11715
11716 private final short _thriftId;
11717 private final String _fieldName;
11718
11719 _Fields(short thriftId, String fieldName) {
11720 _thriftId = thriftId;
11721 _fieldName = fieldName;
11722 }
11723
11724 public short getThriftFieldId() {
11725 return _thriftId;
11726 }
11727
11728 public String getFieldName() {
11729 return _fieldName;
11730 }
11731 }
11732
11733
11734 private static final int __TIMESTAMP_ISSET_ID = 0;
11735 private static final int __NUMVERSIONS_ISSET_ID = 1;
11736 private BitSet __isset_bit_vector = new BitSet(2);
11737
11738 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
11739 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
11740 new FieldValueMetaData(TType.STRING)));
11741 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
11742 new FieldValueMetaData(TType.STRING)));
11743 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
11744 new FieldValueMetaData(TType.STRING)));
11745 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
11746 new FieldValueMetaData(TType.I64)));
11747 put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT,
11748 new FieldValueMetaData(TType.I32)));
11749 }});
11750
11751 static {
11752 FieldMetaData.addStructMetaDataMap(getVerTs_args.class, metaDataMap);
11753 }
11754
11755 public getVerTs_args() {
11756 }
11757
11758 public getVerTs_args(
11759 byte[] tableName,
11760 byte[] row,
11761 byte[] column,
11762 long timestamp,
11763 int numVersions)
11764 {
11765 this();
11766 this.tableName = tableName;
11767 this.row = row;
11768 this.column = column;
11769 this.timestamp = timestamp;
11770 setTimestampIsSet(true);
11771 this.numVersions = numVersions;
11772 setNumVersionsIsSet(true);
11773 }
11774
11775
11776
11777
11778 public getVerTs_args(getVerTs_args other) {
11779 __isset_bit_vector.clear();
11780 __isset_bit_vector.or(other.__isset_bit_vector);
11781 if (other.isSetTableName()) {
11782 this.tableName = other.tableName;
11783 }
11784 if (other.isSetRow()) {
11785 this.row = other.row;
11786 }
11787 if (other.isSetColumn()) {
11788 this.column = other.column;
11789 }
11790 this.timestamp = other.timestamp;
11791 this.numVersions = other.numVersions;
11792 }
11793
11794 public getVerTs_args deepCopy() {
11795 return new getVerTs_args(this);
11796 }
11797
11798 @Deprecated
11799 public getVerTs_args clone() {
11800 return new getVerTs_args(this);
11801 }
11802
11803
11804
11805
11806 public byte[] getTableName() {
11807 return this.tableName;
11808 }
11809
11810
11811
11812
11813 public getVerTs_args setTableName(byte[] tableName) {
11814 this.tableName = tableName;
11815 return this;
11816 }
11817
11818 public void unsetTableName() {
11819 this.tableName = null;
11820 }
11821
11822
11823 public boolean isSetTableName() {
11824 return this.tableName != null;
11825 }
11826
11827 public void setTableNameIsSet(boolean value) {
11828 if (!value) {
11829 this.tableName = null;
11830 }
11831 }
11832
11833
11834
11835
11836 public byte[] getRow() {
11837 return this.row;
11838 }
11839
11840
11841
11842
11843 public getVerTs_args setRow(byte[] row) {
11844 this.row = row;
11845 return this;
11846 }
11847
11848 public void unsetRow() {
11849 this.row = null;
11850 }
11851
11852
11853 public boolean isSetRow() {
11854 return this.row != null;
11855 }
11856
11857 public void setRowIsSet(boolean value) {
11858 if (!value) {
11859 this.row = null;
11860 }
11861 }
11862
11863
11864
11865
11866 public byte[] getColumn() {
11867 return this.column;
11868 }
11869
11870
11871
11872
11873 public getVerTs_args setColumn(byte[] column) {
11874 this.column = column;
11875 return this;
11876 }
11877
11878 public void unsetColumn() {
11879 this.column = null;
11880 }
11881
11882
11883 public boolean isSetColumn() {
11884 return this.column != null;
11885 }
11886
11887 public void setColumnIsSet(boolean value) {
11888 if (!value) {
11889 this.column = null;
11890 }
11891 }
11892
11893
11894
11895
11896 public long getTimestamp() {
11897 return this.timestamp;
11898 }
11899
11900
11901
11902
11903 public getVerTs_args setTimestamp(long timestamp) {
11904 this.timestamp = timestamp;
11905 setTimestampIsSet(true);
11906 return this;
11907 }
11908
11909 public void unsetTimestamp() {
11910 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
11911 }
11912
11913
11914 public boolean isSetTimestamp() {
11915 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
11916 }
11917
11918 public void setTimestampIsSet(boolean value) {
11919 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
11920 }
11921
11922
11923
11924
11925 public int getNumVersions() {
11926 return this.numVersions;
11927 }
11928
11929
11930
11931
11932 public getVerTs_args setNumVersions(int numVersions) {
11933 this.numVersions = numVersions;
11934 setNumVersionsIsSet(true);
11935 return this;
11936 }
11937
11938 public void unsetNumVersions() {
11939 __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID);
11940 }
11941
11942
11943 public boolean isSetNumVersions() {
11944 return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID);
11945 }
11946
11947 public void setNumVersionsIsSet(boolean value) {
11948 __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value);
11949 }
11950
11951 public void setFieldValue(_Fields field, Object value) {
11952 switch (field) {
11953 case TABLE_NAME:
11954 if (value == null) {
11955 unsetTableName();
11956 } else {
11957 setTableName((byte[])value);
11958 }
11959 break;
11960
11961 case ROW:
11962 if (value == null) {
11963 unsetRow();
11964 } else {
11965 setRow((byte[])value);
11966 }
11967 break;
11968
11969 case COLUMN:
11970 if (value == null) {
11971 unsetColumn();
11972 } else {
11973 setColumn((byte[])value);
11974 }
11975 break;
11976
11977 case TIMESTAMP:
11978 if (value == null) {
11979 unsetTimestamp();
11980 } else {
11981 setTimestamp((Long)value);
11982 }
11983 break;
11984
11985 case NUM_VERSIONS:
11986 if (value == null) {
11987 unsetNumVersions();
11988 } else {
11989 setNumVersions((Integer)value);
11990 }
11991 break;
11992
11993 }
11994 }
11995
11996 public void setFieldValue(int fieldID, Object value) {
11997 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
11998 }
11999
12000 public Object getFieldValue(_Fields field) {
12001 switch (field) {
12002 case TABLE_NAME:
12003 return getTableName();
12004
12005 case ROW:
12006 return getRow();
12007
12008 case COLUMN:
12009 return getColumn();
12010
12011 case TIMESTAMP:
12012 return new Long(getTimestamp());
12013
12014 case NUM_VERSIONS:
12015 return new Integer(getNumVersions());
12016
12017 }
12018 throw new IllegalStateException();
12019 }
12020
12021 public Object getFieldValue(int fieldId) {
12022 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12023 }
12024
12025
12026 public boolean isSet(_Fields field) {
12027 switch (field) {
12028 case TABLE_NAME:
12029 return isSetTableName();
12030 case ROW:
12031 return isSetRow();
12032 case COLUMN:
12033 return isSetColumn();
12034 case TIMESTAMP:
12035 return isSetTimestamp();
12036 case NUM_VERSIONS:
12037 return isSetNumVersions();
12038 }
12039 throw new IllegalStateException();
12040 }
12041
12042 public boolean isSet(int fieldID) {
12043 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12044 }
12045
12046 @Override
12047 public boolean equals(Object that) {
12048 if (that == null)
12049 return false;
12050 if (that instanceof getVerTs_args)
12051 return this.equals((getVerTs_args)that);
12052 return false;
12053 }
12054
12055 public boolean equals(getVerTs_args that) {
12056 if (that == null)
12057 return false;
12058
12059 boolean this_present_tableName = true && this.isSetTableName();
12060 boolean that_present_tableName = true && that.isSetTableName();
12061 if (this_present_tableName || that_present_tableName) {
12062 if (!(this_present_tableName && that_present_tableName))
12063 return false;
12064 if (!java.util.Arrays.equals(this.tableName, that.tableName))
12065 return false;
12066 }
12067
12068 boolean this_present_row = true && this.isSetRow();
12069 boolean that_present_row = true && that.isSetRow();
12070 if (this_present_row || that_present_row) {
12071 if (!(this_present_row && that_present_row))
12072 return false;
12073 if (!java.util.Arrays.equals(this.row, that.row))
12074 return false;
12075 }
12076
12077 boolean this_present_column = true && this.isSetColumn();
12078 boolean that_present_column = true && that.isSetColumn();
12079 if (this_present_column || that_present_column) {
12080 if (!(this_present_column && that_present_column))
12081 return false;
12082 if (!java.util.Arrays.equals(this.column, that.column))
12083 return false;
12084 }
12085
12086 boolean this_present_timestamp = true;
12087 boolean that_present_timestamp = true;
12088 if (this_present_timestamp || that_present_timestamp) {
12089 if (!(this_present_timestamp && that_present_timestamp))
12090 return false;
12091 if (this.timestamp != that.timestamp)
12092 return false;
12093 }
12094
12095 boolean this_present_numVersions = true;
12096 boolean that_present_numVersions = true;
12097 if (this_present_numVersions || that_present_numVersions) {
12098 if (!(this_present_numVersions && that_present_numVersions))
12099 return false;
12100 if (this.numVersions != that.numVersions)
12101 return false;
12102 }
12103
12104 return true;
12105 }
12106
12107 @Override
12108 public int hashCode() {
12109 HashCodeBuilder builder = new HashCodeBuilder();
12110
12111 boolean present_tableName = true && (isSetTableName());
12112 builder.append(present_tableName);
12113 if (present_tableName)
12114 builder.append(tableName);
12115
12116 boolean present_row = true && (isSetRow());
12117 builder.append(present_row);
12118 if (present_row)
12119 builder.append(row);
12120
12121 boolean present_column = true && (isSetColumn());
12122 builder.append(present_column);
12123 if (present_column)
12124 builder.append(column);
12125
12126 boolean present_timestamp = true;
12127 builder.append(present_timestamp);
12128 if (present_timestamp)
12129 builder.append(timestamp);
12130
12131 boolean present_numVersions = true;
12132 builder.append(present_numVersions);
12133 if (present_numVersions)
12134 builder.append(numVersions);
12135
12136 return builder.toHashCode();
12137 }
12138
12139 public int compareTo(getVerTs_args other) {
12140 if (!getClass().equals(other.getClass())) {
12141 return getClass().getName().compareTo(other.getClass().getName());
12142 }
12143
12144 int lastComparison = 0;
12145 getVerTs_args typedOther = (getVerTs_args)other;
12146
12147 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
12148 if (lastComparison != 0) {
12149 return lastComparison;
12150 }
12151 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
12152 if (lastComparison != 0) {
12153 return lastComparison;
12154 }
12155 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
12156 if (lastComparison != 0) {
12157 return lastComparison;
12158 }
12159 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
12160 if (lastComparison != 0) {
12161 return lastComparison;
12162 }
12163 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
12164 if (lastComparison != 0) {
12165 return lastComparison;
12166 }
12167 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
12168 if (lastComparison != 0) {
12169 return lastComparison;
12170 }
12171 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
12172 if (lastComparison != 0) {
12173 return lastComparison;
12174 }
12175 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
12176 if (lastComparison != 0) {
12177 return lastComparison;
12178 }
12179 lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(isSetNumVersions());
12180 if (lastComparison != 0) {
12181 return lastComparison;
12182 }
12183 lastComparison = TBaseHelper.compareTo(numVersions, typedOther.numVersions);
12184 if (lastComparison != 0) {
12185 return lastComparison;
12186 }
12187 return 0;
12188 }
12189
12190 public void read(TProtocol iprot) throws TException {
12191 TField field;
12192 iprot.readStructBegin();
12193 while (true)
12194 {
12195 field = iprot.readFieldBegin();
12196 if (field.type == TType.STOP) {
12197 break;
12198 }
12199 _Fields fieldId = _Fields.findByThriftId(field.id);
12200 if (fieldId == null) {
12201 TProtocolUtil.skip(iprot, field.type);
12202 } else {
12203 switch (fieldId) {
12204 case TABLE_NAME:
12205 if (field.type == TType.STRING) {
12206 this.tableName = iprot.readBinary();
12207 } else {
12208 TProtocolUtil.skip(iprot, field.type);
12209 }
12210 break;
12211 case ROW:
12212 if (field.type == TType.STRING) {
12213 this.row = iprot.readBinary();
12214 } else {
12215 TProtocolUtil.skip(iprot, field.type);
12216 }
12217 break;
12218 case COLUMN:
12219 if (field.type == TType.STRING) {
12220 this.column = iprot.readBinary();
12221 } else {
12222 TProtocolUtil.skip(iprot, field.type);
12223 }
12224 break;
12225 case TIMESTAMP:
12226 if (field.type == TType.I64) {
12227 this.timestamp = iprot.readI64();
12228 setTimestampIsSet(true);
12229 } else {
12230 TProtocolUtil.skip(iprot, field.type);
12231 }
12232 break;
12233 case NUM_VERSIONS:
12234 if (field.type == TType.I32) {
12235 this.numVersions = iprot.readI32();
12236 setNumVersionsIsSet(true);
12237 } else {
12238 TProtocolUtil.skip(iprot, field.type);
12239 }
12240 break;
12241 }
12242 iprot.readFieldEnd();
12243 }
12244 }
12245 iprot.readStructEnd();
12246
12247
12248 validate();
12249 }
12250
12251 public void write(TProtocol oprot) throws TException {
12252 validate();
12253
12254 oprot.writeStructBegin(STRUCT_DESC);
12255 if (this.tableName != null) {
12256 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
12257 oprot.writeBinary(this.tableName);
12258 oprot.writeFieldEnd();
12259 }
12260 if (this.row != null) {
12261 oprot.writeFieldBegin(ROW_FIELD_DESC);
12262 oprot.writeBinary(this.row);
12263 oprot.writeFieldEnd();
12264 }
12265 if (this.column != null) {
12266 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
12267 oprot.writeBinary(this.column);
12268 oprot.writeFieldEnd();
12269 }
12270 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
12271 oprot.writeI64(this.timestamp);
12272 oprot.writeFieldEnd();
12273 oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
12274 oprot.writeI32(this.numVersions);
12275 oprot.writeFieldEnd();
12276 oprot.writeFieldStop();
12277 oprot.writeStructEnd();
12278 }
12279
12280 @Override
12281 public String toString() {
12282 StringBuilder sb = new StringBuilder("getVerTs_args(");
12283 boolean first = true;
12284
12285 sb.append("tableName:");
12286 if (this.tableName == null) {
12287 sb.append("null");
12288 } else {
12289 sb.append(this.tableName);
12290 }
12291 first = false;
12292 if (!first) sb.append(", ");
12293 sb.append("row:");
12294 if (this.row == null) {
12295 sb.append("null");
12296 } else {
12297 sb.append(this.row);
12298 }
12299 first = false;
12300 if (!first) sb.append(", ");
12301 sb.append("column:");
12302 if (this.column == null) {
12303 sb.append("null");
12304 } else {
12305 sb.append(this.column);
12306 }
12307 first = false;
12308 if (!first) sb.append(", ");
12309 sb.append("timestamp:");
12310 sb.append(this.timestamp);
12311 first = false;
12312 if (!first) sb.append(", ");
12313 sb.append("numVersions:");
12314 sb.append(this.numVersions);
12315 first = false;
12316 sb.append(")");
12317 return sb.toString();
12318 }
12319
12320 public void validate() throws TException {
12321
12322 }
12323
12324 }
12325
12326 public static class getVerTs_result implements TBase<getVerTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_result> {
12327 private static final TStruct STRUCT_DESC = new TStruct("getVerTs_result");
12328
12329 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
12330 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
12331
12332 public List<TCell> success;
12333 public IOError io;
12334
12335
12336 public enum _Fields implements TFieldIdEnum {
12337 SUCCESS((short)0, "success"),
12338 IO((short)1, "io");
12339
12340 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12341 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12342
12343 static {
12344 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12345 byId.put((int)field._thriftId, field);
12346 byName.put(field.getFieldName(), field);
12347 }
12348 }
12349
12350
12351
12352
12353 public static _Fields findByThriftId(int fieldId) {
12354 return byId.get(fieldId);
12355 }
12356
12357
12358
12359
12360
12361 public static _Fields findByThriftIdOrThrow(int fieldId) {
12362 _Fields fields = findByThriftId(fieldId);
12363 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12364 return fields;
12365 }
12366
12367
12368
12369
12370 public static _Fields findByName(String name) {
12371 return byName.get(name);
12372 }
12373
12374 private final short _thriftId;
12375 private final String _fieldName;
12376
12377 _Fields(short thriftId, String fieldName) {
12378 _thriftId = thriftId;
12379 _fieldName = fieldName;
12380 }
12381
12382 public short getThriftFieldId() {
12383 return _thriftId;
12384 }
12385
12386 public String getFieldName() {
12387 return _fieldName;
12388 }
12389 }
12390
12391
12392
12393 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12394 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
12395 new ListMetaData(TType.LIST,
12396 new StructMetaData(TType.STRUCT, TCell.class))));
12397 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
12398 new FieldValueMetaData(TType.STRUCT)));
12399 }});
12400
12401 static {
12402 FieldMetaData.addStructMetaDataMap(getVerTs_result.class, metaDataMap);
12403 }
12404
12405 public getVerTs_result() {
12406 }
12407
12408 public getVerTs_result(
12409 List<TCell> success,
12410 IOError io)
12411 {
12412 this();
12413 this.success = success;
12414 this.io = io;
12415 }
12416
12417
12418
12419
12420 public getVerTs_result(getVerTs_result other) {
12421 if (other.isSetSuccess()) {
12422 List<TCell> __this__success = new ArrayList<TCell>();
12423 for (TCell other_element : other.success) {
12424 __this__success.add(new TCell(other_element));
12425 }
12426 this.success = __this__success;
12427 }
12428 if (other.isSetIo()) {
12429 this.io = new IOError(other.io);
12430 }
12431 }
12432
12433 public getVerTs_result deepCopy() {
12434 return new getVerTs_result(this);
12435 }
12436
12437 @Deprecated
12438 public getVerTs_result clone() {
12439 return new getVerTs_result(this);
12440 }
12441
12442 public int getSuccessSize() {
12443 return (this.success == null) ? 0 : this.success.size();
12444 }
12445
12446 public java.util.Iterator<TCell> getSuccessIterator() {
12447 return (this.success == null) ? null : this.success.iterator();
12448 }
12449
12450 public void addToSuccess(TCell elem) {
12451 if (this.success == null) {
12452 this.success = new ArrayList<TCell>();
12453 }
12454 this.success.add(elem);
12455 }
12456
12457 public List<TCell> getSuccess() {
12458 return this.success;
12459 }
12460
12461 public getVerTs_result setSuccess(List<TCell> success) {
12462 this.success = success;
12463 return this;
12464 }
12465
12466 public void unsetSuccess() {
12467 this.success = null;
12468 }
12469
12470
12471 public boolean isSetSuccess() {
12472 return this.success != null;
12473 }
12474
12475 public void setSuccessIsSet(boolean value) {
12476 if (!value) {
12477 this.success = null;
12478 }
12479 }
12480
12481 public IOError getIo() {
12482 return this.io;
12483 }
12484
12485 public getVerTs_result setIo(IOError io) {
12486 this.io = io;
12487 return this;
12488 }
12489
12490 public void unsetIo() {
12491 this.io = null;
12492 }
12493
12494
12495 public boolean isSetIo() {
12496 return this.io != null;
12497 }
12498
12499 public void setIoIsSet(boolean value) {
12500 if (!value) {
12501 this.io = null;
12502 }
12503 }
12504
12505 public void setFieldValue(_Fields field, Object value) {
12506 switch (field) {
12507 case SUCCESS:
12508 if (value == null) {
12509 unsetSuccess();
12510 } else {
12511 setSuccess((List<TCell>)value);
12512 }
12513 break;
12514
12515 case IO:
12516 if (value == null) {
12517 unsetIo();
12518 } else {
12519 setIo((IOError)value);
12520 }
12521 break;
12522
12523 }
12524 }
12525
12526 public void setFieldValue(int fieldID, Object value) {
12527 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
12528 }
12529
12530 public Object getFieldValue(_Fields field) {
12531 switch (field) {
12532 case SUCCESS:
12533 return getSuccess();
12534
12535 case IO:
12536 return getIo();
12537
12538 }
12539 throw new IllegalStateException();
12540 }
12541
12542 public Object getFieldValue(int fieldId) {
12543 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12544 }
12545
12546
12547 public boolean isSet(_Fields field) {
12548 switch (field) {
12549 case SUCCESS:
12550 return isSetSuccess();
12551 case IO:
12552 return isSetIo();
12553 }
12554 throw new IllegalStateException();
12555 }
12556
12557 public boolean isSet(int fieldID) {
12558 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12559 }
12560
12561 @Override
12562 public boolean equals(Object that) {
12563 if (that == null)
12564 return false;
12565 if (that instanceof getVerTs_result)
12566 return this.equals((getVerTs_result)that);
12567 return false;
12568 }
12569
12570 public boolean equals(getVerTs_result that) {
12571 if (that == null)
12572 return false;
12573
12574 boolean this_present_success = true && this.isSetSuccess();
12575 boolean that_present_success = true && that.isSetSuccess();
12576 if (this_present_success || that_present_success) {
12577 if (!(this_present_success && that_present_success))
12578 return false;
12579 if (!this.success.equals(that.success))
12580 return false;
12581 }
12582
12583 boolean this_present_io = true && this.isSetIo();
12584 boolean that_present_io = true && that.isSetIo();
12585 if (this_present_io || that_present_io) {
12586 if (!(this_present_io && that_present_io))
12587 return false;
12588 if (!this.io.equals(that.io))
12589 return false;
12590 }
12591
12592 return true;
12593 }
12594
12595 @Override
12596 public int hashCode() {
12597 HashCodeBuilder builder = new HashCodeBuilder();
12598
12599 boolean present_success = true && (isSetSuccess());
12600 builder.append(present_success);
12601 if (present_success)
12602 builder.append(success);
12603
12604 boolean present_io = true && (isSetIo());
12605 builder.append(present_io);
12606 if (present_io)
12607 builder.append(io);
12608
12609 return builder.toHashCode();
12610 }
12611
12612 public int compareTo(getVerTs_result other) {
12613 if (!getClass().equals(other.getClass())) {
12614 return getClass().getName().compareTo(other.getClass().getName());
12615 }
12616
12617 int lastComparison = 0;
12618 getVerTs_result typedOther = (getVerTs_result)other;
12619
12620 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
12621 if (lastComparison != 0) {
12622 return lastComparison;
12623 }
12624 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
12625 if (lastComparison != 0) {
12626 return lastComparison;
12627 }
12628 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
12629 if (lastComparison != 0) {
12630 return lastComparison;
12631 }
12632 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
12633 if (lastComparison != 0) {
12634 return lastComparison;
12635 }
12636 return 0;
12637 }
12638
12639 public void read(TProtocol iprot) throws TException {
12640 TField field;
12641 iprot.readStructBegin();
12642 while (true)
12643 {
12644 field = iprot.readFieldBegin();
12645 if (field.type == TType.STOP) {
12646 break;
12647 }
12648 _Fields fieldId = _Fields.findByThriftId(field.id);
12649 if (fieldId == null) {
12650 TProtocolUtil.skip(iprot, field.type);
12651 } else {
12652 switch (fieldId) {
12653 case SUCCESS:
12654 if (field.type == TType.LIST) {
12655 {
12656 TList _list34 = iprot.readListBegin();
12657 this.success = new ArrayList<TCell>(_list34.size);
12658 for (int _i35 = 0; _i35 < _list34.size; ++_i35)
12659 {
12660 TCell _elem36;
12661 _elem36 = new TCell();
12662 _elem36.read(iprot);
12663 this.success.add(_elem36);
12664 }
12665 iprot.readListEnd();
12666 }
12667 } else {
12668 TProtocolUtil.skip(iprot, field.type);
12669 }
12670 break;
12671 case IO:
12672 if (field.type == TType.STRUCT) {
12673 this.io = new IOError();
12674 this.io.read(iprot);
12675 } else {
12676 TProtocolUtil.skip(iprot, field.type);
12677 }
12678 break;
12679 }
12680 iprot.readFieldEnd();
12681 }
12682 }
12683 iprot.readStructEnd();
12684
12685
12686 validate();
12687 }
12688
12689 public void write(TProtocol oprot) throws TException {
12690 oprot.writeStructBegin(STRUCT_DESC);
12691
12692 if (this.isSetSuccess()) {
12693 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12694 {
12695 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
12696 for (TCell _iter37 : this.success)
12697 {
12698 _iter37.write(oprot);
12699 }
12700 oprot.writeListEnd();
12701 }
12702 oprot.writeFieldEnd();
12703 } else if (this.isSetIo()) {
12704 oprot.writeFieldBegin(IO_FIELD_DESC);
12705 this.io.write(oprot);
12706 oprot.writeFieldEnd();
12707 }
12708 oprot.writeFieldStop();
12709 oprot.writeStructEnd();
12710 }
12711
12712 @Override
12713 public String toString() {
12714 StringBuilder sb = new StringBuilder("getVerTs_result(");
12715 boolean first = true;
12716
12717 sb.append("success:");
12718 if (this.success == null) {
12719 sb.append("null");
12720 } else {
12721 sb.append(this.success);
12722 }
12723 first = false;
12724 if (!first) sb.append(", ");
12725 sb.append("io:");
12726 if (this.io == null) {
12727 sb.append("null");
12728 } else {
12729 sb.append(this.io);
12730 }
12731 first = false;
12732 sb.append(")");
12733 return sb.toString();
12734 }
12735
12736 public void validate() throws TException {
12737
12738 }
12739
12740 }
12741
12742 public static class getRow_args implements TBase<getRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRow_args> {
12743 private static final TStruct STRUCT_DESC = new TStruct("getRow_args");
12744
12745 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
12746 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
12747
12748
12749
12750
12751 public byte[] tableName;
12752
12753
12754
12755 public byte[] row;
12756
12757
12758 public enum _Fields implements TFieldIdEnum {
12759
12760
12761
12762 TABLE_NAME((short)1, "tableName"),
12763
12764
12765
12766 ROW((short)2, "row");
12767
12768 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12769 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12770
12771 static {
12772 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12773 byId.put((int)field._thriftId, field);
12774 byName.put(field.getFieldName(), field);
12775 }
12776 }
12777
12778
12779
12780
12781 public static _Fields findByThriftId(int fieldId) {
12782 return byId.get(fieldId);
12783 }
12784
12785
12786
12787
12788
12789 public static _Fields findByThriftIdOrThrow(int fieldId) {
12790 _Fields fields = findByThriftId(fieldId);
12791 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12792 return fields;
12793 }
12794
12795
12796
12797
12798 public static _Fields findByName(String name) {
12799 return byName.get(name);
12800 }
12801
12802 private final short _thriftId;
12803 private final String _fieldName;
12804
12805 _Fields(short thriftId, String fieldName) {
12806 _thriftId = thriftId;
12807 _fieldName = fieldName;
12808 }
12809
12810 public short getThriftFieldId() {
12811 return _thriftId;
12812 }
12813
12814 public String getFieldName() {
12815 return _fieldName;
12816 }
12817 }
12818
12819
12820
12821 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12822 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
12823 new FieldValueMetaData(TType.STRING)));
12824 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
12825 new FieldValueMetaData(TType.STRING)));
12826 }});
12827
12828 static {
12829 FieldMetaData.addStructMetaDataMap(getRow_args.class, metaDataMap);
12830 }
12831
12832 public getRow_args() {
12833 }
12834
12835 public getRow_args(
12836 byte[] tableName,
12837 byte[] row)
12838 {
12839 this();
12840 this.tableName = tableName;
12841 this.row = row;
12842 }
12843
12844
12845
12846
12847 public getRow_args(getRow_args other) {
12848 if (other.isSetTableName()) {
12849 this.tableName = other.tableName;
12850 }
12851 if (other.isSetRow()) {
12852 this.row = other.row;
12853 }
12854 }
12855
12856 public getRow_args deepCopy() {
12857 return new getRow_args(this);
12858 }
12859
12860 @Deprecated
12861 public getRow_args clone() {
12862 return new getRow_args(this);
12863 }
12864
12865
12866
12867
12868 public byte[] getTableName() {
12869 return this.tableName;
12870 }
12871
12872
12873
12874
12875 public getRow_args setTableName(byte[] tableName) {
12876 this.tableName = tableName;
12877 return this;
12878 }
12879
12880 public void unsetTableName() {
12881 this.tableName = null;
12882 }
12883
12884
12885 public boolean isSetTableName() {
12886 return this.tableName != null;
12887 }
12888
12889 public void setTableNameIsSet(boolean value) {
12890 if (!value) {
12891 this.tableName = null;
12892 }
12893 }
12894
12895
12896
12897
12898 public byte[] getRow() {
12899 return this.row;
12900 }
12901
12902
12903
12904
12905 public getRow_args setRow(byte[] row) {
12906 this.row = row;
12907 return this;
12908 }
12909
12910 public void unsetRow() {
12911 this.row = null;
12912 }
12913
12914
12915 public boolean isSetRow() {
12916 return this.row != null;
12917 }
12918
12919 public void setRowIsSet(boolean value) {
12920 if (!value) {
12921 this.row = null;
12922 }
12923 }
12924
12925 public void setFieldValue(_Fields field, Object value) {
12926 switch (field) {
12927 case TABLE_NAME:
12928 if (value == null) {
12929 unsetTableName();
12930 } else {
12931 setTableName((byte[])value);
12932 }
12933 break;
12934
12935 case ROW:
12936 if (value == null) {
12937 unsetRow();
12938 } else {
12939 setRow((byte[])value);
12940 }
12941 break;
12942
12943 }
12944 }
12945
12946 public void setFieldValue(int fieldID, Object value) {
12947 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
12948 }
12949
12950 public Object getFieldValue(_Fields field) {
12951 switch (field) {
12952 case TABLE_NAME:
12953 return getTableName();
12954
12955 case ROW:
12956 return getRow();
12957
12958 }
12959 throw new IllegalStateException();
12960 }
12961
12962 public Object getFieldValue(int fieldId) {
12963 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12964 }
12965
12966
12967 public boolean isSet(_Fields field) {
12968 switch (field) {
12969 case TABLE_NAME:
12970 return isSetTableName();
12971 case ROW:
12972 return isSetRow();
12973 }
12974 throw new IllegalStateException();
12975 }
12976
12977 public boolean isSet(int fieldID) {
12978 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12979 }
12980
12981 @Override
12982 public boolean equals(Object that) {
12983 if (that == null)
12984 return false;
12985 if (that instanceof getRow_args)
12986 return this.equals((getRow_args)that);
12987 return false;
12988 }
12989
12990 public boolean equals(getRow_args that) {
12991 if (that == null)
12992 return false;
12993
12994 boolean this_present_tableName = true && this.isSetTableName();
12995 boolean that_present_tableName = true && that.isSetTableName();
12996 if (this_present_tableName || that_present_tableName) {
12997 if (!(this_present_tableName && that_present_tableName))
12998 return false;
12999 if (!java.util.Arrays.equals(this.tableName, that.tableName))
13000 return false;
13001 }
13002
13003 boolean this_present_row = true && this.isSetRow();
13004 boolean that_present_row = true && that.isSetRow();
13005 if (this_present_row || that_present_row) {
13006 if (!(this_present_row && that_present_row))
13007 return false;
13008 if (!java.util.Arrays.equals(this.row, that.row))
13009 return false;
13010 }
13011
13012 return true;
13013 }
13014
13015 @Override
13016 public int hashCode() {
13017 HashCodeBuilder builder = new HashCodeBuilder();
13018
13019 boolean present_tableName = true && (isSetTableName());
13020 builder.append(present_tableName);
13021 if (present_tableName)
13022 builder.append(tableName);
13023
13024 boolean present_row = true && (isSetRow());
13025 builder.append(present_row);
13026 if (present_row)
13027 builder.append(row);
13028
13029 return builder.toHashCode();
13030 }
13031
13032 public int compareTo(getRow_args other) {
13033 if (!getClass().equals(other.getClass())) {
13034 return getClass().getName().compareTo(other.getClass().getName());
13035 }
13036
13037 int lastComparison = 0;
13038 getRow_args typedOther = (getRow_args)other;
13039
13040 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
13041 if (lastComparison != 0) {
13042 return lastComparison;
13043 }
13044 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
13045 if (lastComparison != 0) {
13046 return lastComparison;
13047 }
13048 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
13049 if (lastComparison != 0) {
13050 return lastComparison;
13051 }
13052 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
13053 if (lastComparison != 0) {
13054 return lastComparison;
13055 }
13056 return 0;
13057 }
13058
13059 public void read(TProtocol iprot) throws TException {
13060 TField field;
13061 iprot.readStructBegin();
13062 while (true)
13063 {
13064 field = iprot.readFieldBegin();
13065 if (field.type == TType.STOP) {
13066 break;
13067 }
13068 _Fields fieldId = _Fields.findByThriftId(field.id);
13069 if (fieldId == null) {
13070 TProtocolUtil.skip(iprot, field.type);
13071 } else {
13072 switch (fieldId) {
13073 case TABLE_NAME:
13074 if (field.type == TType.STRING) {
13075 this.tableName = iprot.readBinary();
13076 } else {
13077 TProtocolUtil.skip(iprot, field.type);
13078 }
13079 break;
13080 case ROW:
13081 if (field.type == TType.STRING) {
13082 this.row = iprot.readBinary();
13083 } else {
13084 TProtocolUtil.skip(iprot, field.type);
13085 }
13086 break;
13087 }
13088 iprot.readFieldEnd();
13089 }
13090 }
13091 iprot.readStructEnd();
13092
13093
13094 validate();
13095 }
13096
13097 public void write(TProtocol oprot) throws TException {
13098 validate();
13099
13100 oprot.writeStructBegin(STRUCT_DESC);
13101 if (this.tableName != null) {
13102 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
13103 oprot.writeBinary(this.tableName);
13104 oprot.writeFieldEnd();
13105 }
13106 if (this.row != null) {
13107 oprot.writeFieldBegin(ROW_FIELD_DESC);
13108 oprot.writeBinary(this.row);
13109 oprot.writeFieldEnd();
13110 }
13111 oprot.writeFieldStop();
13112 oprot.writeStructEnd();
13113 }
13114
13115 @Override
13116 public String toString() {
13117 StringBuilder sb = new StringBuilder("getRow_args(");
13118 boolean first = true;
13119
13120 sb.append("tableName:");
13121 if (this.tableName == null) {
13122 sb.append("null");
13123 } else {
13124 sb.append(this.tableName);
13125 }
13126 first = false;
13127 if (!first) sb.append(", ");
13128 sb.append("row:");
13129 if (this.row == null) {
13130 sb.append("null");
13131 } else {
13132 sb.append(this.row);
13133 }
13134 first = false;
13135 sb.append(")");
13136 return sb.toString();
13137 }
13138
13139 public void validate() throws TException {
13140
13141 }
13142
13143 }
13144
13145 public static class getRow_result implements TBase<getRow_result._Fields>, java.io.Serializable, Cloneable {
13146 private static final TStruct STRUCT_DESC = new TStruct("getRow_result");
13147
13148 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
13149 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
13150
13151 public List<TRowResult> success;
13152 public IOError io;
13153
13154
13155 public enum _Fields implements TFieldIdEnum {
13156 SUCCESS((short)0, "success"),
13157 IO((short)1, "io");
13158
13159 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
13160 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13161
13162 static {
13163 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13164 byId.put((int)field._thriftId, field);
13165 byName.put(field.getFieldName(), field);
13166 }
13167 }
13168
13169
13170
13171
13172 public static _Fields findByThriftId(int fieldId) {
13173 return byId.get(fieldId);
13174 }
13175
13176
13177
13178
13179
13180 public static _Fields findByThriftIdOrThrow(int fieldId) {
13181 _Fields fields = findByThriftId(fieldId);
13182 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13183 return fields;
13184 }
13185
13186
13187
13188
13189 public static _Fields findByName(String name) {
13190 return byName.get(name);
13191 }
13192
13193 private final short _thriftId;
13194 private final String _fieldName;
13195
13196 _Fields(short thriftId, String fieldName) {
13197 _thriftId = thriftId;
13198 _fieldName = fieldName;
13199 }
13200
13201 public short getThriftFieldId() {
13202 return _thriftId;
13203 }
13204
13205 public String getFieldName() {
13206 return _fieldName;
13207 }
13208 }
13209
13210
13211
13212 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
13213 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
13214 new ListMetaData(TType.LIST,
13215 new StructMetaData(TType.STRUCT, TRowResult.class))));
13216 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
13217 new FieldValueMetaData(TType.STRUCT)));
13218 }});
13219
13220 static {
13221 FieldMetaData.addStructMetaDataMap(getRow_result.class, metaDataMap);
13222 }
13223
13224 public getRow_result() {
13225 }
13226
13227 public getRow_result(
13228 List<TRowResult> success,
13229 IOError io)
13230 {
13231 this();
13232 this.success = success;
13233 this.io = io;
13234 }
13235
13236
13237
13238
13239 public getRow_result(getRow_result other) {
13240 if (other.isSetSuccess()) {
13241 List<TRowResult> __this__success = new ArrayList<TRowResult>();
13242 for (TRowResult other_element : other.success) {
13243 __this__success.add(new TRowResult(other_element));
13244 }
13245 this.success = __this__success;
13246 }
13247 if (other.isSetIo()) {
13248 this.io = new IOError(other.io);
13249 }
13250 }
13251
13252 public getRow_result deepCopy() {
13253 return new getRow_result(this);
13254 }
13255
13256 @Deprecated
13257 public getRow_result clone() {
13258 return new getRow_result(this);
13259 }
13260
13261 public int getSuccessSize() {
13262 return (this.success == null) ? 0 : this.success.size();
13263 }
13264
13265 public java.util.Iterator<TRowResult> getSuccessIterator() {
13266 return (this.success == null) ? null : this.success.iterator();
13267 }
13268
13269 public void addToSuccess(TRowResult elem) {
13270 if (this.success == null) {
13271 this.success = new ArrayList<TRowResult>();
13272 }
13273 this.success.add(elem);
13274 }
13275
13276 public List<TRowResult> getSuccess() {
13277 return this.success;
13278 }
13279
13280 public getRow_result setSuccess(List<TRowResult> success) {
13281 this.success = success;
13282 return this;
13283 }
13284
13285 public void unsetSuccess() {
13286 this.success = null;
13287 }
13288
13289
13290 public boolean isSetSuccess() {
13291 return this.success != null;
13292 }
13293
13294 public void setSuccessIsSet(boolean value) {
13295 if (!value) {
13296 this.success = null;
13297 }
13298 }
13299
13300 public IOError getIo() {
13301 return this.io;
13302 }
13303
13304 public getRow_result setIo(IOError io) {
13305 this.io = io;
13306 return this;
13307 }
13308
13309 public void unsetIo() {
13310 this.io = null;
13311 }
13312
13313
13314 public boolean isSetIo() {
13315 return this.io != null;
13316 }
13317
13318 public void setIoIsSet(boolean value) {
13319 if (!value) {
13320 this.io = null;
13321 }
13322 }
13323
13324 public void setFieldValue(_Fields field, Object value) {
13325 switch (field) {
13326 case SUCCESS:
13327 if (value == null) {
13328 unsetSuccess();
13329 } else {
13330 setSuccess((List<TRowResult>)value);
13331 }
13332 break;
13333
13334 case IO:
13335 if (value == null) {
13336 unsetIo();
13337 } else {
13338 setIo((IOError)value);
13339 }
13340 break;
13341
13342 }
13343 }
13344
13345 public void setFieldValue(int fieldID, Object value) {
13346 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13347 }
13348
13349 public Object getFieldValue(_Fields field) {
13350 switch (field) {
13351 case SUCCESS:
13352 return getSuccess();
13353
13354 case IO:
13355 return getIo();
13356
13357 }
13358 throw new IllegalStateException();
13359 }
13360
13361 public Object getFieldValue(int fieldId) {
13362 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13363 }
13364
13365
13366 public boolean isSet(_Fields field) {
13367 switch (field) {
13368 case SUCCESS:
13369 return isSetSuccess();
13370 case IO:
13371 return isSetIo();
13372 }
13373 throw new IllegalStateException();
13374 }
13375
13376 public boolean isSet(int fieldID) {
13377 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13378 }
13379
13380 @Override
13381 public boolean equals(Object that) {
13382 if (that == null)
13383 return false;
13384 if (that instanceof getRow_result)
13385 return this.equals((getRow_result)that);
13386 return false;
13387 }
13388
13389 public boolean equals(getRow_result that) {
13390 if (that == null)
13391 return false;
13392
13393 boolean this_present_success = true && this.isSetSuccess();
13394 boolean that_present_success = true && that.isSetSuccess();
13395 if (this_present_success || that_present_success) {
13396 if (!(this_present_success && that_present_success))
13397 return false;
13398 if (!this.success.equals(that.success))
13399 return false;
13400 }
13401
13402 boolean this_present_io = true && this.isSetIo();
13403 boolean that_present_io = true && that.isSetIo();
13404 if (this_present_io || that_present_io) {
13405 if (!(this_present_io && that_present_io))
13406 return false;
13407 if (!this.io.equals(that.io))
13408 return false;
13409 }
13410
13411 return true;
13412 }
13413
13414 @Override
13415 public int hashCode() {
13416 HashCodeBuilder builder = new HashCodeBuilder();
13417
13418 boolean present_success = true && (isSetSuccess());
13419 builder.append(present_success);
13420 if (present_success)
13421 builder.append(success);
13422
13423 boolean present_io = true && (isSetIo());
13424 builder.append(present_io);
13425 if (present_io)
13426 builder.append(io);
13427
13428 return builder.toHashCode();
13429 }
13430
13431 public void read(TProtocol iprot) throws TException {
13432 TField field;
13433 iprot.readStructBegin();
13434 while (true)
13435 {
13436 field = iprot.readFieldBegin();
13437 if (field.type == TType.STOP) {
13438 break;
13439 }
13440 _Fields fieldId = _Fields.findByThriftId(field.id);
13441 if (fieldId == null) {
13442 TProtocolUtil.skip(iprot, field.type);
13443 } else {
13444 switch (fieldId) {
13445 case SUCCESS:
13446 if (field.type == TType.LIST) {
13447 {
13448 TList _list38 = iprot.readListBegin();
13449 this.success = new ArrayList<TRowResult>(_list38.size);
13450 for (int _i39 = 0; _i39 < _list38.size; ++_i39)
13451 {
13452 TRowResult _elem40;
13453 _elem40 = new TRowResult();
13454 _elem40.read(iprot);
13455 this.success.add(_elem40);
13456 }
13457 iprot.readListEnd();
13458 }
13459 } else {
13460 TProtocolUtil.skip(iprot, field.type);
13461 }
13462 break;
13463 case IO:
13464 if (field.type == TType.STRUCT) {
13465 this.io = new IOError();
13466 this.io.read(iprot);
13467 } else {
13468 TProtocolUtil.skip(iprot, field.type);
13469 }
13470 break;
13471 }
13472 iprot.readFieldEnd();
13473 }
13474 }
13475 iprot.readStructEnd();
13476
13477
13478 validate();
13479 }
13480
13481 public void write(TProtocol oprot) throws TException {
13482 oprot.writeStructBegin(STRUCT_DESC);
13483
13484 if (this.isSetSuccess()) {
13485 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13486 {
13487 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
13488 for (TRowResult _iter41 : this.success)
13489 {
13490 _iter41.write(oprot);
13491 }
13492 oprot.writeListEnd();
13493 }
13494 oprot.writeFieldEnd();
13495 } else if (this.isSetIo()) {
13496 oprot.writeFieldBegin(IO_FIELD_DESC);
13497 this.io.write(oprot);
13498 oprot.writeFieldEnd();
13499 }
13500 oprot.writeFieldStop();
13501 oprot.writeStructEnd();
13502 }
13503
13504 @Override
13505 public String toString() {
13506 StringBuilder sb = new StringBuilder("getRow_result(");
13507 boolean first = true;
13508
13509 sb.append("success:");
13510 if (this.success == null) {
13511 sb.append("null");
13512 } else {
13513 sb.append(this.success);
13514 }
13515 first = false;
13516 if (!first) sb.append(", ");
13517 sb.append("io:");
13518 if (this.io == null) {
13519 sb.append("null");
13520 } else {
13521 sb.append(this.io);
13522 }
13523 first = false;
13524 sb.append(")");
13525 return sb.toString();
13526 }
13527
13528 public void validate() throws TException {
13529
13530 }
13531
13532 }
13533
13534 public static class getRowWithColumns_args implements TBase<getRowWithColumns_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumns_args> {
13535 private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_args");
13536
13537 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
13538 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
13539 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
13540
13541
13542
13543
13544 public byte[] tableName;
13545
13546
13547
13548 public byte[] row;
13549
13550
13551
13552 public List<byte[]> columns;
13553
13554
13555 public enum _Fields implements TFieldIdEnum {
13556
13557
13558
13559 TABLE_NAME((short)1, "tableName"),
13560
13561
13562
13563 ROW((short)2, "row"),
13564
13565
13566
13567 COLUMNS((short)3, "columns");
13568
13569 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
13570 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13571
13572 static {
13573 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13574 byId.put((int)field._thriftId, field);
13575 byName.put(field.getFieldName(), field);
13576 }
13577 }
13578
13579
13580
13581
13582 public static _Fields findByThriftId(int fieldId) {
13583 return byId.get(fieldId);
13584 }
13585
13586
13587
13588
13589
13590 public static _Fields findByThriftIdOrThrow(int fieldId) {
13591 _Fields fields = findByThriftId(fieldId);
13592 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13593 return fields;
13594 }
13595
13596
13597
13598
13599 public static _Fields findByName(String name) {
13600 return byName.get(name);
13601 }
13602
13603 private final short _thriftId;
13604 private final String _fieldName;
13605
13606 _Fields(short thriftId, String fieldName) {
13607 _thriftId = thriftId;
13608 _fieldName = fieldName;
13609 }
13610
13611 public short getThriftFieldId() {
13612 return _thriftId;
13613 }
13614
13615 public String getFieldName() {
13616 return _fieldName;
13617 }
13618 }
13619
13620
13621
13622 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
13623 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
13624 new FieldValueMetaData(TType.STRING)));
13625 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
13626 new FieldValueMetaData(TType.STRING)));
13627 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
13628 new ListMetaData(TType.LIST,
13629 new FieldValueMetaData(TType.STRING))));
13630 }});
13631
13632 static {
13633 FieldMetaData.addStructMetaDataMap(getRowWithColumns_args.class, metaDataMap);
13634 }
13635
13636 public getRowWithColumns_args() {
13637 }
13638
13639 public getRowWithColumns_args(
13640 byte[] tableName,
13641 byte[] row,
13642 List<byte[]> columns)
13643 {
13644 this();
13645 this.tableName = tableName;
13646 this.row = row;
13647 this.columns = columns;
13648 }
13649
13650
13651
13652
13653 public getRowWithColumns_args(getRowWithColumns_args other) {
13654 if (other.isSetTableName()) {
13655 this.tableName = other.tableName;
13656 }
13657 if (other.isSetRow()) {
13658 this.row = other.row;
13659 }
13660 if (other.isSetColumns()) {
13661 List<byte[]> __this__columns = new ArrayList<byte[]>();
13662 for (byte[] other_element : other.columns) {
13663 __this__columns.add(other_element);
13664 }
13665 this.columns = __this__columns;
13666 }
13667 }
13668
13669 public getRowWithColumns_args deepCopy() {
13670 return new getRowWithColumns_args(this);
13671 }
13672
13673 @Deprecated
13674 public getRowWithColumns_args clone() {
13675 return new getRowWithColumns_args(this);
13676 }
13677
13678
13679
13680
13681 public byte[] getTableName() {
13682 return this.tableName;
13683 }
13684
13685
13686
13687
13688 public getRowWithColumns_args setTableName(byte[] tableName) {
13689 this.tableName = tableName;
13690 return this;
13691 }
13692
13693 public void unsetTableName() {
13694 this.tableName = null;
13695 }
13696
13697
13698 public boolean isSetTableName() {
13699 return this.tableName != null;
13700 }
13701
13702 public void setTableNameIsSet(boolean value) {
13703 if (!value) {
13704 this.tableName = null;
13705 }
13706 }
13707
13708
13709
13710
13711 public byte[] getRow() {
13712 return this.row;
13713 }
13714
13715
13716
13717
13718 public getRowWithColumns_args setRow(byte[] row) {
13719 this.row = row;
13720 return this;
13721 }
13722
13723 public void unsetRow() {
13724 this.row = null;
13725 }
13726
13727
13728 public boolean isSetRow() {
13729 return this.row != null;
13730 }
13731
13732 public void setRowIsSet(boolean value) {
13733 if (!value) {
13734 this.row = null;
13735 }
13736 }
13737
13738 public int getColumnsSize() {
13739 return (this.columns == null) ? 0 : this.columns.size();
13740 }
13741
13742 public java.util.Iterator<byte[]> getColumnsIterator() {
13743 return (this.columns == null) ? null : this.columns.iterator();
13744 }
13745
13746 public void addToColumns(byte[] elem) {
13747 if (this.columns == null) {
13748 this.columns = new ArrayList<byte[]>();
13749 }
13750 this.columns.add(elem);
13751 }
13752
13753
13754
13755
13756 public List<byte[]> getColumns() {
13757 return this.columns;
13758 }
13759
13760
13761
13762
13763 public getRowWithColumns_args setColumns(List<byte[]> columns) {
13764 this.columns = columns;
13765 return this;
13766 }
13767
13768 public void unsetColumns() {
13769 this.columns = null;
13770 }
13771
13772
13773 public boolean isSetColumns() {
13774 return this.columns != null;
13775 }
13776
13777 public void setColumnsIsSet(boolean value) {
13778 if (!value) {
13779 this.columns = null;
13780 }
13781 }
13782
13783 public void setFieldValue(_Fields field, Object value) {
13784 switch (field) {
13785 case TABLE_NAME:
13786 if (value == null) {
13787 unsetTableName();
13788 } else {
13789 setTableName((byte[])value);
13790 }
13791 break;
13792
13793 case ROW:
13794 if (value == null) {
13795 unsetRow();
13796 } else {
13797 setRow((byte[])value);
13798 }
13799 break;
13800
13801 case COLUMNS:
13802 if (value == null) {
13803 unsetColumns();
13804 } else {
13805 setColumns((List<byte[]>)value);
13806 }
13807 break;
13808
13809 }
13810 }
13811
13812 public void setFieldValue(int fieldID, Object value) {
13813 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13814 }
13815
13816 public Object getFieldValue(_Fields field) {
13817 switch (field) {
13818 case TABLE_NAME:
13819 return getTableName();
13820
13821 case ROW:
13822 return getRow();
13823
13824 case COLUMNS:
13825 return getColumns();
13826
13827 }
13828 throw new IllegalStateException();
13829 }
13830
13831 public Object getFieldValue(int fieldId) {
13832 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13833 }
13834
13835
13836 public boolean isSet(_Fields field) {
13837 switch (field) {
13838 case TABLE_NAME:
13839 return isSetTableName();
13840 case ROW:
13841 return isSetRow();
13842 case COLUMNS:
13843 return isSetColumns();
13844 }
13845 throw new IllegalStateException();
13846 }
13847
13848 public boolean isSet(int fieldID) {
13849 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13850 }
13851
13852 @Override
13853 public boolean equals(Object that) {
13854 if (that == null)
13855 return false;
13856 if (that instanceof getRowWithColumns_args)
13857 return this.equals((getRowWithColumns_args)that);
13858 return false;
13859 }
13860
13861 public boolean equals(getRowWithColumns_args that) {
13862 if (that == null)
13863 return false;
13864
13865 boolean this_present_tableName = true && this.isSetTableName();
13866 boolean that_present_tableName = true && that.isSetTableName();
13867 if (this_present_tableName || that_present_tableName) {
13868 if (!(this_present_tableName && that_present_tableName))
13869 return false;
13870 if (!java.util.Arrays.equals(this.tableName, that.tableName))
13871 return false;
13872 }
13873
13874 boolean this_present_row = true && this.isSetRow();
13875 boolean that_present_row = true && that.isSetRow();
13876 if (this_present_row || that_present_row) {
13877 if (!(this_present_row && that_present_row))
13878 return false;
13879 if (!java.util.Arrays.equals(this.row, that.row))
13880 return false;
13881 }
13882
13883 boolean this_present_columns = true && this.isSetColumns();
13884 boolean that_present_columns = true && that.isSetColumns();
13885 if (this_present_columns || that_present_columns) {
13886 if (!(this_present_columns && that_present_columns))
13887 return false;
13888 if (!this.columns.equals(that.columns))
13889 return false;
13890 }
13891
13892 return true;
13893 }
13894
13895 @Override
13896 public int hashCode() {
13897 HashCodeBuilder builder = new HashCodeBuilder();
13898
13899 boolean present_tableName = true && (isSetTableName());
13900 builder.append(present_tableName);
13901 if (present_tableName)
13902 builder.append(tableName);
13903
13904 boolean present_row = true && (isSetRow());
13905 builder.append(present_row);
13906 if (present_row)
13907 builder.append(row);
13908
13909 boolean present_columns = true && (isSetColumns());
13910 builder.append(present_columns);
13911 if (present_columns)
13912 builder.append(columns);
13913
13914 return builder.toHashCode();
13915 }
13916
13917 public int compareTo(getRowWithColumns_args other) {
13918 if (!getClass().equals(other.getClass())) {
13919 return getClass().getName().compareTo(other.getClass().getName());
13920 }
13921
13922 int lastComparison = 0;
13923 getRowWithColumns_args typedOther = (getRowWithColumns_args)other;
13924
13925 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
13926 if (lastComparison != 0) {
13927 return lastComparison;
13928 }
13929 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
13930 if (lastComparison != 0) {
13931 return lastComparison;
13932 }
13933 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
13934 if (lastComparison != 0) {
13935 return lastComparison;
13936 }
13937 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
13938 if (lastComparison != 0) {
13939 return lastComparison;
13940 }
13941 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
13942 if (lastComparison != 0) {
13943 return lastComparison;
13944 }
13945 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
13946 if (lastComparison != 0) {
13947 return lastComparison;
13948 }
13949 return 0;
13950 }
13951
13952 public void read(TProtocol iprot) throws TException {
13953 TField field;
13954 iprot.readStructBegin();
13955 while (true)
13956 {
13957 field = iprot.readFieldBegin();
13958 if (field.type == TType.STOP) {
13959 break;
13960 }
13961 _Fields fieldId = _Fields.findByThriftId(field.id);
13962 if (fieldId == null) {
13963 TProtocolUtil.skip(iprot, field.type);
13964 } else {
13965 switch (fieldId) {
13966 case TABLE_NAME:
13967 if (field.type == TType.STRING) {
13968 this.tableName = iprot.readBinary();
13969 } else {
13970 TProtocolUtil.skip(iprot, field.type);
13971 }
13972 break;
13973 case ROW:
13974 if (field.type == TType.STRING) {
13975 this.row = iprot.readBinary();
13976 } else {
13977 TProtocolUtil.skip(iprot, field.type);
13978 }
13979 break;
13980 case COLUMNS:
13981 if (field.type == TType.LIST) {
13982 {
13983 TList _list42 = iprot.readListBegin();
13984 this.columns = new ArrayList<byte[]>(_list42.size);
13985 for (int _i43 = 0; _i43 < _list42.size; ++_i43)
13986 {
13987 byte[] _elem44;
13988 _elem44 = iprot.readBinary();
13989 this.columns.add(_elem44);
13990 }
13991 iprot.readListEnd();
13992 }
13993 } else {
13994 TProtocolUtil.skip(iprot, field.type);
13995 }
13996 break;
13997 }
13998 iprot.readFieldEnd();
13999 }
14000 }
14001 iprot.readStructEnd();
14002
14003
14004 validate();
14005 }
14006
14007 public void write(TProtocol oprot) throws TException {
14008 validate();
14009
14010 oprot.writeStructBegin(STRUCT_DESC);
14011 if (this.tableName != null) {
14012 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
14013 oprot.writeBinary(this.tableName);
14014 oprot.writeFieldEnd();
14015 }
14016 if (this.row != null) {
14017 oprot.writeFieldBegin(ROW_FIELD_DESC);
14018 oprot.writeBinary(this.row);
14019 oprot.writeFieldEnd();
14020 }
14021 if (this.columns != null) {
14022 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
14023 {
14024 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
14025 for (byte[] _iter45 : this.columns)
14026 {
14027 oprot.writeBinary(_iter45);
14028 }
14029 oprot.writeListEnd();
14030 }
14031 oprot.writeFieldEnd();
14032 }
14033 oprot.writeFieldStop();
14034 oprot.writeStructEnd();
14035 }
14036
14037 @Override
14038 public String toString() {
14039 StringBuilder sb = new StringBuilder("getRowWithColumns_args(");
14040 boolean first = true;
14041
14042 sb.append("tableName:");
14043 if (this.tableName == null) {
14044 sb.append("null");
14045 } else {
14046 sb.append(this.tableName);
14047 }
14048 first = false;
14049 if (!first) sb.append(", ");
14050 sb.append("row:");
14051 if (this.row == null) {
14052 sb.append("null");
14053 } else {
14054 sb.append(this.row);
14055 }
14056 first = false;
14057 if (!first) sb.append(", ");
14058 sb.append("columns:");
14059 if (this.columns == null) {
14060 sb.append("null");
14061 } else {
14062 sb.append(this.columns);
14063 }
14064 first = false;
14065 sb.append(")");
14066 return sb.toString();
14067 }
14068
14069 public void validate() throws TException {
14070
14071 }
14072
14073 }
14074
14075 public static class getRowWithColumns_result implements TBase<getRowWithColumns_result._Fields>, java.io.Serializable, Cloneable {
14076 private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_result");
14077
14078 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
14079 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
14080
14081 public List<TRowResult> success;
14082 public IOError io;
14083
14084
14085 public enum _Fields implements TFieldIdEnum {
14086 SUCCESS((short)0, "success"),
14087 IO((short)1, "io");
14088
14089 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14090 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14091
14092 static {
14093 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14094 byId.put((int)field._thriftId, field);
14095 byName.put(field.getFieldName(), field);
14096 }
14097 }
14098
14099
14100
14101
14102 public static _Fields findByThriftId(int fieldId) {
14103 return byId.get(fieldId);
14104 }
14105
14106
14107
14108
14109
14110 public static _Fields findByThriftIdOrThrow(int fieldId) {
14111 _Fields fields = findByThriftId(fieldId);
14112 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14113 return fields;
14114 }
14115
14116
14117
14118
14119 public static _Fields findByName(String name) {
14120 return byName.get(name);
14121 }
14122
14123 private final short _thriftId;
14124 private final String _fieldName;
14125
14126 _Fields(short thriftId, String fieldName) {
14127 _thriftId = thriftId;
14128 _fieldName = fieldName;
14129 }
14130
14131 public short getThriftFieldId() {
14132 return _thriftId;
14133 }
14134
14135 public String getFieldName() {
14136 return _fieldName;
14137 }
14138 }
14139
14140
14141
14142 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
14143 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
14144 new ListMetaData(TType.LIST,
14145 new StructMetaData(TType.STRUCT, TRowResult.class))));
14146 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
14147 new FieldValueMetaData(TType.STRUCT)));
14148 }});
14149
14150 static {
14151 FieldMetaData.addStructMetaDataMap(getRowWithColumns_result.class, metaDataMap);
14152 }
14153
14154 public getRowWithColumns_result() {
14155 }
14156
14157 public getRowWithColumns_result(
14158 List<TRowResult> success,
14159 IOError io)
14160 {
14161 this();
14162 this.success = success;
14163 this.io = io;
14164 }
14165
14166
14167
14168
14169 public getRowWithColumns_result(getRowWithColumns_result other) {
14170 if (other.isSetSuccess()) {
14171 List<TRowResult> __this__success = new ArrayList<TRowResult>();
14172 for (TRowResult other_element : other.success) {
14173 __this__success.add(new TRowResult(other_element));
14174 }
14175 this.success = __this__success;
14176 }
14177 if (other.isSetIo()) {
14178 this.io = new IOError(other.io);
14179 }
14180 }
14181
14182 public getRowWithColumns_result deepCopy() {
14183 return new getRowWithColumns_result(this);
14184 }
14185
14186 @Deprecated
14187 public getRowWithColumns_result clone() {
14188 return new getRowWithColumns_result(this);
14189 }
14190
14191 public int getSuccessSize() {
14192 return (this.success == null) ? 0 : this.success.size();
14193 }
14194
14195 public java.util.Iterator<TRowResult> getSuccessIterator() {
14196 return (this.success == null) ? null : this.success.iterator();
14197 }
14198
14199 public void addToSuccess(TRowResult elem) {
14200 if (this.success == null) {
14201 this.success = new ArrayList<TRowResult>();
14202 }
14203 this.success.add(elem);
14204 }
14205
14206 public List<TRowResult> getSuccess() {
14207 return this.success;
14208 }
14209
14210 public getRowWithColumns_result setSuccess(List<TRowResult> success) {
14211 this.success = success;
14212 return this;
14213 }
14214
14215 public void unsetSuccess() {
14216 this.success = null;
14217 }
14218
14219
14220 public boolean isSetSuccess() {
14221 return this.success != null;
14222 }
14223
14224 public void setSuccessIsSet(boolean value) {
14225 if (!value) {
14226 this.success = null;
14227 }
14228 }
14229
14230 public IOError getIo() {
14231 return this.io;
14232 }
14233
14234 public getRowWithColumns_result setIo(IOError io) {
14235 this.io = io;
14236 return this;
14237 }
14238
14239 public void unsetIo() {
14240 this.io = null;
14241 }
14242
14243
14244 public boolean isSetIo() {
14245 return this.io != null;
14246 }
14247
14248 public void setIoIsSet(boolean value) {
14249 if (!value) {
14250 this.io = null;
14251 }
14252 }
14253
14254 public void setFieldValue(_Fields field, Object value) {
14255 switch (field) {
14256 case SUCCESS:
14257 if (value == null) {
14258 unsetSuccess();
14259 } else {
14260 setSuccess((List<TRowResult>)value);
14261 }
14262 break;
14263
14264 case IO:
14265 if (value == null) {
14266 unsetIo();
14267 } else {
14268 setIo((IOError)value);
14269 }
14270 break;
14271
14272 }
14273 }
14274
14275 public void setFieldValue(int fieldID, Object value) {
14276 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
14277 }
14278
14279 public Object getFieldValue(_Fields field) {
14280 switch (field) {
14281 case SUCCESS:
14282 return getSuccess();
14283
14284 case IO:
14285 return getIo();
14286
14287 }
14288 throw new IllegalStateException();
14289 }
14290
14291 public Object getFieldValue(int fieldId) {
14292 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
14293 }
14294
14295
14296 public boolean isSet(_Fields field) {
14297 switch (field) {
14298 case SUCCESS:
14299 return isSetSuccess();
14300 case IO:
14301 return isSetIo();
14302 }
14303 throw new IllegalStateException();
14304 }
14305
14306 public boolean isSet(int fieldID) {
14307 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
14308 }
14309
14310 @Override
14311 public boolean equals(Object that) {
14312 if (that == null)
14313 return false;
14314 if (that instanceof getRowWithColumns_result)
14315 return this.equals((getRowWithColumns_result)that);
14316 return false;
14317 }
14318
14319 public boolean equals(getRowWithColumns_result that) {
14320 if (that == null)
14321 return false;
14322
14323 boolean this_present_success = true && this.isSetSuccess();
14324 boolean that_present_success = true && that.isSetSuccess();
14325 if (this_present_success || that_present_success) {
14326 if (!(this_present_success && that_present_success))
14327 return false;
14328 if (!this.success.equals(that.success))
14329 return false;
14330 }
14331
14332 boolean this_present_io = true && this.isSetIo();
14333 boolean that_present_io = true && that.isSetIo();
14334 if (this_present_io || that_present_io) {
14335 if (!(this_present_io && that_present_io))
14336 return false;
14337 if (!this.io.equals(that.io))
14338 return false;
14339 }
14340
14341 return true;
14342 }
14343
14344 @Override
14345 public int hashCode() {
14346 HashCodeBuilder builder = new HashCodeBuilder();
14347
14348 boolean present_success = true && (isSetSuccess());
14349 builder.append(present_success);
14350 if (present_success)
14351 builder.append(success);
14352
14353 boolean present_io = true && (isSetIo());
14354 builder.append(present_io);
14355 if (present_io)
14356 builder.append(io);
14357
14358 return builder.toHashCode();
14359 }
14360
14361 public void read(TProtocol iprot) throws TException {
14362 TField field;
14363 iprot.readStructBegin();
14364 while (true)
14365 {
14366 field = iprot.readFieldBegin();
14367 if (field.type == TType.STOP) {
14368 break;
14369 }
14370 _Fields fieldId = _Fields.findByThriftId(field.id);
14371 if (fieldId == null) {
14372 TProtocolUtil.skip(iprot, field.type);
14373 } else {
14374 switch (fieldId) {
14375 case SUCCESS:
14376 if (field.type == TType.LIST) {
14377 {
14378 TList _list46 = iprot.readListBegin();
14379 this.success = new ArrayList<TRowResult>(_list46.size);
14380 for (int _i47 = 0; _i47 < _list46.size; ++_i47)
14381 {
14382 TRowResult _elem48;
14383 _elem48 = new TRowResult();
14384 _elem48.read(iprot);
14385 this.success.add(_elem48);
14386 }
14387 iprot.readListEnd();
14388 }
14389 } else {
14390 TProtocolUtil.skip(iprot, field.type);
14391 }
14392 break;
14393 case IO:
14394 if (field.type == TType.STRUCT) {
14395 this.io = new IOError();
14396 this.io.read(iprot);
14397 } else {
14398 TProtocolUtil.skip(iprot, field.type);
14399 }
14400 break;
14401 }
14402 iprot.readFieldEnd();
14403 }
14404 }
14405 iprot.readStructEnd();
14406
14407
14408 validate();
14409 }
14410
14411 public void write(TProtocol oprot) throws TException {
14412 oprot.writeStructBegin(STRUCT_DESC);
14413
14414 if (this.isSetSuccess()) {
14415 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
14416 {
14417 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
14418 for (TRowResult _iter49 : this.success)
14419 {
14420 _iter49.write(oprot);
14421 }
14422 oprot.writeListEnd();
14423 }
14424 oprot.writeFieldEnd();
14425 } else if (this.isSetIo()) {
14426 oprot.writeFieldBegin(IO_FIELD_DESC);
14427 this.io.write(oprot);
14428 oprot.writeFieldEnd();
14429 }
14430 oprot.writeFieldStop();
14431 oprot.writeStructEnd();
14432 }
14433
14434 @Override
14435 public String toString() {
14436 StringBuilder sb = new StringBuilder("getRowWithColumns_result(");
14437 boolean first = true;
14438
14439 sb.append("success:");
14440 if (this.success == null) {
14441 sb.append("null");
14442 } else {
14443 sb.append(this.success);
14444 }
14445 first = false;
14446 if (!first) sb.append(", ");
14447 sb.append("io:");
14448 if (this.io == null) {
14449 sb.append("null");
14450 } else {
14451 sb.append(this.io);
14452 }
14453 first = false;
14454 sb.append(")");
14455 return sb.toString();
14456 }
14457
14458 public void validate() throws TException {
14459
14460 }
14461
14462 }
14463
14464 public static class getRowTs_args implements TBase<getRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowTs_args> {
14465 private static final TStruct STRUCT_DESC = new TStruct("getRowTs_args");
14466
14467 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
14468 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
14469 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
14470
14471
14472
14473
14474 public byte[] tableName;
14475
14476
14477
14478 public byte[] row;
14479
14480
14481
14482 public long timestamp;
14483
14484
14485 public enum _Fields implements TFieldIdEnum {
14486
14487
14488
14489 TABLE_NAME((short)1, "tableName"),
14490
14491
14492
14493 ROW((short)2, "row"),
14494
14495
14496
14497 TIMESTAMP((short)3, "timestamp");
14498
14499 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14500 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14501
14502 static {
14503 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14504 byId.put((int)field._thriftId, field);
14505 byName.put(field.getFieldName(), field);
14506 }
14507 }
14508
14509
14510
14511
14512 public static _Fields findByThriftId(int fieldId) {
14513 return byId.get(fieldId);
14514 }
14515
14516
14517
14518
14519
14520 public static _Fields findByThriftIdOrThrow(int fieldId) {
14521 _Fields fields = findByThriftId(fieldId);
14522 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14523 return fields;
14524 }
14525
14526
14527
14528
14529 public static _Fields findByName(String name) {
14530 return byName.get(name);
14531 }
14532
14533 private final short _thriftId;
14534 private final String _fieldName;
14535
14536 _Fields(short thriftId, String fieldName) {
14537 _thriftId = thriftId;
14538 _fieldName = fieldName;
14539 }
14540
14541 public short getThriftFieldId() {
14542 return _thriftId;
14543 }
14544
14545 public String getFieldName() {
14546 return _fieldName;
14547 }
14548 }
14549
14550
14551 private static final int __TIMESTAMP_ISSET_ID = 0;
14552 private BitSet __isset_bit_vector = new BitSet(1);
14553
14554 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
14555 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
14556 new FieldValueMetaData(TType.STRING)));
14557 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
14558 new FieldValueMetaData(TType.STRING)));
14559 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
14560 new FieldValueMetaData(TType.I64)));
14561 }});
14562
14563 static {
14564 FieldMetaData.addStructMetaDataMap(getRowTs_args.class, metaDataMap);
14565 }
14566
14567 public getRowTs_args() {
14568 }
14569
14570 public getRowTs_args(
14571 byte[] tableName,
14572 byte[] row,
14573 long timestamp)
14574 {
14575 this();
14576 this.tableName = tableName;
14577 this.row = row;
14578 this.timestamp = timestamp;
14579 setTimestampIsSet(true);
14580 }
14581
14582
14583
14584
14585 public getRowTs_args(getRowTs_args other) {
14586 __isset_bit_vector.clear();
14587 __isset_bit_vector.or(other.__isset_bit_vector);
14588 if (other.isSetTableName()) {
14589 this.tableName = other.tableName;
14590 }
14591 if (other.isSetRow()) {
14592 this.row = other.row;
14593 }
14594 this.timestamp = other.timestamp;
14595 }
14596
14597 public getRowTs_args deepCopy() {
14598 return new getRowTs_args(this);
14599 }
14600
14601 @Deprecated
14602 public getRowTs_args clone() {
14603 return new getRowTs_args(this);
14604 }
14605
14606
14607
14608
14609 public byte[] getTableName() {
14610 return this.tableName;
14611 }
14612
14613
14614
14615
14616 public getRowTs_args setTableName(byte[] tableName) {
14617 this.tableName = tableName;
14618 return this;
14619 }
14620
14621 public void unsetTableName() {
14622 this.tableName = null;
14623 }
14624
14625
14626 public boolean isSetTableName() {
14627 return this.tableName != null;
14628 }
14629
14630 public void setTableNameIsSet(boolean value) {
14631 if (!value) {
14632 this.tableName = null;
14633 }
14634 }
14635
14636
14637
14638
14639 public byte[] getRow() {
14640 return this.row;
14641 }
14642
14643
14644
14645
14646 public getRowTs_args setRow(byte[] row) {
14647 this.row = row;
14648 return this;
14649 }
14650
14651 public void unsetRow() {
14652 this.row = null;
14653 }
14654
14655
14656 public boolean isSetRow() {
14657 return this.row != null;
14658 }
14659
14660 public void setRowIsSet(boolean value) {
14661 if (!value) {
14662 this.row = null;
14663 }
14664 }
14665
14666
14667
14668
14669 public long getTimestamp() {
14670 return this.timestamp;
14671 }
14672
14673
14674
14675
14676 public getRowTs_args setTimestamp(long timestamp) {
14677 this.timestamp = timestamp;
14678 setTimestampIsSet(true);
14679 return this;
14680 }
14681
14682 public void unsetTimestamp() {
14683 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
14684 }
14685
14686
14687 public boolean isSetTimestamp() {
14688 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
14689 }
14690
14691 public void setTimestampIsSet(boolean value) {
14692 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
14693 }
14694
14695 public void setFieldValue(_Fields field, Object value) {
14696 switch (field) {
14697 case TABLE_NAME:
14698 if (value == null) {
14699 unsetTableName();
14700 } else {
14701 setTableName((byte[])value);
14702 }
14703 break;
14704
14705 case ROW:
14706 if (value == null) {
14707 unsetRow();
14708 } else {
14709 setRow((byte[])value);
14710 }
14711 break;
14712
14713 case TIMESTAMP:
14714 if (value == null) {
14715 unsetTimestamp();
14716 } else {
14717 setTimestamp((Long)value);
14718 }
14719 break;
14720
14721 }
14722 }
14723
14724 public void setFieldValue(int fieldID, Object value) {
14725 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
14726 }
14727
14728 public Object getFieldValue(_Fields field) {
14729 switch (field) {
14730 case TABLE_NAME:
14731 return getTableName();
14732
14733 case ROW:
14734 return getRow();
14735
14736 case TIMESTAMP:
14737 return new Long(getTimestamp());
14738
14739 }
14740 throw new IllegalStateException();
14741 }
14742
14743 public Object getFieldValue(int fieldId) {
14744 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
14745 }
14746
14747
14748 public boolean isSet(_Fields field) {
14749 switch (field) {
14750 case TABLE_NAME:
14751 return isSetTableName();
14752 case ROW:
14753 return isSetRow();
14754 case TIMESTAMP:
14755 return isSetTimestamp();
14756 }
14757 throw new IllegalStateException();
14758 }
14759
14760 public boolean isSet(int fieldID) {
14761 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
14762 }
14763
14764 @Override
14765 public boolean equals(Object that) {
14766 if (that == null)
14767 return false;
14768 if (that instanceof getRowTs_args)
14769 return this.equals((getRowTs_args)that);
14770 return false;
14771 }
14772
14773 public boolean equals(getRowTs_args that) {
14774 if (that == null)
14775 return false;
14776
14777 boolean this_present_tableName = true && this.isSetTableName();
14778 boolean that_present_tableName = true && that.isSetTableName();
14779 if (this_present_tableName || that_present_tableName) {
14780 if (!(this_present_tableName && that_present_tableName))
14781 return false;
14782 if (!java.util.Arrays.equals(this.tableName, that.tableName))
14783 return false;
14784 }
14785
14786 boolean this_present_row = true && this.isSetRow();
14787 boolean that_present_row = true && that.isSetRow();
14788 if (this_present_row || that_present_row) {
14789 if (!(this_present_row && that_present_row))
14790 return false;
14791 if (!java.util.Arrays.equals(this.row, that.row))
14792 return false;
14793 }
14794
14795 boolean this_present_timestamp = true;
14796 boolean that_present_timestamp = true;
14797 if (this_present_timestamp || that_present_timestamp) {
14798 if (!(this_present_timestamp && that_present_timestamp))
14799 return false;
14800 if (this.timestamp != that.timestamp)
14801 return false;
14802 }
14803
14804 return true;
14805 }
14806
14807 @Override
14808 public int hashCode() {
14809 HashCodeBuilder builder = new HashCodeBuilder();
14810
14811 boolean present_tableName = true && (isSetTableName());
14812 builder.append(present_tableName);
14813 if (present_tableName)
14814 builder.append(tableName);
14815
14816 boolean present_row = true && (isSetRow());
14817 builder.append(present_row);
14818 if (present_row)
14819 builder.append(row);
14820
14821 boolean present_timestamp = true;
14822 builder.append(present_timestamp);
14823 if (present_timestamp)
14824 builder.append(timestamp);
14825
14826 return builder.toHashCode();
14827 }
14828
14829 public int compareTo(getRowTs_args other) {
14830 if (!getClass().equals(other.getClass())) {
14831 return getClass().getName().compareTo(other.getClass().getName());
14832 }
14833
14834 int lastComparison = 0;
14835 getRowTs_args typedOther = (getRowTs_args)other;
14836
14837 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
14838 if (lastComparison != 0) {
14839 return lastComparison;
14840 }
14841 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
14842 if (lastComparison != 0) {
14843 return lastComparison;
14844 }
14845 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
14846 if (lastComparison != 0) {
14847 return lastComparison;
14848 }
14849 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
14850 if (lastComparison != 0) {
14851 return lastComparison;
14852 }
14853 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
14854 if (lastComparison != 0) {
14855 return lastComparison;
14856 }
14857 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
14858 if (lastComparison != 0) {
14859 return lastComparison;
14860 }
14861 return 0;
14862 }
14863
14864 public void read(TProtocol iprot) throws TException {
14865 TField field;
14866 iprot.readStructBegin();
14867 while (true)
14868 {
14869 field = iprot.readFieldBegin();
14870 if (field.type == TType.STOP) {
14871 break;
14872 }
14873 _Fields fieldId = _Fields.findByThriftId(field.id);
14874 if (fieldId == null) {
14875 TProtocolUtil.skip(iprot, field.type);
14876 } else {
14877 switch (fieldId) {
14878 case TABLE_NAME:
14879 if (field.type == TType.STRING) {
14880 this.tableName = iprot.readBinary();
14881 } else {
14882 TProtocolUtil.skip(iprot, field.type);
14883 }
14884 break;
14885 case ROW:
14886 if (field.type == TType.STRING) {
14887 this.row = iprot.readBinary();
14888 } else {
14889 TProtocolUtil.skip(iprot, field.type);
14890 }
14891 break;
14892 case TIMESTAMP:
14893 if (field.type == TType.I64) {
14894 this.timestamp = iprot.readI64();
14895 setTimestampIsSet(true);
14896 } else {
14897 TProtocolUtil.skip(iprot, field.type);
14898 }
14899 break;
14900 }
14901 iprot.readFieldEnd();
14902 }
14903 }
14904 iprot.readStructEnd();
14905
14906
14907 validate();
14908 }
14909
14910 public void write(TProtocol oprot) throws TException {
14911 validate();
14912
14913 oprot.writeStructBegin(STRUCT_DESC);
14914 if (this.tableName != null) {
14915 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
14916 oprot.writeBinary(this.tableName);
14917 oprot.writeFieldEnd();
14918 }
14919 if (this.row != null) {
14920 oprot.writeFieldBegin(ROW_FIELD_DESC);
14921 oprot.writeBinary(this.row);
14922 oprot.writeFieldEnd();
14923 }
14924 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
14925 oprot.writeI64(this.timestamp);
14926 oprot.writeFieldEnd();
14927 oprot.writeFieldStop();
14928 oprot.writeStructEnd();
14929 }
14930
14931 @Override
14932 public String toString() {
14933 StringBuilder sb = new StringBuilder("getRowTs_args(");
14934 boolean first = true;
14935
14936 sb.append("tableName:");
14937 if (this.tableName == null) {
14938 sb.append("null");
14939 } else {
14940 sb.append(this.tableName);
14941 }
14942 first = false;
14943 if (!first) sb.append(", ");
14944 sb.append("row:");
14945 if (this.row == null) {
14946 sb.append("null");
14947 } else {
14948 sb.append(this.row);
14949 }
14950 first = false;
14951 if (!first) sb.append(", ");
14952 sb.append("timestamp:");
14953 sb.append(this.timestamp);
14954 first = false;
14955 sb.append(")");
14956 return sb.toString();
14957 }
14958
14959 public void validate() throws TException {
14960
14961 }
14962
14963 }
14964
14965 public static class getRowTs_result implements TBase<getRowTs_result._Fields>, java.io.Serializable, Cloneable {
14966 private static final TStruct STRUCT_DESC = new TStruct("getRowTs_result");
14967
14968 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
14969 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
14970
14971 public List<TRowResult> success;
14972 public IOError io;
14973
14974
14975 public enum _Fields implements TFieldIdEnum {
14976 SUCCESS((short)0, "success"),
14977 IO((short)1, "io");
14978
14979 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14980 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14981
14982 static {
14983 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14984 byId.put((int)field._thriftId, field);
14985 byName.put(field.getFieldName(), field);
14986 }
14987 }
14988
14989
14990
14991
14992 public static _Fields findByThriftId(int fieldId) {
14993 return byId.get(fieldId);
14994 }
14995
14996
14997
14998
14999
15000 public static _Fields findByThriftIdOrThrow(int fieldId) {
15001 _Fields fields = findByThriftId(fieldId);
15002 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15003 return fields;
15004 }
15005
15006
15007
15008
15009 public static _Fields findByName(String name) {
15010 return byName.get(name);
15011 }
15012
15013 private final short _thriftId;
15014 private final String _fieldName;
15015
15016 _Fields(short thriftId, String fieldName) {
15017 _thriftId = thriftId;
15018 _fieldName = fieldName;
15019 }
15020
15021 public short getThriftFieldId() {
15022 return _thriftId;
15023 }
15024
15025 public String getFieldName() {
15026 return _fieldName;
15027 }
15028 }
15029
15030
15031
15032 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
15033 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
15034 new ListMetaData(TType.LIST,
15035 new StructMetaData(TType.STRUCT, TRowResult.class))));
15036 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
15037 new FieldValueMetaData(TType.STRUCT)));
15038 }});
15039
15040 static {
15041 FieldMetaData.addStructMetaDataMap(getRowTs_result.class, metaDataMap);
15042 }
15043
15044 public getRowTs_result() {
15045 }
15046
15047 public getRowTs_result(
15048 List<TRowResult> success,
15049 IOError io)
15050 {
15051 this();
15052 this.success = success;
15053 this.io = io;
15054 }
15055
15056
15057
15058
15059 public getRowTs_result(getRowTs_result other) {
15060 if (other.isSetSuccess()) {
15061 List<TRowResult> __this__success = new ArrayList<TRowResult>();
15062 for (TRowResult other_element : other.success) {
15063 __this__success.add(new TRowResult(other_element));
15064 }
15065 this.success = __this__success;
15066 }
15067 if (other.isSetIo()) {
15068 this.io = new IOError(other.io);
15069 }
15070 }
15071
15072 public getRowTs_result deepCopy() {
15073 return new getRowTs_result(this);
15074 }
15075
15076 @Deprecated
15077 public getRowTs_result clone() {
15078 return new getRowTs_result(this);
15079 }
15080
15081 public int getSuccessSize() {
15082 return (this.success == null) ? 0 : this.success.size();
15083 }
15084
15085 public java.util.Iterator<TRowResult> getSuccessIterator() {
15086 return (this.success == null) ? null : this.success.iterator();
15087 }
15088
15089 public void addToSuccess(TRowResult elem) {
15090 if (this.success == null) {
15091 this.success = new ArrayList<TRowResult>();
15092 }
15093 this.success.add(elem);
15094 }
15095
15096 public List<TRowResult> getSuccess() {
15097 return this.success;
15098 }
15099
15100 public getRowTs_result setSuccess(List<TRowResult> success) {
15101 this.success = success;
15102 return this;
15103 }
15104
15105 public void unsetSuccess() {
15106 this.success = null;
15107 }
15108
15109
15110 public boolean isSetSuccess() {
15111 return this.success != null;
15112 }
15113
15114 public void setSuccessIsSet(boolean value) {
15115 if (!value) {
15116 this.success = null;
15117 }
15118 }
15119
15120 public IOError getIo() {
15121 return this.io;
15122 }
15123
15124 public getRowTs_result setIo(IOError io) {
15125 this.io = io;
15126 return this;
15127 }
15128
15129 public void unsetIo() {
15130 this.io = null;
15131 }
15132
15133
15134 public boolean isSetIo() {
15135 return this.io != null;
15136 }
15137
15138 public void setIoIsSet(boolean value) {
15139 if (!value) {
15140 this.io = null;
15141 }
15142 }
15143
15144 public void setFieldValue(_Fields field, Object value) {
15145 switch (field) {
15146 case SUCCESS:
15147 if (value == null) {
15148 unsetSuccess();
15149 } else {
15150 setSuccess((List<TRowResult>)value);
15151 }
15152 break;
15153
15154 case IO:
15155 if (value == null) {
15156 unsetIo();
15157 } else {
15158 setIo((IOError)value);
15159 }
15160 break;
15161
15162 }
15163 }
15164
15165 public void setFieldValue(int fieldID, Object value) {
15166 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
15167 }
15168
15169 public Object getFieldValue(_Fields field) {
15170 switch (field) {
15171 case SUCCESS:
15172 return getSuccess();
15173
15174 case IO:
15175 return getIo();
15176
15177 }
15178 throw new IllegalStateException();
15179 }
15180
15181 public Object getFieldValue(int fieldId) {
15182 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
15183 }
15184
15185
15186 public boolean isSet(_Fields field) {
15187 switch (field) {
15188 case SUCCESS:
15189 return isSetSuccess();
15190 case IO:
15191 return isSetIo();
15192 }
15193 throw new IllegalStateException();
15194 }
15195
15196 public boolean isSet(int fieldID) {
15197 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
15198 }
15199
15200 @Override
15201 public boolean equals(Object that) {
15202 if (that == null)
15203 return false;
15204 if (that instanceof getRowTs_result)
15205 return this.equals((getRowTs_result)that);
15206 return false;
15207 }
15208
15209 public boolean equals(getRowTs_result that) {
15210 if (that == null)
15211 return false;
15212
15213 boolean this_present_success = true && this.isSetSuccess();
15214 boolean that_present_success = true && that.isSetSuccess();
15215 if (this_present_success || that_present_success) {
15216 if (!(this_present_success && that_present_success))
15217 return false;
15218 if (!this.success.equals(that.success))
15219 return false;
15220 }
15221
15222 boolean this_present_io = true && this.isSetIo();
15223 boolean that_present_io = true && that.isSetIo();
15224 if (this_present_io || that_present_io) {
15225 if (!(this_present_io && that_present_io))
15226 return false;
15227 if (!this.io.equals(that.io))
15228 return false;
15229 }
15230
15231 return true;
15232 }
15233
15234 @Override
15235 public int hashCode() {
15236 HashCodeBuilder builder = new HashCodeBuilder();
15237
15238 boolean present_success = true && (isSetSuccess());
15239 builder.append(present_success);
15240 if (present_success)
15241 builder.append(success);
15242
15243 boolean present_io = true && (isSetIo());
15244 builder.append(present_io);
15245 if (present_io)
15246 builder.append(io);
15247
15248 return builder.toHashCode();
15249 }
15250
15251 public void read(TProtocol iprot) throws TException {
15252 TField field;
15253 iprot.readStructBegin();
15254 while (true)
15255 {
15256 field = iprot.readFieldBegin();
15257 if (field.type == TType.STOP) {
15258 break;
15259 }
15260 _Fields fieldId = _Fields.findByThriftId(field.id);
15261 if (fieldId == null) {
15262 TProtocolUtil.skip(iprot, field.type);
15263 } else {
15264 switch (fieldId) {
15265 case SUCCESS:
15266 if (field.type == TType.LIST) {
15267 {
15268 TList _list50 = iprot.readListBegin();
15269 this.success = new ArrayList<TRowResult>(_list50.size);
15270 for (int _i51 = 0; _i51 < _list50.size; ++_i51)
15271 {
15272 TRowResult _elem52;
15273 _elem52 = new TRowResult();
15274 _elem52.read(iprot);
15275 this.success.add(_elem52);
15276 }
15277 iprot.readListEnd();
15278 }
15279 } else {
15280 TProtocolUtil.skip(iprot, field.type);
15281 }
15282 break;
15283 case IO:
15284 if (field.type == TType.STRUCT) {
15285 this.io = new IOError();
15286 this.io.read(iprot);
15287 } else {
15288 TProtocolUtil.skip(iprot, field.type);
15289 }
15290 break;
15291 }
15292 iprot.readFieldEnd();
15293 }
15294 }
15295 iprot.readStructEnd();
15296
15297
15298 validate();
15299 }
15300
15301 public void write(TProtocol oprot) throws TException {
15302 oprot.writeStructBegin(STRUCT_DESC);
15303
15304 if (this.isSetSuccess()) {
15305 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
15306 {
15307 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
15308 for (TRowResult _iter53 : this.success)
15309 {
15310 _iter53.write(oprot);
15311 }
15312 oprot.writeListEnd();
15313 }
15314 oprot.writeFieldEnd();
15315 } else if (this.isSetIo()) {
15316 oprot.writeFieldBegin(IO_FIELD_DESC);
15317 this.io.write(oprot);
15318 oprot.writeFieldEnd();
15319 }
15320 oprot.writeFieldStop();
15321 oprot.writeStructEnd();
15322 }
15323
15324 @Override
15325 public String toString() {
15326 StringBuilder sb = new StringBuilder("getRowTs_result(");
15327 boolean first = true;
15328
15329 sb.append("success:");
15330 if (this.success == null) {
15331 sb.append("null");
15332 } else {
15333 sb.append(this.success);
15334 }
15335 first = false;
15336 if (!first) sb.append(", ");
15337 sb.append("io:");
15338 if (this.io == null) {
15339 sb.append("null");
15340 } else {
15341 sb.append(this.io);
15342 }
15343 first = false;
15344 sb.append(")");
15345 return sb.toString();
15346 }
15347
15348 public void validate() throws TException {
15349
15350 }
15351
15352 }
15353
15354 public static class getRowWithColumnsTs_args implements TBase<getRowWithColumnsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumnsTs_args> {
15355 private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_args");
15356
15357 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
15358 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
15359 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
15360 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
15361
15362
15363
15364
15365 public byte[] tableName;
15366
15367
15368
15369 public byte[] row;
15370
15371
15372
15373 public List<byte[]> columns;
15374 public long timestamp;
15375
15376
15377 public enum _Fields implements TFieldIdEnum {
15378
15379
15380
15381 TABLE_NAME((short)1, "tableName"),
15382
15383
15384
15385 ROW((short)2, "row"),
15386
15387
15388
15389 COLUMNS((short)3, "columns"),
15390 TIMESTAMP((short)4, "timestamp");
15391
15392 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
15393 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15394
15395 static {
15396 for (_Fields field : EnumSet.allOf(_Fields.class)) {
15397 byId.put((int)field._thriftId, field);
15398 byName.put(field.getFieldName(), field);
15399 }
15400 }
15401
15402
15403
15404
15405 public static _Fields findByThriftId(int fieldId) {
15406 return byId.get(fieldId);
15407 }
15408
15409
15410
15411
15412
15413 public static _Fields findByThriftIdOrThrow(int fieldId) {
15414 _Fields fields = findByThriftId(fieldId);
15415 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15416 return fields;
15417 }
15418
15419
15420
15421
15422 public static _Fields findByName(String name) {
15423 return byName.get(name);
15424 }
15425
15426 private final short _thriftId;
15427 private final String _fieldName;
15428
15429 _Fields(short thriftId, String fieldName) {
15430 _thriftId = thriftId;
15431 _fieldName = fieldName;
15432 }
15433
15434 public short getThriftFieldId() {
15435 return _thriftId;
15436 }
15437
15438 public String getFieldName() {
15439 return _fieldName;
15440 }
15441 }
15442
15443
15444 private static final int __TIMESTAMP_ISSET_ID = 0;
15445 private BitSet __isset_bit_vector = new BitSet(1);
15446
15447 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
15448 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
15449 new FieldValueMetaData(TType.STRING)));
15450 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
15451 new FieldValueMetaData(TType.STRING)));
15452 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
15453 new ListMetaData(TType.LIST,
15454 new FieldValueMetaData(TType.STRING))));
15455 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
15456 new FieldValueMetaData(TType.I64)));
15457 }});
15458
15459 static {
15460 FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_args.class, metaDataMap);
15461 }
15462
15463 public getRowWithColumnsTs_args() {
15464 }
15465
15466 public getRowWithColumnsTs_args(
15467 byte[] tableName,
15468 byte[] row,
15469 List<byte[]> columns,
15470 long timestamp)
15471 {
15472 this();
15473 this.tableName = tableName;
15474 this.row = row;
15475 this.columns = columns;
15476 this.timestamp = timestamp;
15477 setTimestampIsSet(true);
15478 }
15479
15480
15481
15482
15483 public getRowWithColumnsTs_args(getRowWithColumnsTs_args other) {
15484 __isset_bit_vector.clear();
15485 __isset_bit_vector.or(other.__isset_bit_vector);
15486 if (other.isSetTableName()) {
15487 this.tableName = other.tableName;
15488 }
15489 if (other.isSetRow()) {
15490 this.row = other.row;
15491 }
15492 if (other.isSetColumns()) {
15493 List<byte[]> __this__columns = new ArrayList<byte[]>();
15494 for (byte[] other_element : other.columns) {
15495 __this__columns.add(other_element);
15496 }
15497 this.columns = __this__columns;
15498 }
15499 this.timestamp = other.timestamp;
15500 }
15501
15502 public getRowWithColumnsTs_args deepCopy() {
15503 return new getRowWithColumnsTs_args(this);
15504 }
15505
15506 @Deprecated
15507 public getRowWithColumnsTs_args clone() {
15508 return new getRowWithColumnsTs_args(this);
15509 }
15510
15511
15512
15513
15514 public byte[] getTableName() {
15515 return this.tableName;
15516 }
15517
15518
15519
15520
15521 public getRowWithColumnsTs_args setTableName(byte[] tableName) {
15522 this.tableName = tableName;
15523 return this;
15524 }
15525
15526 public void unsetTableName() {
15527 this.tableName = null;
15528 }
15529
15530
15531 public boolean isSetTableName() {
15532 return this.tableName != null;
15533 }
15534
15535 public void setTableNameIsSet(boolean value) {
15536 if (!value) {
15537 this.tableName = null;
15538 }
15539 }
15540
15541
15542
15543
15544 public byte[] getRow() {
15545 return this.row;
15546 }
15547
15548
15549
15550
15551 public getRowWithColumnsTs_args setRow(byte[] row) {
15552 this.row = row;
15553 return this;
15554 }
15555
15556 public void unsetRow() {
15557 this.row = null;
15558 }
15559
15560
15561 public boolean isSetRow() {
15562 return this.row != null;
15563 }
15564
15565 public void setRowIsSet(boolean value) {
15566 if (!value) {
15567 this.row = null;
15568 }
15569 }
15570
15571 public int getColumnsSize() {
15572 return (this.columns == null) ? 0 : this.columns.size();
15573 }
15574
15575 public java.util.Iterator<byte[]> getColumnsIterator() {
15576 return (this.columns == null) ? null : this.columns.iterator();
15577 }
15578
15579 public void addToColumns(byte[] elem) {
15580 if (this.columns == null) {
15581 this.columns = new ArrayList<byte[]>();
15582 }
15583 this.columns.add(elem);
15584 }
15585
15586
15587
15588
15589 public List<byte[]> getColumns() {
15590 return this.columns;
15591 }
15592
15593
15594
15595
15596 public getRowWithColumnsTs_args setColumns(List<byte[]> columns) {
15597 this.columns = columns;
15598 return this;
15599 }
15600
15601 public void unsetColumns() {
15602 this.columns = null;
15603 }
15604
15605
15606 public boolean isSetColumns() {
15607 return this.columns != null;
15608 }
15609
15610 public void setColumnsIsSet(boolean value) {
15611 if (!value) {
15612 this.columns = null;
15613 }
15614 }
15615
15616 public long getTimestamp() {
15617 return this.timestamp;
15618 }
15619
15620 public getRowWithColumnsTs_args setTimestamp(long timestamp) {
15621 this.timestamp = timestamp;
15622 setTimestampIsSet(true);
15623 return this;
15624 }
15625
15626 public void unsetTimestamp() {
15627 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
15628 }
15629
15630
15631 public boolean isSetTimestamp() {
15632 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
15633 }
15634
15635 public void setTimestampIsSet(boolean value) {
15636 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
15637 }
15638
15639 public void setFieldValue(_Fields field, Object value) {
15640 switch (field) {
15641 case TABLE_NAME:
15642 if (value == null) {
15643 unsetTableName();
15644 } else {
15645 setTableName((byte[])value);
15646 }
15647 break;
15648
15649 case ROW:
15650 if (value == null) {
15651 unsetRow();
15652 } else {
15653 setRow((byte[])value);
15654 }
15655 break;
15656
15657 case COLUMNS:
15658 if (value == null) {
15659 unsetColumns();
15660 } else {
15661 setColumns((List<byte[]>)value);
15662 }
15663 break;
15664
15665 case TIMESTAMP:
15666 if (value == null) {
15667 unsetTimestamp();
15668 } else {
15669 setTimestamp((Long)value);
15670 }
15671 break;
15672
15673 }
15674 }
15675
15676 public void setFieldValue(int fieldID, Object value) {
15677 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
15678 }
15679
15680 public Object getFieldValue(_Fields field) {
15681 switch (field) {
15682 case TABLE_NAME:
15683 return getTableName();
15684
15685 case ROW:
15686 return getRow();
15687
15688 case COLUMNS:
15689 return getColumns();
15690
15691 case TIMESTAMP:
15692 return new Long(getTimestamp());
15693
15694 }
15695 throw new IllegalStateException();
15696 }
15697
15698 public Object getFieldValue(int fieldId) {
15699 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
15700 }
15701
15702
15703 public boolean isSet(_Fields field) {
15704 switch (field) {
15705 case TABLE_NAME:
15706 return isSetTableName();
15707 case ROW:
15708 return isSetRow();
15709 case COLUMNS:
15710 return isSetColumns();
15711 case TIMESTAMP:
15712 return isSetTimestamp();
15713 }
15714 throw new IllegalStateException();
15715 }
15716
15717 public boolean isSet(int fieldID) {
15718 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
15719 }
15720
15721 @Override
15722 public boolean equals(Object that) {
15723 if (that == null)
15724 return false;
15725 if (that instanceof getRowWithColumnsTs_args)
15726 return this.equals((getRowWithColumnsTs_args)that);
15727 return false;
15728 }
15729
15730 public boolean equals(getRowWithColumnsTs_args that) {
15731 if (that == null)
15732 return false;
15733
15734 boolean this_present_tableName = true && this.isSetTableName();
15735 boolean that_present_tableName = true && that.isSetTableName();
15736 if (this_present_tableName || that_present_tableName) {
15737 if (!(this_present_tableName && that_present_tableName))
15738 return false;
15739 if (!java.util.Arrays.equals(this.tableName, that.tableName))
15740 return false;
15741 }
15742
15743 boolean this_present_row = true && this.isSetRow();
15744 boolean that_present_row = true && that.isSetRow();
15745 if (this_present_row || that_present_row) {
15746 if (!(this_present_row && that_present_row))
15747 return false;
15748 if (!java.util.Arrays.equals(this.row, that.row))
15749 return false;
15750 }
15751
15752 boolean this_present_columns = true && this.isSetColumns();
15753 boolean that_present_columns = true && that.isSetColumns();
15754 if (this_present_columns || that_present_columns) {
15755 if (!(this_present_columns && that_present_columns))
15756 return false;
15757 if (!this.columns.equals(that.columns))
15758 return false;
15759 }
15760
15761 boolean this_present_timestamp = true;
15762 boolean that_present_timestamp = true;
15763 if (this_present_timestamp || that_present_timestamp) {
15764 if (!(this_present_timestamp && that_present_timestamp))
15765 return false;
15766 if (this.timestamp != that.timestamp)
15767 return false;
15768 }
15769
15770 return true;
15771 }
15772
15773 @Override
15774 public int hashCode() {
15775 HashCodeBuilder builder = new HashCodeBuilder();
15776
15777 boolean present_tableName = true && (isSetTableName());
15778 builder.append(present_tableName);
15779 if (present_tableName)
15780 builder.append(tableName);
15781
15782 boolean present_row = true && (isSetRow());
15783 builder.append(present_row);
15784 if (present_row)
15785 builder.append(row);
15786
15787 boolean present_columns = true && (isSetColumns());
15788 builder.append(present_columns);
15789 if (present_columns)
15790 builder.append(columns);
15791
15792 boolean present_timestamp = true;
15793 builder.append(present_timestamp);
15794 if (present_timestamp)
15795 builder.append(timestamp);
15796
15797 return builder.toHashCode();
15798 }
15799
15800 public int compareTo(getRowWithColumnsTs_args other) {
15801 if (!getClass().equals(other.getClass())) {
15802 return getClass().getName().compareTo(other.getClass().getName());
15803 }
15804
15805 int lastComparison = 0;
15806 getRowWithColumnsTs_args typedOther = (getRowWithColumnsTs_args)other;
15807
15808 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
15809 if (lastComparison != 0) {
15810 return lastComparison;
15811 }
15812 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
15813 if (lastComparison != 0) {
15814 return lastComparison;
15815 }
15816 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
15817 if (lastComparison != 0) {
15818 return lastComparison;
15819 }
15820 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
15821 if (lastComparison != 0) {
15822 return lastComparison;
15823 }
15824 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
15825 if (lastComparison != 0) {
15826 return lastComparison;
15827 }
15828 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
15829 if (lastComparison != 0) {
15830 return lastComparison;
15831 }
15832 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
15833 if (lastComparison != 0) {
15834 return lastComparison;
15835 }
15836 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
15837 if (lastComparison != 0) {
15838 return lastComparison;
15839 }
15840 return 0;
15841 }
15842
15843 public void read(TProtocol iprot) throws TException {
15844 TField field;
15845 iprot.readStructBegin();
15846 while (true)
15847 {
15848 field = iprot.readFieldBegin();
15849 if (field.type == TType.STOP) {
15850 break;
15851 }
15852 _Fields fieldId = _Fields.findByThriftId(field.id);
15853 if (fieldId == null) {
15854 TProtocolUtil.skip(iprot, field.type);
15855 } else {
15856 switch (fieldId) {
15857 case TABLE_NAME:
15858 if (field.type == TType.STRING) {
15859 this.tableName = iprot.readBinary();
15860 } else {
15861 TProtocolUtil.skip(iprot, field.type);
15862 }
15863 break;
15864 case ROW:
15865 if (field.type == TType.STRING) {
15866 this.row = iprot.readBinary();
15867 } else {
15868 TProtocolUtil.skip(iprot, field.type);
15869 }
15870 break;
15871 case COLUMNS:
15872 if (field.type == TType.LIST) {
15873 {
15874 TList _list54 = iprot.readListBegin();
15875 this.columns = new ArrayList<byte[]>(_list54.size);
15876 for (int _i55 = 0; _i55 < _list54.size; ++_i55)
15877 {
15878 byte[] _elem56;
15879 _elem56 = iprot.readBinary();
15880 this.columns.add(_elem56);
15881 }
15882 iprot.readListEnd();
15883 }
15884 } else {
15885 TProtocolUtil.skip(iprot, field.type);
15886 }
15887 break;
15888 case TIMESTAMP:
15889 if (field.type == TType.I64) {
15890 this.timestamp = iprot.readI64();
15891 setTimestampIsSet(true);
15892 } else {
15893 TProtocolUtil.skip(iprot, field.type);
15894 }
15895 break;
15896 }
15897 iprot.readFieldEnd();
15898 }
15899 }
15900 iprot.readStructEnd();
15901
15902
15903 validate();
15904 }
15905
15906 public void write(TProtocol oprot) throws TException {
15907 validate();
15908
15909 oprot.writeStructBegin(STRUCT_DESC);
15910 if (this.tableName != null) {
15911 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
15912 oprot.writeBinary(this.tableName);
15913 oprot.writeFieldEnd();
15914 }
15915 if (this.row != null) {
15916 oprot.writeFieldBegin(ROW_FIELD_DESC);
15917 oprot.writeBinary(this.row);
15918 oprot.writeFieldEnd();
15919 }
15920 if (this.columns != null) {
15921 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
15922 {
15923 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
15924 for (byte[] _iter57 : this.columns)
15925 {
15926 oprot.writeBinary(_iter57);
15927 }
15928 oprot.writeListEnd();
15929 }
15930 oprot.writeFieldEnd();
15931 }
15932 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
15933 oprot.writeI64(this.timestamp);
15934 oprot.writeFieldEnd();
15935 oprot.writeFieldStop();
15936 oprot.writeStructEnd();
15937 }
15938
15939 @Override
15940 public String toString() {
15941 StringBuilder sb = new StringBuilder("getRowWithColumnsTs_args(");
15942 boolean first = true;
15943
15944 sb.append("tableName:");
15945 if (this.tableName == null) {
15946 sb.append("null");
15947 } else {
15948 sb.append(this.tableName);
15949 }
15950 first = false;
15951 if (!first) sb.append(", ");
15952 sb.append("row:");
15953 if (this.row == null) {
15954 sb.append("null");
15955 } else {
15956 sb.append(this.row);
15957 }
15958 first = false;
15959 if (!first) sb.append(", ");
15960 sb.append("columns:");
15961 if (this.columns == null) {
15962 sb.append("null");
15963 } else {
15964 sb.append(this.columns);
15965 }
15966 first = false;
15967 if (!first) sb.append(", ");
15968 sb.append("timestamp:");
15969 sb.append(this.timestamp);
15970 first = false;
15971 sb.append(")");
15972 return sb.toString();
15973 }
15974
15975 public void validate() throws TException {
15976
15977 }
15978
15979 }
15980
15981 public static class getRowWithColumnsTs_result implements TBase<getRowWithColumnsTs_result._Fields>, java.io.Serializable, Cloneable {
15982 private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_result");
15983
15984 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
15985 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
15986
15987 public List<TRowResult> success;
15988 public IOError io;
15989
15990
15991 public enum _Fields implements TFieldIdEnum {
15992 SUCCESS((short)0, "success"),
15993 IO((short)1, "io");
15994
15995 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
15996 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15997
15998 static {
15999 for (_Fields field : EnumSet.allOf(_Fields.class)) {
16000 byId.put((int)field._thriftId, field);
16001 byName.put(field.getFieldName(), field);
16002 }
16003 }
16004
16005
16006
16007
16008 public static _Fields findByThriftId(int fieldId) {
16009 return byId.get(fieldId);
16010 }
16011
16012
16013
16014
16015
16016 public static _Fields findByThriftIdOrThrow(int fieldId) {
16017 _Fields fields = findByThriftId(fieldId);
16018 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16019 return fields;
16020 }
16021
16022
16023
16024
16025 public static _Fields findByName(String name) {
16026 return byName.get(name);
16027 }
16028
16029 private final short _thriftId;
16030 private final String _fieldName;
16031
16032 _Fields(short thriftId, String fieldName) {
16033 _thriftId = thriftId;
16034 _fieldName = fieldName;
16035 }
16036
16037 public short getThriftFieldId() {
16038 return _thriftId;
16039 }
16040
16041 public String getFieldName() {
16042 return _fieldName;
16043 }
16044 }
16045
16046
16047
16048 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16049 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
16050 new ListMetaData(TType.LIST,
16051 new StructMetaData(TType.STRUCT, TRowResult.class))));
16052 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
16053 new FieldValueMetaData(TType.STRUCT)));
16054 }});
16055
16056 static {
16057 FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_result.class, metaDataMap);
16058 }
16059
16060 public getRowWithColumnsTs_result() {
16061 }
16062
16063 public getRowWithColumnsTs_result(
16064 List<TRowResult> success,
16065 IOError io)
16066 {
16067 this();
16068 this.success = success;
16069 this.io = io;
16070 }
16071
16072
16073
16074
16075 public getRowWithColumnsTs_result(getRowWithColumnsTs_result other) {
16076 if (other.isSetSuccess()) {
16077 List<TRowResult> __this__success = new ArrayList<TRowResult>();
16078 for (TRowResult other_element : other.success) {
16079 __this__success.add(new TRowResult(other_element));
16080 }
16081 this.success = __this__success;
16082 }
16083 if (other.isSetIo()) {
16084 this.io = new IOError(other.io);
16085 }
16086 }
16087
16088 public getRowWithColumnsTs_result deepCopy() {
16089 return new getRowWithColumnsTs_result(this);
16090 }
16091
16092 @Deprecated
16093 public getRowWithColumnsTs_result clone() {
16094 return new getRowWithColumnsTs_result(this);
16095 }
16096
16097 public int getSuccessSize() {
16098 return (this.success == null) ? 0 : this.success.size();
16099 }
16100
16101 public java.util.Iterator<TRowResult> getSuccessIterator() {
16102 return (this.success == null) ? null : this.success.iterator();
16103 }
16104
16105 public void addToSuccess(TRowResult elem) {
16106 if (this.success == null) {
16107 this.success = new ArrayList<TRowResult>();
16108 }
16109 this.success.add(elem);
16110 }
16111
16112 public List<TRowResult> getSuccess() {
16113 return this.success;
16114 }
16115
16116 public getRowWithColumnsTs_result setSuccess(List<TRowResult> success) {
16117 this.success = success;
16118 return this;
16119 }
16120
16121 public void unsetSuccess() {
16122 this.success = null;
16123 }
16124
16125
16126 public boolean isSetSuccess() {
16127 return this.success != null;
16128 }
16129
16130 public void setSuccessIsSet(boolean value) {
16131 if (!value) {
16132 this.success = null;
16133 }
16134 }
16135
16136 public IOError getIo() {
16137 return this.io;
16138 }
16139
16140 public getRowWithColumnsTs_result setIo(IOError io) {
16141 this.io = io;
16142 return this;
16143 }
16144
16145 public void unsetIo() {
16146 this.io = null;
16147 }
16148
16149
16150 public boolean isSetIo() {
16151 return this.io != null;
16152 }
16153
16154 public void setIoIsSet(boolean value) {
16155 if (!value) {
16156 this.io = null;
16157 }
16158 }
16159
16160 public void setFieldValue(_Fields field, Object value) {
16161 switch (field) {
16162 case SUCCESS:
16163 if (value == null) {
16164 unsetSuccess();
16165 } else {
16166 setSuccess((List<TRowResult>)value);
16167 }
16168 break;
16169
16170 case IO:
16171 if (value == null) {
16172 unsetIo();
16173 } else {
16174 setIo((IOError)value);
16175 }
16176 break;
16177
16178 }
16179 }
16180
16181 public void setFieldValue(int fieldID, Object value) {
16182 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
16183 }
16184
16185 public Object getFieldValue(_Fields field) {
16186 switch (field) {
16187 case SUCCESS:
16188 return getSuccess();
16189
16190 case IO:
16191 return getIo();
16192
16193 }
16194 throw new IllegalStateException();
16195 }
16196
16197 public Object getFieldValue(int fieldId) {
16198 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
16199 }
16200
16201
16202 public boolean isSet(_Fields field) {
16203 switch (field) {
16204 case SUCCESS:
16205 return isSetSuccess();
16206 case IO:
16207 return isSetIo();
16208 }
16209 throw new IllegalStateException();
16210 }
16211
16212 public boolean isSet(int fieldID) {
16213 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
16214 }
16215
16216 @Override
16217 public boolean equals(Object that) {
16218 if (that == null)
16219 return false;
16220 if (that instanceof getRowWithColumnsTs_result)
16221 return this.equals((getRowWithColumnsTs_result)that);
16222 return false;
16223 }
16224
16225 public boolean equals(getRowWithColumnsTs_result that) {
16226 if (that == null)
16227 return false;
16228
16229 boolean this_present_success = true && this.isSetSuccess();
16230 boolean that_present_success = true && that.isSetSuccess();
16231 if (this_present_success || that_present_success) {
16232 if (!(this_present_success && that_present_success))
16233 return false;
16234 if (!this.success.equals(that.success))
16235 return false;
16236 }
16237
16238 boolean this_present_io = true && this.isSetIo();
16239 boolean that_present_io = true && that.isSetIo();
16240 if (this_present_io || that_present_io) {
16241 if (!(this_present_io && that_present_io))
16242 return false;
16243 if (!this.io.equals(that.io))
16244 return false;
16245 }
16246
16247 return true;
16248 }
16249
16250 @Override
16251 public int hashCode() {
16252 HashCodeBuilder builder = new HashCodeBuilder();
16253
16254 boolean present_success = true && (isSetSuccess());
16255 builder.append(present_success);
16256 if (present_success)
16257 builder.append(success);
16258
16259 boolean present_io = true && (isSetIo());
16260 builder.append(present_io);
16261 if (present_io)
16262 builder.append(io);
16263
16264 return builder.toHashCode();
16265 }
16266
16267 public void read(TProtocol iprot) throws TException {
16268 TField field;
16269 iprot.readStructBegin();
16270 while (true)
16271 {
16272 field = iprot.readFieldBegin();
16273 if (field.type == TType.STOP) {
16274 break;
16275 }
16276 _Fields fieldId = _Fields.findByThriftId(field.id);
16277 if (fieldId == null) {
16278 TProtocolUtil.skip(iprot, field.type);
16279 } else {
16280 switch (fieldId) {
16281 case SUCCESS:
16282 if (field.type == TType.LIST) {
16283 {
16284 TList _list58 = iprot.readListBegin();
16285 this.success = new ArrayList<TRowResult>(_list58.size);
16286 for (int _i59 = 0; _i59 < _list58.size; ++_i59)
16287 {
16288 TRowResult _elem60;
16289 _elem60 = new TRowResult();
16290 _elem60.read(iprot);
16291 this.success.add(_elem60);
16292 }
16293 iprot.readListEnd();
16294 }
16295 } else {
16296 TProtocolUtil.skip(iprot, field.type);
16297 }
16298 break;
16299 case IO:
16300 if (field.type == TType.STRUCT) {
16301 this.io = new IOError();
16302 this.io.read(iprot);
16303 } else {
16304 TProtocolUtil.skip(iprot, field.type);
16305 }
16306 break;
16307 }
16308 iprot.readFieldEnd();
16309 }
16310 }
16311 iprot.readStructEnd();
16312
16313
16314 validate();
16315 }
16316
16317 public void write(TProtocol oprot) throws TException {
16318 oprot.writeStructBegin(STRUCT_DESC);
16319
16320 if (this.isSetSuccess()) {
16321 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
16322 {
16323 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
16324 for (TRowResult _iter61 : this.success)
16325 {
16326 _iter61.write(oprot);
16327 }
16328 oprot.writeListEnd();
16329 }
16330 oprot.writeFieldEnd();
16331 } else if (this.isSetIo()) {
16332 oprot.writeFieldBegin(IO_FIELD_DESC);
16333 this.io.write(oprot);
16334 oprot.writeFieldEnd();
16335 }
16336 oprot.writeFieldStop();
16337 oprot.writeStructEnd();
16338 }
16339
16340 @Override
16341 public String toString() {
16342 StringBuilder sb = new StringBuilder("getRowWithColumnsTs_result(");
16343 boolean first = true;
16344
16345 sb.append("success:");
16346 if (this.success == null) {
16347 sb.append("null");
16348 } else {
16349 sb.append(this.success);
16350 }
16351 first = false;
16352 if (!first) sb.append(", ");
16353 sb.append("io:");
16354 if (this.io == null) {
16355 sb.append("null");
16356 } else {
16357 sb.append(this.io);
16358 }
16359 first = false;
16360 sb.append(")");
16361 return sb.toString();
16362 }
16363
16364 public void validate() throws TException {
16365
16366 }
16367
16368 }
16369
16370 public static class getRows_args implements TBase<getRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRows_args> {
16371 private static final TStruct STRUCT_DESC = new TStruct("getRows_args");
16372
16373 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
16374 private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
16375
16376
16377
16378
16379 public byte[] tableName;
16380
16381
16382
16383 public List<byte[]> rows;
16384
16385
16386 public enum _Fields implements TFieldIdEnum {
16387
16388
16389
16390 TABLE_NAME((short)1, "tableName"),
16391
16392
16393
16394 ROWS((short)2, "rows");
16395
16396 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
16397 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16398
16399 static {
16400 for (_Fields field : EnumSet.allOf(_Fields.class)) {
16401 byId.put((int)field._thriftId, field);
16402 byName.put(field.getFieldName(), field);
16403 }
16404 }
16405
16406
16407
16408
16409 public static _Fields findByThriftId(int fieldId) {
16410 return byId.get(fieldId);
16411 }
16412
16413
16414
16415
16416
16417 public static _Fields findByThriftIdOrThrow(int fieldId) {
16418 _Fields fields = findByThriftId(fieldId);
16419 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16420 return fields;
16421 }
16422
16423
16424
16425
16426 public static _Fields findByName(String name) {
16427 return byName.get(name);
16428 }
16429
16430 private final short _thriftId;
16431 private final String _fieldName;
16432
16433 _Fields(short thriftId, String fieldName) {
16434 _thriftId = thriftId;
16435 _fieldName = fieldName;
16436 }
16437
16438 public short getThriftFieldId() {
16439 return _thriftId;
16440 }
16441
16442 public String getFieldName() {
16443 return _fieldName;
16444 }
16445 }
16446
16447
16448
16449 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16450 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
16451 new FieldValueMetaData(TType.STRING)));
16452 put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
16453 new ListMetaData(TType.LIST,
16454 new FieldValueMetaData(TType.STRING))));
16455 }});
16456
16457 static {
16458 FieldMetaData.addStructMetaDataMap(getRows_args.class, metaDataMap);
16459 }
16460
16461 public getRows_args() {
16462 }
16463
16464 public getRows_args(
16465 byte[] tableName,
16466 List<byte[]> rows)
16467 {
16468 this();
16469 this.tableName = tableName;
16470 this.rows = rows;
16471 }
16472
16473
16474
16475
16476 public getRows_args(getRows_args other) {
16477 if (other.isSetTableName()) {
16478 this.tableName = other.tableName;
16479 }
16480 if (other.isSetRows()) {
16481 List<byte[]> __this__rows = new ArrayList<byte[]>();
16482 for (byte[] other_element : other.rows) {
16483 __this__rows.add(other_element);
16484 }
16485 this.rows = __this__rows;
16486 }
16487 }
16488
16489 public getRows_args deepCopy() {
16490 return new getRows_args(this);
16491 }
16492
16493 @Deprecated
16494 public getRows_args clone() {
16495 return new getRows_args(this);
16496 }
16497
16498
16499
16500
16501 public byte[] getTableName() {
16502 return this.tableName;
16503 }
16504
16505
16506
16507
16508 public getRows_args setTableName(byte[] tableName) {
16509 this.tableName = tableName;
16510 return this;
16511 }
16512
16513 public void unsetTableName() {
16514 this.tableName = null;
16515 }
16516
16517
16518 public boolean isSetTableName() {
16519 return this.tableName != null;
16520 }
16521
16522 public void setTableNameIsSet(boolean value) {
16523 if (!value) {
16524 this.tableName = null;
16525 }
16526 }
16527
16528 public int getRowsSize() {
16529 return (this.rows == null) ? 0 : this.rows.size();
16530 }
16531
16532 public java.util.Iterator<byte[]> getRowsIterator() {
16533 return (this.rows == null) ? null : this.rows.iterator();
16534 }
16535
16536 public void addToRows(byte[] elem) {
16537 if (this.rows == null) {
16538 this.rows = new ArrayList<byte[]>();
16539 }
16540 this.rows.add(elem);
16541 }
16542
16543
16544
16545
16546 public List<byte[]> getRows() {
16547 return this.rows;
16548 }
16549
16550
16551
16552
16553 public getRows_args setRows(List<byte[]> rows) {
16554 this.rows = rows;
16555 return this;
16556 }
16557
16558 public void unsetRows() {
16559 this.rows = null;
16560 }
16561
16562
16563 public boolean isSetRows() {
16564 return this.rows != null;
16565 }
16566
16567 public void setRowsIsSet(boolean value) {
16568 if (!value) {
16569 this.rows = null;
16570 }
16571 }
16572
16573 public void setFieldValue(_Fields field, Object value) {
16574 switch (field) {
16575 case TABLE_NAME:
16576 if (value == null) {
16577 unsetTableName();
16578 } else {
16579 setTableName((byte[])value);
16580 }
16581 break;
16582
16583 case ROWS:
16584 if (value == null) {
16585 unsetRows();
16586 } else {
16587 setRows((List<byte[]>)value);
16588 }
16589 break;
16590
16591 }
16592 }
16593
16594 public void setFieldValue(int fieldID, Object value) {
16595 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
16596 }
16597
16598 public Object getFieldValue(_Fields field) {
16599 switch (field) {
16600 case TABLE_NAME:
16601 return getTableName();
16602
16603 case ROWS:
16604 return getRows();
16605
16606 }
16607 throw new IllegalStateException();
16608 }
16609
16610 public Object getFieldValue(int fieldId) {
16611 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
16612 }
16613
16614
16615 public boolean isSet(_Fields field) {
16616 switch (field) {
16617 case TABLE_NAME:
16618 return isSetTableName();
16619 case ROWS:
16620 return isSetRows();
16621 }
16622 throw new IllegalStateException();
16623 }
16624
16625 public boolean isSet(int fieldID) {
16626 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
16627 }
16628
16629 @Override
16630 public boolean equals(Object that) {
16631 if (that == null)
16632 return false;
16633 if (that instanceof getRows_args)
16634 return this.equals((getRows_args)that);
16635 return false;
16636 }
16637
16638 public boolean equals(getRows_args that) {
16639 if (that == null)
16640 return false;
16641
16642 boolean this_present_tableName = true && this.isSetTableName();
16643 boolean that_present_tableName = true && that.isSetTableName();
16644 if (this_present_tableName || that_present_tableName) {
16645 if (!(this_present_tableName && that_present_tableName))
16646 return false;
16647 if (!java.util.Arrays.equals(this.tableName, that.tableName))
16648 return false;
16649 }
16650
16651 boolean this_present_rows = true && this.isSetRows();
16652 boolean that_present_rows = true && that.isSetRows();
16653 if (this_present_rows || that_present_rows) {
16654 if (!(this_present_rows && that_present_rows))
16655 return false;
16656 if (!this.rows.equals(that.rows))
16657 return false;
16658 }
16659
16660 return true;
16661 }
16662
16663 @Override
16664 public int hashCode() {
16665 HashCodeBuilder builder = new HashCodeBuilder();
16666
16667 boolean present_tableName = true && (isSetTableName());
16668 builder.append(present_tableName);
16669 if (present_tableName)
16670 builder.append(tableName);
16671
16672 boolean present_rows = true && (isSetRows());
16673 builder.append(present_rows);
16674 if (present_rows)
16675 builder.append(rows);
16676
16677 return builder.toHashCode();
16678 }
16679
16680 public int compareTo(getRows_args other) {
16681 if (!getClass().equals(other.getClass())) {
16682 return getClass().getName().compareTo(other.getClass().getName());
16683 }
16684
16685 int lastComparison = 0;
16686 getRows_args typedOther = (getRows_args)other;
16687
16688 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
16689 if (lastComparison != 0) {
16690 return lastComparison;
16691 }
16692 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
16693 if (lastComparison != 0) {
16694 return lastComparison;
16695 }
16696 lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
16697 if (lastComparison != 0) {
16698 return lastComparison;
16699 }
16700 lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
16701 if (lastComparison != 0) {
16702 return lastComparison;
16703 }
16704 return 0;
16705 }
16706
16707 public void read(TProtocol iprot) throws TException {
16708 TField field;
16709 iprot.readStructBegin();
16710 while (true)
16711 {
16712 field = iprot.readFieldBegin();
16713 if (field.type == TType.STOP) {
16714 break;
16715 }
16716 _Fields fieldId = _Fields.findByThriftId(field.id);
16717 if (fieldId == null) {
16718 TProtocolUtil.skip(iprot, field.type);
16719 } else {
16720 switch (fieldId) {
16721 case TABLE_NAME:
16722 if (field.type == TType.STRING) {
16723 this.tableName = iprot.readBinary();
16724 } else {
16725 TProtocolUtil.skip(iprot, field.type);
16726 }
16727 break;
16728 case ROWS:
16729 if (field.type == TType.LIST) {
16730 {
16731 TList _list62 = iprot.readListBegin();
16732 this.rows = new ArrayList<byte[]>(_list62.size);
16733 for (int _i63 = 0; _i63 < _list62.size; ++_i63)
16734 {
16735 byte[] _elem64;
16736 _elem64 = iprot.readBinary();
16737 this.rows.add(_elem64);
16738 }
16739 iprot.readListEnd();
16740 }
16741 } else {
16742 TProtocolUtil.skip(iprot, field.type);
16743 }
16744 break;
16745 }
16746 iprot.readFieldEnd();
16747 }
16748 }
16749 iprot.readStructEnd();
16750
16751
16752 validate();
16753 }
16754
16755 public void write(TProtocol oprot) throws TException {
16756 validate();
16757
16758 oprot.writeStructBegin(STRUCT_DESC);
16759 if (this.tableName != null) {
16760 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
16761 oprot.writeBinary(this.tableName);
16762 oprot.writeFieldEnd();
16763 }
16764 if (this.rows != null) {
16765 oprot.writeFieldBegin(ROWS_FIELD_DESC);
16766 {
16767 oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
16768 for (byte[] _iter65 : this.rows)
16769 {
16770 oprot.writeBinary(_iter65);
16771 }
16772 oprot.writeListEnd();
16773 }
16774 oprot.writeFieldEnd();
16775 }
16776 oprot.writeFieldStop();
16777 oprot.writeStructEnd();
16778 }
16779
16780 @Override
16781 public String toString() {
16782 StringBuilder sb = new StringBuilder("getRows_args(");
16783 boolean first = true;
16784
16785 sb.append("tableName:");
16786 if (this.tableName == null) {
16787 sb.append("null");
16788 } else {
16789 sb.append(this.tableName);
16790 }
16791 first = false;
16792 if (!first) sb.append(", ");
16793 sb.append("rows:");
16794 if (this.rows == null) {
16795 sb.append("null");
16796 } else {
16797 sb.append(this.rows);
16798 }
16799 first = false;
16800 sb.append(")");
16801 return sb.toString();
16802 }
16803
16804 public void validate() throws TException {
16805
16806 }
16807
16808 }
16809
16810 public static class getRows_result implements TBase<getRows_result._Fields>, java.io.Serializable, Cloneable {
16811 private static final TStruct STRUCT_DESC = new TStruct("getRows_result");
16812
16813 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
16814 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
16815
16816 public List<TRowResult> success;
16817 public IOError io;
16818
16819
16820 public enum _Fields implements TFieldIdEnum {
16821 SUCCESS((short)0, "success"),
16822 IO((short)1, "io");
16823
16824 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
16825 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16826
16827 static {
16828 for (_Fields field : EnumSet.allOf(_Fields.class)) {
16829 byId.put((int)field._thriftId, field);
16830 byName.put(field.getFieldName(), field);
16831 }
16832 }
16833
16834
16835
16836
16837 public static _Fields findByThriftId(int fieldId) {
16838 return byId.get(fieldId);
16839 }
16840
16841
16842
16843
16844
16845 public static _Fields findByThriftIdOrThrow(int fieldId) {
16846 _Fields fields = findByThriftId(fieldId);
16847 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16848 return fields;
16849 }
16850
16851
16852
16853
16854 public static _Fields findByName(String name) {
16855 return byName.get(name);
16856 }
16857
16858 private final short _thriftId;
16859 private final String _fieldName;
16860
16861 _Fields(short thriftId, String fieldName) {
16862 _thriftId = thriftId;
16863 _fieldName = fieldName;
16864 }
16865
16866 public short getThriftFieldId() {
16867 return _thriftId;
16868 }
16869
16870 public String getFieldName() {
16871 return _fieldName;
16872 }
16873 }
16874
16875
16876
16877 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16878 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
16879 new ListMetaData(TType.LIST,
16880 new StructMetaData(TType.STRUCT, TRowResult.class))));
16881 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
16882 new FieldValueMetaData(TType.STRUCT)));
16883 }});
16884
16885 static {
16886 FieldMetaData.addStructMetaDataMap(getRows_result.class, metaDataMap);
16887 }
16888
16889 public getRows_result() {
16890 }
16891
16892 public getRows_result(
16893 List<TRowResult> success,
16894 IOError io)
16895 {
16896 this();
16897 this.success = success;
16898 this.io = io;
16899 }
16900
16901
16902
16903
16904 public getRows_result(getRows_result other) {
16905 if (other.isSetSuccess()) {
16906 List<TRowResult> __this__success = new ArrayList<TRowResult>();
16907 for (TRowResult other_element : other.success) {
16908 __this__success.add(new TRowResult(other_element));
16909 }
16910 this.success = __this__success;
16911 }
16912 if (other.isSetIo()) {
16913 this.io = new IOError(other.io);
16914 }
16915 }
16916
16917 public getRows_result deepCopy() {
16918 return new getRows_result(this);
16919 }
16920
16921 @Deprecated
16922 public getRows_result clone() {
16923 return new getRows_result(this);
16924 }
16925
16926 public int getSuccessSize() {
16927 return (this.success == null) ? 0 : this.success.size();
16928 }
16929
16930 public java.util.Iterator<TRowResult> getSuccessIterator() {
16931 return (this.success == null) ? null : this.success.iterator();
16932 }
16933
16934 public void addToSuccess(TRowResult elem) {
16935 if (this.success == null) {
16936 this.success = new ArrayList<TRowResult>();
16937 }
16938 this.success.add(elem);
16939 }
16940
16941 public List<TRowResult> getSuccess() {
16942 return this.success;
16943 }
16944
16945 public getRows_result setSuccess(List<TRowResult> success) {
16946 this.success = success;
16947 return this;
16948 }
16949
16950 public void unsetSuccess() {
16951 this.success = null;
16952 }
16953
16954
16955 public boolean isSetSuccess() {
16956 return this.success != null;
16957 }
16958
16959 public void setSuccessIsSet(boolean value) {
16960 if (!value) {
16961 this.success = null;
16962 }
16963 }
16964
16965 public IOError getIo() {
16966 return this.io;
16967 }
16968
16969 public getRows_result setIo(IOError io) {
16970 this.io = io;
16971 return this;
16972 }
16973
16974 public void unsetIo() {
16975 this.io = null;
16976 }
16977
16978
16979 public boolean isSetIo() {
16980 return this.io != null;
16981 }
16982
16983 public void setIoIsSet(boolean value) {
16984 if (!value) {
16985 this.io = null;
16986 }
16987 }
16988
16989 public void setFieldValue(_Fields field, Object value) {
16990 switch (field) {
16991 case SUCCESS:
16992 if (value == null) {
16993 unsetSuccess();
16994 } else {
16995 setSuccess((List<TRowResult>)value);
16996 }
16997 break;
16998
16999 case IO:
17000 if (value == null) {
17001 unsetIo();
17002 } else {
17003 setIo((IOError)value);
17004 }
17005 break;
17006
17007 }
17008 }
17009
17010 public void setFieldValue(int fieldID, Object value) {
17011 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17012 }
17013
17014 public Object getFieldValue(_Fields field) {
17015 switch (field) {
17016 case SUCCESS:
17017 return getSuccess();
17018
17019 case IO:
17020 return getIo();
17021
17022 }
17023 throw new IllegalStateException();
17024 }
17025
17026 public Object getFieldValue(int fieldId) {
17027 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17028 }
17029
17030
17031 public boolean isSet(_Fields field) {
17032 switch (field) {
17033 case SUCCESS:
17034 return isSetSuccess();
17035 case IO:
17036 return isSetIo();
17037 }
17038 throw new IllegalStateException();
17039 }
17040
17041 public boolean isSet(int fieldID) {
17042 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
17043 }
17044
17045 @Override
17046 public boolean equals(Object that) {
17047 if (that == null)
17048 return false;
17049 if (that instanceof getRows_result)
17050 return this.equals((getRows_result)that);
17051 return false;
17052 }
17053
17054 public boolean equals(getRows_result that) {
17055 if (that == null)
17056 return false;
17057
17058 boolean this_present_success = true && this.isSetSuccess();
17059 boolean that_present_success = true && that.isSetSuccess();
17060 if (this_present_success || that_present_success) {
17061 if (!(this_present_success && that_present_success))
17062 return false;
17063 if (!this.success.equals(that.success))
17064 return false;
17065 }
17066
17067 boolean this_present_io = true && this.isSetIo();
17068 boolean that_present_io = true && that.isSetIo();
17069 if (this_present_io || that_present_io) {
17070 if (!(this_present_io && that_present_io))
17071 return false;
17072 if (!this.io.equals(that.io))
17073 return false;
17074 }
17075
17076 return true;
17077 }
17078
17079 @Override
17080 public int hashCode() {
17081 HashCodeBuilder builder = new HashCodeBuilder();
17082
17083 boolean present_success = true && (isSetSuccess());
17084 builder.append(present_success);
17085 if (present_success)
17086 builder.append(success);
17087
17088 boolean present_io = true && (isSetIo());
17089 builder.append(present_io);
17090 if (present_io)
17091 builder.append(io);
17092
17093 return builder.toHashCode();
17094 }
17095
17096 public void read(TProtocol iprot) throws TException {
17097 TField field;
17098 iprot.readStructBegin();
17099 while (true)
17100 {
17101 field = iprot.readFieldBegin();
17102 if (field.type == TType.STOP) {
17103 break;
17104 }
17105 _Fields fieldId = _Fields.findByThriftId(field.id);
17106 if (fieldId == null) {
17107 TProtocolUtil.skip(iprot, field.type);
17108 } else {
17109 switch (fieldId) {
17110 case SUCCESS:
17111 if (field.type == TType.LIST) {
17112 {
17113 TList _list66 = iprot.readListBegin();
17114 this.success = new ArrayList<TRowResult>(_list66.size);
17115 for (int _i67 = 0; _i67 < _list66.size; ++_i67)
17116 {
17117 TRowResult _elem68;
17118 _elem68 = new TRowResult();
17119 _elem68.read(iprot);
17120 this.success.add(_elem68);
17121 }
17122 iprot.readListEnd();
17123 }
17124 } else {
17125 TProtocolUtil.skip(iprot, field.type);
17126 }
17127 break;
17128 case IO:
17129 if (field.type == TType.STRUCT) {
17130 this.io = new IOError();
17131 this.io.read(iprot);
17132 } else {
17133 TProtocolUtil.skip(iprot, field.type);
17134 }
17135 break;
17136 }
17137 iprot.readFieldEnd();
17138 }
17139 }
17140 iprot.readStructEnd();
17141
17142
17143 validate();
17144 }
17145
17146 public void write(TProtocol oprot) throws TException {
17147 oprot.writeStructBegin(STRUCT_DESC);
17148
17149 if (this.isSetSuccess()) {
17150 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
17151 {
17152 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
17153 for (TRowResult _iter69 : this.success)
17154 {
17155 _iter69.write(oprot);
17156 }
17157 oprot.writeListEnd();
17158 }
17159 oprot.writeFieldEnd();
17160 } else if (this.isSetIo()) {
17161 oprot.writeFieldBegin(IO_FIELD_DESC);
17162 this.io.write(oprot);
17163 oprot.writeFieldEnd();
17164 }
17165 oprot.writeFieldStop();
17166 oprot.writeStructEnd();
17167 }
17168
17169 @Override
17170 public String toString() {
17171 StringBuilder sb = new StringBuilder("getRows_result(");
17172 boolean first = true;
17173
17174 sb.append("success:");
17175 if (this.success == null) {
17176 sb.append("null");
17177 } else {
17178 sb.append(this.success);
17179 }
17180 first = false;
17181 if (!first) sb.append(", ");
17182 sb.append("io:");
17183 if (this.io == null) {
17184 sb.append("null");
17185 } else {
17186 sb.append(this.io);
17187 }
17188 first = false;
17189 sb.append(")");
17190 return sb.toString();
17191 }
17192
17193 public void validate() throws TException {
17194
17195 }
17196
17197 }
17198
17199 public static class getRowsWithColumns_args implements TBase<getRowsWithColumns_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsWithColumns_args> {
17200 private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumns_args");
17201
17202 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
17203 private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
17204 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
17205
17206
17207
17208
17209 public byte[] tableName;
17210
17211
17212
17213 public List<byte[]> rows;
17214
17215
17216
17217 public List<byte[]> columns;
17218
17219
17220 public enum _Fields implements TFieldIdEnum {
17221
17222
17223
17224 TABLE_NAME((short)1, "tableName"),
17225
17226
17227
17228 ROWS((short)2, "rows"),
17229
17230
17231
17232 COLUMNS((short)3, "columns");
17233
17234 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
17235 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
17236
17237 static {
17238 for (_Fields field : EnumSet.allOf(_Fields.class)) {
17239 byId.put((int)field._thriftId, field);
17240 byName.put(field.getFieldName(), field);
17241 }
17242 }
17243
17244
17245
17246
17247 public static _Fields findByThriftId(int fieldId) {
17248 return byId.get(fieldId);
17249 }
17250
17251
17252
17253
17254
17255 public static _Fields findByThriftIdOrThrow(int fieldId) {
17256 _Fields fields = findByThriftId(fieldId);
17257 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
17258 return fields;
17259 }
17260
17261
17262
17263
17264 public static _Fields findByName(String name) {
17265 return byName.get(name);
17266 }
17267
17268 private final short _thriftId;
17269 private final String _fieldName;
17270
17271 _Fields(short thriftId, String fieldName) {
17272 _thriftId = thriftId;
17273 _fieldName = fieldName;
17274 }
17275
17276 public short getThriftFieldId() {
17277 return _thriftId;
17278 }
17279
17280 public String getFieldName() {
17281 return _fieldName;
17282 }
17283 }
17284
17285
17286
17287 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
17288 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
17289 new FieldValueMetaData(TType.STRING)));
17290 put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
17291 new ListMetaData(TType.LIST,
17292 new FieldValueMetaData(TType.STRING))));
17293 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
17294 new ListMetaData(TType.LIST,
17295 new FieldValueMetaData(TType.STRING))));
17296 }});
17297
17298 static {
17299 FieldMetaData.addStructMetaDataMap(getRowsWithColumns_args.class, metaDataMap);
17300 }
17301
17302 public getRowsWithColumns_args() {
17303 }
17304
17305 public getRowsWithColumns_args(
17306 byte[] tableName,
17307 List<byte[]> rows,
17308 List<byte[]> columns)
17309 {
17310 this();
17311 this.tableName = tableName;
17312 this.rows = rows;
17313 this.columns = columns;
17314 }
17315
17316
17317
17318
17319 public getRowsWithColumns_args(getRowsWithColumns_args other) {
17320 if (other.isSetTableName()) {
17321 this.tableName = other.tableName;
17322 }
17323 if (other.isSetRows()) {
17324 List<byte[]> __this__rows = new ArrayList<byte[]>();
17325 for (byte[] other_element : other.rows) {
17326 __this__rows.add(other_element);
17327 }
17328 this.rows = __this__rows;
17329 }
17330 if (other.isSetColumns()) {
17331 List<byte[]> __this__columns = new ArrayList<byte[]>();
17332 for (byte[] other_element : other.columns) {
17333 __this__columns.add(other_element);
17334 }
17335 this.columns = __this__columns;
17336 }
17337 }
17338
17339 public getRowsWithColumns_args deepCopy() {
17340 return new getRowsWithColumns_args(this);
17341 }
17342
17343 @Deprecated
17344 public getRowsWithColumns_args clone() {
17345 return new getRowsWithColumns_args(this);
17346 }
17347
17348
17349
17350
17351 public byte[] getTableName() {
17352 return this.tableName;
17353 }
17354
17355
17356
17357
17358 public getRowsWithColumns_args setTableName(byte[] tableName) {
17359 this.tableName = tableName;
17360 return this;
17361 }
17362
17363 public void unsetTableName() {
17364 this.tableName = null;
17365 }
17366
17367
17368 public boolean isSetTableName() {
17369 return this.tableName != null;
17370 }
17371
17372 public void setTableNameIsSet(boolean value) {
17373 if (!value) {
17374 this.tableName = null;
17375 }
17376 }
17377
17378 public int getRowsSize() {
17379 return (this.rows == null) ? 0 : this.rows.size();
17380 }
17381
17382 public java.util.Iterator<byte[]> getRowsIterator() {
17383 return (this.rows == null) ? null : this.rows.iterator();
17384 }
17385
17386 public void addToRows(byte[] elem) {
17387 if (this.rows == null) {
17388 this.rows = new ArrayList<byte[]>();
17389 }
17390 this.rows.add(elem);
17391 }
17392
17393
17394
17395
17396 public List<byte[]> getRows() {
17397 return this.rows;
17398 }
17399
17400
17401
17402
17403 public getRowsWithColumns_args setRows(List<byte[]> rows) {
17404 this.rows = rows;
17405 return this;
17406 }
17407
17408 public void unsetRows() {
17409 this.rows = null;
17410 }
17411
17412
17413 public boolean isSetRows() {
17414 return this.rows != null;
17415 }
17416
17417 public void setRowsIsSet(boolean value) {
17418 if (!value) {
17419 this.rows = null;
17420 }
17421 }
17422
17423 public int getColumnsSize() {
17424 return (this.columns == null) ? 0 : this.columns.size();
17425 }
17426
17427 public java.util.Iterator<byte[]> getColumnsIterator() {
17428 return (this.columns == null) ? null : this.columns.iterator();
17429 }
17430
17431 public void addToColumns(byte[] elem) {
17432 if (this.columns == null) {
17433 this.columns = new ArrayList<byte[]>();
17434 }
17435 this.columns.add(elem);
17436 }
17437
17438
17439
17440
17441 public List<byte[]> getColumns() {
17442 return this.columns;
17443 }
17444
17445
17446
17447
17448 public getRowsWithColumns_args setColumns(List<byte[]> columns) {
17449 this.columns = columns;
17450 return this;
17451 }
17452
17453 public void unsetColumns() {
17454 this.columns = null;
17455 }
17456
17457
17458 public boolean isSetColumns() {
17459 return this.columns != null;
17460 }
17461
17462 public void setColumnsIsSet(boolean value) {
17463 if (!value) {
17464 this.columns = null;
17465 }
17466 }
17467
17468 public void setFieldValue(_Fields field, Object value) {
17469 switch (field) {
17470 case TABLE_NAME:
17471 if (value == null) {
17472 unsetTableName();
17473 } else {
17474 setTableName((byte[])value);
17475 }
17476 break;
17477
17478 case ROWS:
17479 if (value == null) {
17480 unsetRows();
17481 } else {
17482 setRows((List<byte[]>)value);
17483 }
17484 break;
17485
17486 case COLUMNS:
17487 if (value == null) {
17488 unsetColumns();
17489 } else {
17490 setColumns((List<byte[]>)value);
17491 }
17492 break;
17493
17494 }
17495 }
17496
17497 public void setFieldValue(int fieldID, Object value) {
17498 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17499 }
17500
17501 public Object getFieldValue(_Fields field) {
17502 switch (field) {
17503 case TABLE_NAME:
17504 return getTableName();
17505
17506 case ROWS:
17507 return getRows();
17508
17509 case COLUMNS:
17510 return getColumns();
17511
17512 }
17513 throw new IllegalStateException();
17514 }
17515
17516 public Object getFieldValue(int fieldId) {
17517 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17518 }
17519
17520
17521 public boolean isSet(_Fields field) {
17522 switch (field) {
17523 case TABLE_NAME:
17524 return isSetTableName();
17525 case ROWS:
17526 return isSetRows();
17527 case COLUMNS:
17528 return isSetColumns();
17529 }
17530 throw new IllegalStateException();
17531 }
17532
17533 public boolean isSet(int fieldID) {
17534 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
17535 }
17536
17537 @Override
17538 public boolean equals(Object that) {
17539 if (that == null)
17540 return false;
17541 if (that instanceof getRowsWithColumns_args)
17542 return this.equals((getRowsWithColumns_args)that);
17543 return false;
17544 }
17545
17546 public boolean equals(getRowsWithColumns_args that) {
17547 if (that == null)
17548 return false;
17549
17550 boolean this_present_tableName = true && this.isSetTableName();
17551 boolean that_present_tableName = true && that.isSetTableName();
17552 if (this_present_tableName || that_present_tableName) {
17553 if (!(this_present_tableName && that_present_tableName))
17554 return false;
17555 if (!java.util.Arrays.equals(this.tableName, that.tableName))
17556 return false;
17557 }
17558
17559 boolean this_present_rows = true && this.isSetRows();
17560 boolean that_present_rows = true && that.isSetRows();
17561 if (this_present_rows || that_present_rows) {
17562 if (!(this_present_rows && that_present_rows))
17563 return false;
17564 if (!this.rows.equals(that.rows))
17565 return false;
17566 }
17567
17568 boolean this_present_columns = true && this.isSetColumns();
17569 boolean that_present_columns = true && that.isSetColumns();
17570 if (this_present_columns || that_present_columns) {
17571 if (!(this_present_columns && that_present_columns))
17572 return false;
17573 if (!this.columns.equals(that.columns))
17574 return false;
17575 }
17576
17577 return true;
17578 }
17579
17580 @Override
17581 public int hashCode() {
17582 HashCodeBuilder builder = new HashCodeBuilder();
17583
17584 boolean present_tableName = true && (isSetTableName());
17585 builder.append(present_tableName);
17586 if (present_tableName)
17587 builder.append(tableName);
17588
17589 boolean present_rows = true && (isSetRows());
17590 builder.append(present_rows);
17591 if (present_rows)
17592 builder.append(rows);
17593
17594 boolean present_columns = true && (isSetColumns());
17595 builder.append(present_columns);
17596 if (present_columns)
17597 builder.append(columns);
17598
17599 return builder.toHashCode();
17600 }
17601
17602 public int compareTo(getRowsWithColumns_args other) {
17603 if (!getClass().equals(other.getClass())) {
17604 return getClass().getName().compareTo(other.getClass().getName());
17605 }
17606
17607 int lastComparison = 0;
17608 getRowsWithColumns_args typedOther = (getRowsWithColumns_args)other;
17609
17610 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
17611 if (lastComparison != 0) {
17612 return lastComparison;
17613 }
17614 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
17615 if (lastComparison != 0) {
17616 return lastComparison;
17617 }
17618 lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
17619 if (lastComparison != 0) {
17620 return lastComparison;
17621 }
17622 lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
17623 if (lastComparison != 0) {
17624 return lastComparison;
17625 }
17626 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
17627 if (lastComparison != 0) {
17628 return lastComparison;
17629 }
17630 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
17631 if (lastComparison != 0) {
17632 return lastComparison;
17633 }
17634 return 0;
17635 }
17636
17637 public void read(TProtocol iprot) throws TException {
17638 TField field;
17639 iprot.readStructBegin();
17640 while (true)
17641 {
17642 field = iprot.readFieldBegin();
17643 if (field.type == TType.STOP) {
17644 break;
17645 }
17646 _Fields fieldId = _Fields.findByThriftId(field.id);
17647 if (fieldId == null) {
17648 TProtocolUtil.skip(iprot, field.type);
17649 } else {
17650 switch (fieldId) {
17651 case TABLE_NAME:
17652 if (field.type == TType.STRING) {
17653 this.tableName = iprot.readBinary();
17654 } else {
17655 TProtocolUtil.skip(iprot, field.type);
17656 }
17657 break;
17658 case ROWS:
17659 if (field.type == TType.LIST) {
17660 {
17661 TList _list70 = iprot.readListBegin();
17662 this.rows = new ArrayList<byte[]>(_list70.size);
17663 for (int _i71 = 0; _i71 < _list70.size; ++_i71)
17664 {
17665 byte[] _elem72;
17666 _elem72 = iprot.readBinary();
17667 this.rows.add(_elem72);
17668 }
17669 iprot.readListEnd();
17670 }
17671 } else {
17672 TProtocolUtil.skip(iprot, field.type);
17673 }
17674 break;
17675 case COLUMNS:
17676 if (field.type == TType.LIST) {
17677 {
17678 TList _list73 = iprot.readListBegin();
17679 this.columns = new ArrayList<byte[]>(_list73.size);
17680 for (int _i74 = 0; _i74 < _list73.size; ++_i74)
17681 {
17682 byte[] _elem75;
17683 _elem75 = iprot.readBinary();
17684 this.columns.add(_elem75);
17685 }
17686 iprot.readListEnd();
17687 }
17688 } else {
17689 TProtocolUtil.skip(iprot, field.type);
17690 }
17691 break;
17692 }
17693 iprot.readFieldEnd();
17694 }
17695 }
17696 iprot.readStructEnd();
17697
17698
17699 validate();
17700 }
17701
17702 public void write(TProtocol oprot) throws TException {
17703 validate();
17704
17705 oprot.writeStructBegin(STRUCT_DESC);
17706 if (this.tableName != null) {
17707 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
17708 oprot.writeBinary(this.tableName);
17709 oprot.writeFieldEnd();
17710 }
17711 if (this.rows != null) {
17712 oprot.writeFieldBegin(ROWS_FIELD_DESC);
17713 {
17714 oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
17715 for (byte[] _iter76 : this.rows)
17716 {
17717 oprot.writeBinary(_iter76);
17718 }
17719 oprot.writeListEnd();
17720 }
17721 oprot.writeFieldEnd();
17722 }
17723 if (this.columns != null) {
17724 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
17725 {
17726 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
17727 for (byte[] _iter77 : this.columns)
17728 {
17729 oprot.writeBinary(_iter77);
17730 }
17731 oprot.writeListEnd();
17732 }
17733 oprot.writeFieldEnd();
17734 }
17735 oprot.writeFieldStop();
17736 oprot.writeStructEnd();
17737 }
17738
17739 @Override
17740 public String toString() {
17741 StringBuilder sb = new StringBuilder("getRowsWithColumns_args(");
17742 boolean first = true;
17743
17744 sb.append("tableName:");
17745 if (this.tableName == null) {
17746 sb.append("null");
17747 } else {
17748 sb.append(this.tableName);
17749 }
17750 first = false;
17751 if (!first) sb.append(", ");
17752 sb.append("rows:");
17753 if (this.rows == null) {
17754 sb.append("null");
17755 } else {
17756 sb.append(this.rows);
17757 }
17758 first = false;
17759 if (!first) sb.append(", ");
17760 sb.append("columns:");
17761 if (this.columns == null) {
17762 sb.append("null");
17763 } else {
17764 sb.append(this.columns);
17765 }
17766 first = false;
17767 sb.append(")");
17768 return sb.toString();
17769 }
17770
17771 public void validate() throws TException {
17772
17773 }
17774
17775 }
17776
17777 public static class getRowsWithColumns_result implements TBase<getRowsWithColumns_result._Fields>, java.io.Serializable, Cloneable {
17778 private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumns_result");
17779
17780 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
17781 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
17782
17783 public List<TRowResult> success;
17784 public IOError io;
17785
17786
17787 public enum _Fields implements TFieldIdEnum {
17788 SUCCESS((short)0, "success"),
17789 IO((short)1, "io");
17790
17791 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
17792 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
17793
17794 static {
17795 for (_Fields field : EnumSet.allOf(_Fields.class)) {
17796 byId.put((int)field._thriftId, field);
17797 byName.put(field.getFieldName(), field);
17798 }
17799 }
17800
17801
17802
17803
17804 public static _Fields findByThriftId(int fieldId) {
17805 return byId.get(fieldId);
17806 }
17807
17808
17809
17810
17811
17812 public static _Fields findByThriftIdOrThrow(int fieldId) {
17813 _Fields fields = findByThriftId(fieldId);
17814 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
17815 return fields;
17816 }
17817
17818
17819
17820
17821 public static _Fields findByName(String name) {
17822 return byName.get(name);
17823 }
17824
17825 private final short _thriftId;
17826 private final String _fieldName;
17827
17828 _Fields(short thriftId, String fieldName) {
17829 _thriftId = thriftId;
17830 _fieldName = fieldName;
17831 }
17832
17833 public short getThriftFieldId() {
17834 return _thriftId;
17835 }
17836
17837 public String getFieldName() {
17838 return _fieldName;
17839 }
17840 }
17841
17842
17843
17844 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
17845 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
17846 new ListMetaData(TType.LIST,
17847 new StructMetaData(TType.STRUCT, TRowResult.class))));
17848 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
17849 new FieldValueMetaData(TType.STRUCT)));
17850 }});
17851
17852 static {
17853 FieldMetaData.addStructMetaDataMap(getRowsWithColumns_result.class, metaDataMap);
17854 }
17855
17856 public getRowsWithColumns_result() {
17857 }
17858
17859 public getRowsWithColumns_result(
17860 List<TRowResult> success,
17861 IOError io)
17862 {
17863 this();
17864 this.success = success;
17865 this.io = io;
17866 }
17867
17868
17869
17870
17871 public getRowsWithColumns_result(getRowsWithColumns_result other) {
17872 if (other.isSetSuccess()) {
17873 List<TRowResult> __this__success = new ArrayList<TRowResult>();
17874 for (TRowResult other_element : other.success) {
17875 __this__success.add(new TRowResult(other_element));
17876 }
17877 this.success = __this__success;
17878 }
17879 if (other.isSetIo()) {
17880 this.io = new IOError(other.io);
17881 }
17882 }
17883
17884 public getRowsWithColumns_result deepCopy() {
17885 return new getRowsWithColumns_result(this);
17886 }
17887
17888 @Deprecated
17889 public getRowsWithColumns_result clone() {
17890 return new getRowsWithColumns_result(this);
17891 }
17892
17893 public int getSuccessSize() {
17894 return (this.success == null) ? 0 : this.success.size();
17895 }
17896
17897 public java.util.Iterator<TRowResult> getSuccessIterator() {
17898 return (this.success == null) ? null : this.success.iterator();
17899 }
17900
17901 public void addToSuccess(TRowResult elem) {
17902 if (this.success == null) {
17903 this.success = new ArrayList<TRowResult>();
17904 }
17905 this.success.add(elem);
17906 }
17907
17908 public List<TRowResult> getSuccess() {
17909 return this.success;
17910 }
17911
17912 public getRowsWithColumns_result setSuccess(List<TRowResult> success) {
17913 this.success = success;
17914 return this;
17915 }
17916
17917 public void unsetSuccess() {
17918 this.success = null;
17919 }
17920
17921
17922 public boolean isSetSuccess() {
17923 return this.success != null;
17924 }
17925
17926 public void setSuccessIsSet(boolean value) {
17927 if (!value) {
17928 this.success = null;
17929 }
17930 }
17931
17932 public IOError getIo() {
17933 return this.io;
17934 }
17935
17936 public getRowsWithColumns_result setIo(IOError io) {
17937 this.io = io;
17938 return this;
17939 }
17940
17941 public void unsetIo() {
17942 this.io = null;
17943 }
17944
17945
17946 public boolean isSetIo() {
17947 return this.io != null;
17948 }
17949
17950 public void setIoIsSet(boolean value) {
17951 if (!value) {
17952 this.io = null;
17953 }
17954 }
17955
17956 public void setFieldValue(_Fields field, Object value) {
17957 switch (field) {
17958 case SUCCESS:
17959 if (value == null) {
17960 unsetSuccess();
17961 } else {
17962 setSuccess((List<TRowResult>)value);
17963 }
17964 break;
17965
17966 case IO:
17967 if (value == null) {
17968 unsetIo();
17969 } else {
17970 setIo((IOError)value);
17971 }
17972 break;
17973
17974 }
17975 }
17976
17977 public void setFieldValue(int fieldID, Object value) {
17978 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17979 }
17980
17981 public Object getFieldValue(_Fields field) {
17982 switch (field) {
17983 case SUCCESS:
17984 return getSuccess();
17985
17986 case IO:
17987 return getIo();
17988
17989 }
17990 throw new IllegalStateException();
17991 }
17992
17993 public Object getFieldValue(int fieldId) {
17994 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17995 }
17996
17997
17998 public boolean isSet(_Fields field) {
17999 switch (field) {
18000 case SUCCESS:
18001 return isSetSuccess();
18002 case IO:
18003 return isSetIo();
18004 }
18005 throw new IllegalStateException();
18006 }
18007
18008 public boolean isSet(int fieldID) {
18009 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18010 }
18011
18012 @Override
18013 public boolean equals(Object that) {
18014 if (that == null)
18015 return false;
18016 if (that instanceof getRowsWithColumns_result)
18017 return this.equals((getRowsWithColumns_result)that);
18018 return false;
18019 }
18020
18021 public boolean equals(getRowsWithColumns_result that) {
18022 if (that == null)
18023 return false;
18024
18025 boolean this_present_success = true && this.isSetSuccess();
18026 boolean that_present_success = true && that.isSetSuccess();
18027 if (this_present_success || that_present_success) {
18028 if (!(this_present_success && that_present_success))
18029 return false;
18030 if (!this.success.equals(that.success))
18031 return false;
18032 }
18033
18034 boolean this_present_io = true && this.isSetIo();
18035 boolean that_present_io = true && that.isSetIo();
18036 if (this_present_io || that_present_io) {
18037 if (!(this_present_io && that_present_io))
18038 return false;
18039 if (!this.io.equals(that.io))
18040 return false;
18041 }
18042
18043 return true;
18044 }
18045
18046 @Override
18047 public int hashCode() {
18048 HashCodeBuilder builder = new HashCodeBuilder();
18049
18050 boolean present_success = true && (isSetSuccess());
18051 builder.append(present_success);
18052 if (present_success)
18053 builder.append(success);
18054
18055 boolean present_io = true && (isSetIo());
18056 builder.append(present_io);
18057 if (present_io)
18058 builder.append(io);
18059
18060 return builder.toHashCode();
18061 }
18062
18063 public void read(TProtocol iprot) throws TException {
18064 TField field;
18065 iprot.readStructBegin();
18066 while (true)
18067 {
18068 field = iprot.readFieldBegin();
18069 if (field.type == TType.STOP) {
18070 break;
18071 }
18072 _Fields fieldId = _Fields.findByThriftId(field.id);
18073 if (fieldId == null) {
18074 TProtocolUtil.skip(iprot, field.type);
18075 } else {
18076 switch (fieldId) {
18077 case SUCCESS:
18078 if (field.type == TType.LIST) {
18079 {
18080 TList _list78 = iprot.readListBegin();
18081 this.success = new ArrayList<TRowResult>(_list78.size);
18082 for (int _i79 = 0; _i79 < _list78.size; ++_i79)
18083 {
18084 TRowResult _elem80;
18085 _elem80 = new TRowResult();
18086 _elem80.read(iprot);
18087 this.success.add(_elem80);
18088 }
18089 iprot.readListEnd();
18090 }
18091 } else {
18092 TProtocolUtil.skip(iprot, field.type);
18093 }
18094 break;
18095 case IO:
18096 if (field.type == TType.STRUCT) {
18097 this.io = new IOError();
18098 this.io.read(iprot);
18099 } else {
18100 TProtocolUtil.skip(iprot, field.type);
18101 }
18102 break;
18103 }
18104 iprot.readFieldEnd();
18105 }
18106 }
18107 iprot.readStructEnd();
18108
18109
18110 validate();
18111 }
18112
18113 public void write(TProtocol oprot) throws TException {
18114 oprot.writeStructBegin(STRUCT_DESC);
18115
18116 if (this.isSetSuccess()) {
18117 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18118 {
18119 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
18120 for (TRowResult _iter81 : this.success)
18121 {
18122 _iter81.write(oprot);
18123 }
18124 oprot.writeListEnd();
18125 }
18126 oprot.writeFieldEnd();
18127 } else if (this.isSetIo()) {
18128 oprot.writeFieldBegin(IO_FIELD_DESC);
18129 this.io.write(oprot);
18130 oprot.writeFieldEnd();
18131 }
18132 oprot.writeFieldStop();
18133 oprot.writeStructEnd();
18134 }
18135
18136 @Override
18137 public String toString() {
18138 StringBuilder sb = new StringBuilder("getRowsWithColumns_result(");
18139 boolean first = true;
18140
18141 sb.append("success:");
18142 if (this.success == null) {
18143 sb.append("null");
18144 } else {
18145 sb.append(this.success);
18146 }
18147 first = false;
18148 if (!first) sb.append(", ");
18149 sb.append("io:");
18150 if (this.io == null) {
18151 sb.append("null");
18152 } else {
18153 sb.append(this.io);
18154 }
18155 first = false;
18156 sb.append(")");
18157 return sb.toString();
18158 }
18159
18160 public void validate() throws TException {
18161
18162 }
18163
18164 }
18165
18166 public static class getRowsTs_args implements TBase<getRowsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsTs_args> {
18167 private static final TStruct STRUCT_DESC = new TStruct("getRowsTs_args");
18168
18169 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
18170 private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
18171 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
18172
18173
18174
18175
18176 public byte[] tableName;
18177
18178
18179
18180 public List<byte[]> rows;
18181
18182
18183
18184 public long timestamp;
18185
18186
18187 public enum _Fields implements TFieldIdEnum {
18188
18189
18190
18191 TABLE_NAME((short)1, "tableName"),
18192
18193
18194
18195 ROWS((short)2, "rows"),
18196
18197
18198
18199 TIMESTAMP((short)3, "timestamp");
18200
18201 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18202 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18203
18204 static {
18205 for (_Fields field : EnumSet.allOf(_Fields.class)) {
18206 byId.put((int)field._thriftId, field);
18207 byName.put(field.getFieldName(), field);
18208 }
18209 }
18210
18211
18212
18213
18214 public static _Fields findByThriftId(int fieldId) {
18215 return byId.get(fieldId);
18216 }
18217
18218
18219
18220
18221
18222 public static _Fields findByThriftIdOrThrow(int fieldId) {
18223 _Fields fields = findByThriftId(fieldId);
18224 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18225 return fields;
18226 }
18227
18228
18229
18230
18231 public static _Fields findByName(String name) {
18232 return byName.get(name);
18233 }
18234
18235 private final short _thriftId;
18236 private final String _fieldName;
18237
18238 _Fields(short thriftId, String fieldName) {
18239 _thriftId = thriftId;
18240 _fieldName = fieldName;
18241 }
18242
18243 public short getThriftFieldId() {
18244 return _thriftId;
18245 }
18246
18247 public String getFieldName() {
18248 return _fieldName;
18249 }
18250 }
18251
18252
18253 private static final int __TIMESTAMP_ISSET_ID = 0;
18254 private BitSet __isset_bit_vector = new BitSet(1);
18255
18256 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18257 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
18258 new FieldValueMetaData(TType.STRING)));
18259 put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
18260 new ListMetaData(TType.LIST,
18261 new FieldValueMetaData(TType.STRING))));
18262 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
18263 new FieldValueMetaData(TType.I64)));
18264 }});
18265
18266 static {
18267 FieldMetaData.addStructMetaDataMap(getRowsTs_args.class, metaDataMap);
18268 }
18269
18270 public getRowsTs_args() {
18271 }
18272
18273 public getRowsTs_args(
18274 byte[] tableName,
18275 List<byte[]> rows,
18276 long timestamp)
18277 {
18278 this();
18279 this.tableName = tableName;
18280 this.rows = rows;
18281 this.timestamp = timestamp;
18282 setTimestampIsSet(true);
18283 }
18284
18285
18286
18287
18288 public getRowsTs_args(getRowsTs_args other) {
18289 __isset_bit_vector.clear();
18290 __isset_bit_vector.or(other.__isset_bit_vector);
18291 if (other.isSetTableName()) {
18292 this.tableName = other.tableName;
18293 }
18294 if (other.isSetRows()) {
18295 List<byte[]> __this__rows = new ArrayList<byte[]>();
18296 for (byte[] other_element : other.rows) {
18297 __this__rows.add(other_element);
18298 }
18299 this.rows = __this__rows;
18300 }
18301 this.timestamp = other.timestamp;
18302 }
18303
18304 public getRowsTs_args deepCopy() {
18305 return new getRowsTs_args(this);
18306 }
18307
18308 @Deprecated
18309 public getRowsTs_args clone() {
18310 return new getRowsTs_args(this);
18311 }
18312
18313
18314
18315
18316 public byte[] getTableName() {
18317 return this.tableName;
18318 }
18319
18320
18321
18322
18323 public getRowsTs_args setTableName(byte[] tableName) {
18324 this.tableName = tableName;
18325 return this;
18326 }
18327
18328 public void unsetTableName() {
18329 this.tableName = null;
18330 }
18331
18332
18333 public boolean isSetTableName() {
18334 return this.tableName != null;
18335 }
18336
18337 public void setTableNameIsSet(boolean value) {
18338 if (!value) {
18339 this.tableName = null;
18340 }
18341 }
18342
18343 public int getRowsSize() {
18344 return (this.rows == null) ? 0 : this.rows.size();
18345 }
18346
18347 public java.util.Iterator<byte[]> getRowsIterator() {
18348 return (this.rows == null) ? null : this.rows.iterator();
18349 }
18350
18351 public void addToRows(byte[] elem) {
18352 if (this.rows == null) {
18353 this.rows = new ArrayList<byte[]>();
18354 }
18355 this.rows.add(elem);
18356 }
18357
18358
18359
18360
18361 public List<byte[]> getRows() {
18362 return this.rows;
18363 }
18364
18365
18366
18367
18368 public getRowsTs_args setRows(List<byte[]> rows) {
18369 this.rows = rows;
18370 return this;
18371 }
18372
18373 public void unsetRows() {
18374 this.rows = null;
18375 }
18376
18377
18378 public boolean isSetRows() {
18379 return this.rows != null;
18380 }
18381
18382 public void setRowsIsSet(boolean value) {
18383 if (!value) {
18384 this.rows = null;
18385 }
18386 }
18387
18388
18389
18390
18391 public long getTimestamp() {
18392 return this.timestamp;
18393 }
18394
18395
18396
18397
18398 public getRowsTs_args setTimestamp(long timestamp) {
18399 this.timestamp = timestamp;
18400 setTimestampIsSet(true);
18401 return this;
18402 }
18403
18404 public void unsetTimestamp() {
18405 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
18406 }
18407
18408
18409 public boolean isSetTimestamp() {
18410 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
18411 }
18412
18413 public void setTimestampIsSet(boolean value) {
18414 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
18415 }
18416
18417 public void setFieldValue(_Fields field, Object value) {
18418 switch (field) {
18419 case TABLE_NAME:
18420 if (value == null) {
18421 unsetTableName();
18422 } else {
18423 setTableName((byte[])value);
18424 }
18425 break;
18426
18427 case ROWS:
18428 if (value == null) {
18429 unsetRows();
18430 } else {
18431 setRows((List<byte[]>)value);
18432 }
18433 break;
18434
18435 case TIMESTAMP:
18436 if (value == null) {
18437 unsetTimestamp();
18438 } else {
18439 setTimestamp((Long)value);
18440 }
18441 break;
18442
18443 }
18444 }
18445
18446 public void setFieldValue(int fieldID, Object value) {
18447 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
18448 }
18449
18450 public Object getFieldValue(_Fields field) {
18451 switch (field) {
18452 case TABLE_NAME:
18453 return getTableName();
18454
18455 case ROWS:
18456 return getRows();
18457
18458 case TIMESTAMP:
18459 return new Long(getTimestamp());
18460
18461 }
18462 throw new IllegalStateException();
18463 }
18464
18465 public Object getFieldValue(int fieldId) {
18466 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
18467 }
18468
18469
18470 public boolean isSet(_Fields field) {
18471 switch (field) {
18472 case TABLE_NAME:
18473 return isSetTableName();
18474 case ROWS:
18475 return isSetRows();
18476 case TIMESTAMP:
18477 return isSetTimestamp();
18478 }
18479 throw new IllegalStateException();
18480 }
18481
18482 public boolean isSet(int fieldID) {
18483 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18484 }
18485
18486 @Override
18487 public boolean equals(Object that) {
18488 if (that == null)
18489 return false;
18490 if (that instanceof getRowsTs_args)
18491 return this.equals((getRowsTs_args)that);
18492 return false;
18493 }
18494
18495 public boolean equals(getRowsTs_args that) {
18496 if (that == null)
18497 return false;
18498
18499 boolean this_present_tableName = true && this.isSetTableName();
18500 boolean that_present_tableName = true && that.isSetTableName();
18501 if (this_present_tableName || that_present_tableName) {
18502 if (!(this_present_tableName && that_present_tableName))
18503 return false;
18504 if (!java.util.Arrays.equals(this.tableName, that.tableName))
18505 return false;
18506 }
18507
18508 boolean this_present_rows = true && this.isSetRows();
18509 boolean that_present_rows = true && that.isSetRows();
18510 if (this_present_rows || that_present_rows) {
18511 if (!(this_present_rows && that_present_rows))
18512 return false;
18513 if (!this.rows.equals(that.rows))
18514 return false;
18515 }
18516
18517 boolean this_present_timestamp = true;
18518 boolean that_present_timestamp = true;
18519 if (this_present_timestamp || that_present_timestamp) {
18520 if (!(this_present_timestamp && that_present_timestamp))
18521 return false;
18522 if (this.timestamp != that.timestamp)
18523 return false;
18524 }
18525
18526 return true;
18527 }
18528
18529 @Override
18530 public int hashCode() {
18531 HashCodeBuilder builder = new HashCodeBuilder();
18532
18533 boolean present_tableName = true && (isSetTableName());
18534 builder.append(present_tableName);
18535 if (present_tableName)
18536 builder.append(tableName);
18537
18538 boolean present_rows = true && (isSetRows());
18539 builder.append(present_rows);
18540 if (present_rows)
18541 builder.append(rows);
18542
18543 boolean present_timestamp = true;
18544 builder.append(present_timestamp);
18545 if (present_timestamp)
18546 builder.append(timestamp);
18547
18548 return builder.toHashCode();
18549 }
18550
18551 public int compareTo(getRowsTs_args other) {
18552 if (!getClass().equals(other.getClass())) {
18553 return getClass().getName().compareTo(other.getClass().getName());
18554 }
18555
18556 int lastComparison = 0;
18557 getRowsTs_args typedOther = (getRowsTs_args)other;
18558
18559 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
18560 if (lastComparison != 0) {
18561 return lastComparison;
18562 }
18563 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
18564 if (lastComparison != 0) {
18565 return lastComparison;
18566 }
18567 lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
18568 if (lastComparison != 0) {
18569 return lastComparison;
18570 }
18571 lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
18572 if (lastComparison != 0) {
18573 return lastComparison;
18574 }
18575 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
18576 if (lastComparison != 0) {
18577 return lastComparison;
18578 }
18579 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
18580 if (lastComparison != 0) {
18581 return lastComparison;
18582 }
18583 return 0;
18584 }
18585
18586 public void read(TProtocol iprot) throws TException {
18587 TField field;
18588 iprot.readStructBegin();
18589 while (true)
18590 {
18591 field = iprot.readFieldBegin();
18592 if (field.type == TType.STOP) {
18593 break;
18594 }
18595 _Fields fieldId = _Fields.findByThriftId(field.id);
18596 if (fieldId == null) {
18597 TProtocolUtil.skip(iprot, field.type);
18598 } else {
18599 switch (fieldId) {
18600 case TABLE_NAME:
18601 if (field.type == TType.STRING) {
18602 this.tableName = iprot.readBinary();
18603 } else {
18604 TProtocolUtil.skip(iprot, field.type);
18605 }
18606 break;
18607 case ROWS:
18608 if (field.type == TType.LIST) {
18609 {
18610 TList _list82 = iprot.readListBegin();
18611 this.rows = new ArrayList<byte[]>(_list82.size);
18612 for (int _i83 = 0; _i83 < _list82.size; ++_i83)
18613 {
18614 byte[] _elem84;
18615 _elem84 = iprot.readBinary();
18616 this.rows.add(_elem84);
18617 }
18618 iprot.readListEnd();
18619 }
18620 } else {
18621 TProtocolUtil.skip(iprot, field.type);
18622 }
18623 break;
18624 case TIMESTAMP:
18625 if (field.type == TType.I64) {
18626 this.timestamp = iprot.readI64();
18627 setTimestampIsSet(true);
18628 } else {
18629 TProtocolUtil.skip(iprot, field.type);
18630 }
18631 break;
18632 }
18633 iprot.readFieldEnd();
18634 }
18635 }
18636 iprot.readStructEnd();
18637
18638
18639 validate();
18640 }
18641
18642 public void write(TProtocol oprot) throws TException {
18643 validate();
18644
18645 oprot.writeStructBegin(STRUCT_DESC);
18646 if (this.tableName != null) {
18647 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
18648 oprot.writeBinary(this.tableName);
18649 oprot.writeFieldEnd();
18650 }
18651 if (this.rows != null) {
18652 oprot.writeFieldBegin(ROWS_FIELD_DESC);
18653 {
18654 oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
18655 for (byte[] _iter85 : this.rows)
18656 {
18657 oprot.writeBinary(_iter85);
18658 }
18659 oprot.writeListEnd();
18660 }
18661 oprot.writeFieldEnd();
18662 }
18663 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
18664 oprot.writeI64(this.timestamp);
18665 oprot.writeFieldEnd();
18666 oprot.writeFieldStop();
18667 oprot.writeStructEnd();
18668 }
18669
18670 @Override
18671 public String toString() {
18672 StringBuilder sb = new StringBuilder("getRowsTs_args(");
18673 boolean first = true;
18674
18675 sb.append("tableName:");
18676 if (this.tableName == null) {
18677 sb.append("null");
18678 } else {
18679 sb.append(this.tableName);
18680 }
18681 first = false;
18682 if (!first) sb.append(", ");
18683 sb.append("rows:");
18684 if (this.rows == null) {
18685 sb.append("null");
18686 } else {
18687 sb.append(this.rows);
18688 }
18689 first = false;
18690 if (!first) sb.append(", ");
18691 sb.append("timestamp:");
18692 sb.append(this.timestamp);
18693 first = false;
18694 sb.append(")");
18695 return sb.toString();
18696 }
18697
18698 public void validate() throws TException {
18699
18700 }
18701
18702 }
18703
18704 public static class getRowsTs_result implements TBase<getRowsTs_result._Fields>, java.io.Serializable, Cloneable {
18705 private static final TStruct STRUCT_DESC = new TStruct("getRowsTs_result");
18706
18707 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
18708 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
18709
18710 public List<TRowResult> success;
18711 public IOError io;
18712
18713
18714 public enum _Fields implements TFieldIdEnum {
18715 SUCCESS((short)0, "success"),
18716 IO((short)1, "io");
18717
18718 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18719 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18720
18721 static {
18722 for (_Fields field : EnumSet.allOf(_Fields.class)) {
18723 byId.put((int)field._thriftId, field);
18724 byName.put(field.getFieldName(), field);
18725 }
18726 }
18727
18728
18729
18730
18731 public static _Fields findByThriftId(int fieldId) {
18732 return byId.get(fieldId);
18733 }
18734
18735
18736
18737
18738
18739 public static _Fields findByThriftIdOrThrow(int fieldId) {
18740 _Fields fields = findByThriftId(fieldId);
18741 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18742 return fields;
18743 }
18744
18745
18746
18747
18748 public static _Fields findByName(String name) {
18749 return byName.get(name);
18750 }
18751
18752 private final short _thriftId;
18753 private final String _fieldName;
18754
18755 _Fields(short thriftId, String fieldName) {
18756 _thriftId = thriftId;
18757 _fieldName = fieldName;
18758 }
18759
18760 public short getThriftFieldId() {
18761 return _thriftId;
18762 }
18763
18764 public String getFieldName() {
18765 return _fieldName;
18766 }
18767 }
18768
18769
18770
18771 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18772 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
18773 new ListMetaData(TType.LIST,
18774 new StructMetaData(TType.STRUCT, TRowResult.class))));
18775 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
18776 new FieldValueMetaData(TType.STRUCT)));
18777 }});
18778
18779 static {
18780 FieldMetaData.addStructMetaDataMap(getRowsTs_result.class, metaDataMap);
18781 }
18782
18783 public getRowsTs_result() {
18784 }
18785
18786 public getRowsTs_result(
18787 List<TRowResult> success,
18788 IOError io)
18789 {
18790 this();
18791 this.success = success;
18792 this.io = io;
18793 }
18794
18795
18796
18797
18798 public getRowsTs_result(getRowsTs_result other) {
18799 if (other.isSetSuccess()) {
18800 List<TRowResult> __this__success = new ArrayList<TRowResult>();
18801 for (TRowResult other_element : other.success) {
18802 __this__success.add(new TRowResult(other_element));
18803 }
18804 this.success = __this__success;
18805 }
18806 if (other.isSetIo()) {
18807 this.io = new IOError(other.io);
18808 }
18809 }
18810
18811 public getRowsTs_result deepCopy() {
18812 return new getRowsTs_result(this);
18813 }
18814
18815 @Deprecated
18816 public getRowsTs_result clone() {
18817 return new getRowsTs_result(this);
18818 }
18819
18820 public int getSuccessSize() {
18821 return (this.success == null) ? 0 : this.success.size();
18822 }
18823
18824 public java.util.Iterator<TRowResult> getSuccessIterator() {
18825 return (this.success == null) ? null : this.success.iterator();
18826 }
18827
18828 public void addToSuccess(TRowResult elem) {
18829 if (this.success == null) {
18830 this.success = new ArrayList<TRowResult>();
18831 }
18832 this.success.add(elem);
18833 }
18834
18835 public List<TRowResult> getSuccess() {
18836 return this.success;
18837 }
18838
18839 public getRowsTs_result setSuccess(List<TRowResult> success) {
18840 this.success = success;
18841 return this;
18842 }
18843
18844 public void unsetSuccess() {
18845 this.success = null;
18846 }
18847
18848
18849 public boolean isSetSuccess() {
18850 return this.success != null;
18851 }
18852
18853 public void setSuccessIsSet(boolean value) {
18854 if (!value) {
18855 this.success = null;
18856 }
18857 }
18858
18859 public IOError getIo() {
18860 return this.io;
18861 }
18862
18863 public getRowsTs_result setIo(IOError io) {
18864 this.io = io;
18865 return this;
18866 }
18867
18868 public void unsetIo() {
18869 this.io = null;
18870 }
18871
18872
18873 public boolean isSetIo() {
18874 return this.io != null;
18875 }
18876
18877 public void setIoIsSet(boolean value) {
18878 if (!value) {
18879 this.io = null;
18880 }
18881 }
18882
18883 public void setFieldValue(_Fields field, Object value) {
18884 switch (field) {
18885 case SUCCESS:
18886 if (value == null) {
18887 unsetSuccess();
18888 } else {
18889 setSuccess((List<TRowResult>)value);
18890 }
18891 break;
18892
18893 case IO:
18894 if (value == null) {
18895 unsetIo();
18896 } else {
18897 setIo((IOError)value);
18898 }
18899 break;
18900
18901 }
18902 }
18903
18904 public void setFieldValue(int fieldID, Object value) {
18905 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
18906 }
18907
18908 public Object getFieldValue(_Fields field) {
18909 switch (field) {
18910 case SUCCESS:
18911 return getSuccess();
18912
18913 case IO:
18914 return getIo();
18915
18916 }
18917 throw new IllegalStateException();
18918 }
18919
18920 public Object getFieldValue(int fieldId) {
18921 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
18922 }
18923
18924
18925 public boolean isSet(_Fields field) {
18926 switch (field) {
18927 case SUCCESS:
18928 return isSetSuccess();
18929 case IO:
18930 return isSetIo();
18931 }
18932 throw new IllegalStateException();
18933 }
18934
18935 public boolean isSet(int fieldID) {
18936 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18937 }
18938
18939 @Override
18940 public boolean equals(Object that) {
18941 if (that == null)
18942 return false;
18943 if (that instanceof getRowsTs_result)
18944 return this.equals((getRowsTs_result)that);
18945 return false;
18946 }
18947
18948 public boolean equals(getRowsTs_result that) {
18949 if (that == null)
18950 return false;
18951
18952 boolean this_present_success = true && this.isSetSuccess();
18953 boolean that_present_success = true && that.isSetSuccess();
18954 if (this_present_success || that_present_success) {
18955 if (!(this_present_success && that_present_success))
18956 return false;
18957 if (!this.success.equals(that.success))
18958 return false;
18959 }
18960
18961 boolean this_present_io = true && this.isSetIo();
18962 boolean that_present_io = true && that.isSetIo();
18963 if (this_present_io || that_present_io) {
18964 if (!(this_present_io && that_present_io))
18965 return false;
18966 if (!this.io.equals(that.io))
18967 return false;
18968 }
18969
18970 return true;
18971 }
18972
18973 @Override
18974 public int hashCode() {
18975 HashCodeBuilder builder = new HashCodeBuilder();
18976
18977 boolean present_success = true && (isSetSuccess());
18978 builder.append(present_success);
18979 if (present_success)
18980 builder.append(success);
18981
18982 boolean present_io = true && (isSetIo());
18983 builder.append(present_io);
18984 if (present_io)
18985 builder.append(io);
18986
18987 return builder.toHashCode();
18988 }
18989
18990 public void read(TProtocol iprot) throws TException {
18991 TField field;
18992 iprot.readStructBegin();
18993 while (true)
18994 {
18995 field = iprot.readFieldBegin();
18996 if (field.type == TType.STOP) {
18997 break;
18998 }
18999 _Fields fieldId = _Fields.findByThriftId(field.id);
19000 if (fieldId == null) {
19001 TProtocolUtil.skip(iprot, field.type);
19002 } else {
19003 switch (fieldId) {
19004 case SUCCESS:
19005 if (field.type == TType.LIST) {
19006 {
19007 TList _list86 = iprot.readListBegin();
19008 this.success = new ArrayList<TRowResult>(_list86.size);
19009 for (int _i87 = 0; _i87 < _list86.size; ++_i87)
19010 {
19011 TRowResult _elem88;
19012 _elem88 = new TRowResult();
19013 _elem88.read(iprot);
19014 this.success.add(_elem88);
19015 }
19016 iprot.readListEnd();
19017 }
19018 } else {
19019 TProtocolUtil.skip(iprot, field.type);
19020 }
19021 break;
19022 case IO:
19023 if (field.type == TType.STRUCT) {
19024 this.io = new IOError();
19025 this.io.read(iprot);
19026 } else {
19027 TProtocolUtil.skip(iprot, field.type);
19028 }
19029 break;
19030 }
19031 iprot.readFieldEnd();
19032 }
19033 }
19034 iprot.readStructEnd();
19035
19036
19037 validate();
19038 }
19039
19040 public void write(TProtocol oprot) throws TException {
19041 oprot.writeStructBegin(STRUCT_DESC);
19042
19043 if (this.isSetSuccess()) {
19044 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
19045 {
19046 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
19047 for (TRowResult _iter89 : this.success)
19048 {
19049 _iter89.write(oprot);
19050 }
19051 oprot.writeListEnd();
19052 }
19053 oprot.writeFieldEnd();
19054 } else if (this.isSetIo()) {
19055 oprot.writeFieldBegin(IO_FIELD_DESC);
19056 this.io.write(oprot);
19057 oprot.writeFieldEnd();
19058 }
19059 oprot.writeFieldStop();
19060 oprot.writeStructEnd();
19061 }
19062
19063 @Override
19064 public String toString() {
19065 StringBuilder sb = new StringBuilder("getRowsTs_result(");
19066 boolean first = true;
19067
19068 sb.append("success:");
19069 if (this.success == null) {
19070 sb.append("null");
19071 } else {
19072 sb.append(this.success);
19073 }
19074 first = false;
19075 if (!first) sb.append(", ");
19076 sb.append("io:");
19077 if (this.io == null) {
19078 sb.append("null");
19079 } else {
19080 sb.append(this.io);
19081 }
19082 first = false;
19083 sb.append(")");
19084 return sb.toString();
19085 }
19086
19087 public void validate() throws TException {
19088
19089 }
19090
19091 }
19092
19093 public static class getRowsWithColumnsTs_args implements TBase<getRowsWithColumnsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsWithColumnsTs_args> {
19094 private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumnsTs_args");
19095
19096 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
19097 private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
19098 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
19099 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
19100
19101
19102
19103
19104 public byte[] tableName;
19105
19106
19107
19108 public List<byte[]> rows;
19109
19110
19111
19112 public List<byte[]> columns;
19113 public long timestamp;
19114
19115
19116 public enum _Fields implements TFieldIdEnum {
19117
19118
19119
19120 TABLE_NAME((short)1, "tableName"),
19121
19122
19123
19124 ROWS((short)2, "rows"),
19125
19126
19127
19128 COLUMNS((short)3, "columns"),
19129 TIMESTAMP((short)4, "timestamp");
19130
19131 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
19132 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
19133
19134 static {
19135 for (_Fields field : EnumSet.allOf(_Fields.class)) {
19136 byId.put((int)field._thriftId, field);
19137 byName.put(field.getFieldName(), field);
19138 }
19139 }
19140
19141
19142
19143
19144 public static _Fields findByThriftId(int fieldId) {
19145 return byId.get(fieldId);
19146 }
19147
19148
19149
19150
19151
19152 public static _Fields findByThriftIdOrThrow(int fieldId) {
19153 _Fields fields = findByThriftId(fieldId);
19154 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
19155 return fields;
19156 }
19157
19158
19159
19160
19161 public static _Fields findByName(String name) {
19162 return byName.get(name);
19163 }
19164
19165 private final short _thriftId;
19166 private final String _fieldName;
19167
19168 _Fields(short thriftId, String fieldName) {
19169 _thriftId = thriftId;
19170 _fieldName = fieldName;
19171 }
19172
19173 public short getThriftFieldId() {
19174 return _thriftId;
19175 }
19176
19177 public String getFieldName() {
19178 return _fieldName;
19179 }
19180 }
19181
19182
19183 private static final int __TIMESTAMP_ISSET_ID = 0;
19184 private BitSet __isset_bit_vector = new BitSet(1);
19185
19186 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
19187 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
19188 new FieldValueMetaData(TType.STRING)));
19189 put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
19190 new ListMetaData(TType.LIST,
19191 new FieldValueMetaData(TType.STRING))));
19192 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
19193 new ListMetaData(TType.LIST,
19194 new FieldValueMetaData(TType.STRING))));
19195 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
19196 new FieldValueMetaData(TType.I64)));
19197 }});
19198
19199 static {
19200 FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_args.class, metaDataMap);
19201 }
19202
19203 public getRowsWithColumnsTs_args() {
19204 }
19205
19206 public getRowsWithColumnsTs_args(
19207 byte[] tableName,
19208 List<byte[]> rows,
19209 List<byte[]> columns,
19210 long timestamp)
19211 {
19212 this();
19213 this.tableName = tableName;
19214 this.rows = rows;
19215 this.columns = columns;
19216 this.timestamp = timestamp;
19217 setTimestampIsSet(true);
19218 }
19219
19220
19221
19222
19223 public getRowsWithColumnsTs_args(getRowsWithColumnsTs_args other) {
19224 __isset_bit_vector.clear();
19225 __isset_bit_vector.or(other.__isset_bit_vector);
19226 if (other.isSetTableName()) {
19227 this.tableName = other.tableName;
19228 }
19229 if (other.isSetRows()) {
19230 List<byte[]> __this__rows = new ArrayList<byte[]>();
19231 for (byte[] other_element : other.rows) {
19232 __this__rows.add(other_element);
19233 }
19234 this.rows = __this__rows;
19235 }
19236 if (other.isSetColumns()) {
19237 List<byte[]> __this__columns = new ArrayList<byte[]>();
19238 for (byte[] other_element : other.columns) {
19239 __this__columns.add(other_element);
19240 }
19241 this.columns = __this__columns;
19242 }
19243 this.timestamp = other.timestamp;
19244 }
19245
19246 public getRowsWithColumnsTs_args deepCopy() {
19247 return new getRowsWithColumnsTs_args(this);
19248 }
19249
19250 @Deprecated
19251 public getRowsWithColumnsTs_args clone() {
19252 return new getRowsWithColumnsTs_args(this);
19253 }
19254
19255
19256
19257
19258 public byte[] getTableName() {
19259 return this.tableName;
19260 }
19261
19262
19263
19264
19265 public getRowsWithColumnsTs_args setTableName(byte[] tableName) {
19266 this.tableName = tableName;
19267 return this;
19268 }
19269
19270 public void unsetTableName() {
19271 this.tableName = null;
19272 }
19273
19274
19275 public boolean isSetTableName() {
19276 return this.tableName != null;
19277 }
19278
19279 public void setTableNameIsSet(boolean value) {
19280 if (!value) {
19281 this.tableName = null;
19282 }
19283 }
19284
19285 public int getRowsSize() {
19286 return (this.rows == null) ? 0 : this.rows.size();
19287 }
19288
19289 public java.util.Iterator<byte[]> getRowsIterator() {
19290 return (this.rows == null) ? null : this.rows.iterator();
19291 }
19292
19293 public void addToRows(byte[] elem) {
19294 if (this.rows == null) {
19295 this.rows = new ArrayList<byte[]>();
19296 }
19297 this.rows.add(elem);
19298 }
19299
19300
19301
19302
19303 public List<byte[]> getRows() {
19304 return this.rows;
19305 }
19306
19307
19308
19309
19310 public getRowsWithColumnsTs_args setRows(List<byte[]> rows) {
19311 this.rows = rows;
19312 return this;
19313 }
19314
19315 public void unsetRows() {
19316 this.rows = null;
19317 }
19318
19319
19320 public boolean isSetRows() {
19321 return this.rows != null;
19322 }
19323
19324 public void setRowsIsSet(boolean value) {
19325 if (!value) {
19326 this.rows = null;
19327 }
19328 }
19329
19330 public int getColumnsSize() {
19331 return (this.columns == null) ? 0 : this.columns.size();
19332 }
19333
19334 public java.util.Iterator<byte[]> getColumnsIterator() {
19335 return (this.columns == null) ? null : this.columns.iterator();
19336 }
19337
19338 public void addToColumns(byte[] elem) {
19339 if (this.columns == null) {
19340 this.columns = new ArrayList<byte[]>();
19341 }
19342 this.columns.add(elem);
19343 }
19344
19345
19346
19347
19348 public List<byte[]> getColumns() {
19349 return this.columns;
19350 }
19351
19352
19353
19354
19355 public getRowsWithColumnsTs_args setColumns(List<byte[]> columns) {
19356 this.columns = columns;
19357 return this;
19358 }
19359
19360 public void unsetColumns() {
19361 this.columns = null;
19362 }
19363
19364
19365 public boolean isSetColumns() {
19366 return this.columns != null;
19367 }
19368
19369 public void setColumnsIsSet(boolean value) {
19370 if (!value) {
19371 this.columns = null;
19372 }
19373 }
19374
19375 public long getTimestamp() {
19376 return this.timestamp;
19377 }
19378
19379 public getRowsWithColumnsTs_args setTimestamp(long timestamp) {
19380 this.timestamp = timestamp;
19381 setTimestampIsSet(true);
19382 return this;
19383 }
19384
19385 public void unsetTimestamp() {
19386 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
19387 }
19388
19389
19390 public boolean isSetTimestamp() {
19391 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
19392 }
19393
19394 public void setTimestampIsSet(boolean value) {
19395 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
19396 }
19397
19398 public void setFieldValue(_Fields field, Object value) {
19399 switch (field) {
19400 case TABLE_NAME:
19401 if (value == null) {
19402 unsetTableName();
19403 } else {
19404 setTableName((byte[])value);
19405 }
19406 break;
19407
19408 case ROWS:
19409 if (value == null) {
19410 unsetRows();
19411 } else {
19412 setRows((List<byte[]>)value);
19413 }
19414 break;
19415
19416 case COLUMNS:
19417 if (value == null) {
19418 unsetColumns();
19419 } else {
19420 setColumns((List<byte[]>)value);
19421 }
19422 break;
19423
19424 case TIMESTAMP:
19425 if (value == null) {
19426 unsetTimestamp();
19427 } else {
19428 setTimestamp((Long)value);
19429 }
19430 break;
19431
19432 }
19433 }
19434
19435 public void setFieldValue(int fieldID, Object value) {
19436 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
19437 }
19438
19439 public Object getFieldValue(_Fields field) {
19440 switch (field) {
19441 case TABLE_NAME:
19442 return getTableName();
19443
19444 case ROWS:
19445 return getRows();
19446
19447 case COLUMNS:
19448 return getColumns();
19449
19450 case TIMESTAMP:
19451 return new Long(getTimestamp());
19452
19453 }
19454 throw new IllegalStateException();
19455 }
19456
19457 public Object getFieldValue(int fieldId) {
19458 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
19459 }
19460
19461
19462 public boolean isSet(_Fields field) {
19463 switch (field) {
19464 case TABLE_NAME:
19465 return isSetTableName();
19466 case ROWS:
19467 return isSetRows();
19468 case COLUMNS:
19469 return isSetColumns();
19470 case TIMESTAMP:
19471 return isSetTimestamp();
19472 }
19473 throw new IllegalStateException();
19474 }
19475
19476 public boolean isSet(int fieldID) {
19477 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
19478 }
19479
19480 @Override
19481 public boolean equals(Object that) {
19482 if (that == null)
19483 return false;
19484 if (that instanceof getRowsWithColumnsTs_args)
19485 return this.equals((getRowsWithColumnsTs_args)that);
19486 return false;
19487 }
19488
19489 public boolean equals(getRowsWithColumnsTs_args that) {
19490 if (that == null)
19491 return false;
19492
19493 boolean this_present_tableName = true && this.isSetTableName();
19494 boolean that_present_tableName = true && that.isSetTableName();
19495 if (this_present_tableName || that_present_tableName) {
19496 if (!(this_present_tableName && that_present_tableName))
19497 return false;
19498 if (!java.util.Arrays.equals(this.tableName, that.tableName))
19499 return false;
19500 }
19501
19502 boolean this_present_rows = true && this.isSetRows();
19503 boolean that_present_rows = true && that.isSetRows();
19504 if (this_present_rows || that_present_rows) {
19505 if (!(this_present_rows && that_present_rows))
19506 return false;
19507 if (!this.rows.equals(that.rows))
19508 return false;
19509 }
19510
19511 boolean this_present_columns = true && this.isSetColumns();
19512 boolean that_present_columns = true && that.isSetColumns();
19513 if (this_present_columns || that_present_columns) {
19514 if (!(this_present_columns && that_present_columns))
19515 return false;
19516 if (!this.columns.equals(that.columns))
19517 return false;
19518 }
19519
19520 boolean this_present_timestamp = true;
19521 boolean that_present_timestamp = true;
19522 if (this_present_timestamp || that_present_timestamp) {
19523 if (!(this_present_timestamp && that_present_timestamp))
19524 return false;
19525 if (this.timestamp != that.timestamp)
19526 return false;
19527 }
19528
19529 return true;
19530 }
19531
19532 @Override
19533 public int hashCode() {
19534 HashCodeBuilder builder = new HashCodeBuilder();
19535
19536 boolean present_tableName = true && (isSetTableName());
19537 builder.append(present_tableName);
19538 if (present_tableName)
19539 builder.append(tableName);
19540
19541 boolean present_rows = true && (isSetRows());
19542 builder.append(present_rows);
19543 if (present_rows)
19544 builder.append(rows);
19545
19546 boolean present_columns = true && (isSetColumns());
19547 builder.append(present_columns);
19548 if (present_columns)
19549 builder.append(columns);
19550
19551 boolean present_timestamp = true;
19552 builder.append(present_timestamp);
19553 if (present_timestamp)
19554 builder.append(timestamp);
19555
19556 return builder.toHashCode();
19557 }
19558
19559 public int compareTo(getRowsWithColumnsTs_args other) {
19560 if (!getClass().equals(other.getClass())) {
19561 return getClass().getName().compareTo(other.getClass().getName());
19562 }
19563
19564 int lastComparison = 0;
19565 getRowsWithColumnsTs_args typedOther = (getRowsWithColumnsTs_args)other;
19566
19567 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
19568 if (lastComparison != 0) {
19569 return lastComparison;
19570 }
19571 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
19572 if (lastComparison != 0) {
19573 return lastComparison;
19574 }
19575 lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
19576 if (lastComparison != 0) {
19577 return lastComparison;
19578 }
19579 lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
19580 if (lastComparison != 0) {
19581 return lastComparison;
19582 }
19583 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
19584 if (lastComparison != 0) {
19585 return lastComparison;
19586 }
19587 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
19588 if (lastComparison != 0) {
19589 return lastComparison;
19590 }
19591 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
19592 if (lastComparison != 0) {
19593 return lastComparison;
19594 }
19595 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
19596 if (lastComparison != 0) {
19597 return lastComparison;
19598 }
19599 return 0;
19600 }
19601
19602 public void read(TProtocol iprot) throws TException {
19603 TField field;
19604 iprot.readStructBegin();
19605 while (true)
19606 {
19607 field = iprot.readFieldBegin();
19608 if (field.type == TType.STOP) {
19609 break;
19610 }
19611 _Fields fieldId = _Fields.findByThriftId(field.id);
19612 if (fieldId == null) {
19613 TProtocolUtil.skip(iprot, field.type);
19614 } else {
19615 switch (fieldId) {
19616 case TABLE_NAME:
19617 if (field.type == TType.STRING) {
19618 this.tableName = iprot.readBinary();
19619 } else {
19620 TProtocolUtil.skip(iprot, field.type);
19621 }
19622 break;
19623 case ROWS:
19624 if (field.type == TType.LIST) {
19625 {
19626 TList _list90 = iprot.readListBegin();
19627 this.rows = new ArrayList<byte[]>(_list90.size);
19628 for (int _i91 = 0; _i91 < _list90.size; ++_i91)
19629 {
19630 byte[] _elem92;
19631 _elem92 = iprot.readBinary();
19632 this.rows.add(_elem92);
19633 }
19634 iprot.readListEnd();
19635 }
19636 } else {
19637 TProtocolUtil.skip(iprot, field.type);
19638 }
19639 break;
19640 case COLUMNS:
19641 if (field.type == TType.LIST) {
19642 {
19643 TList _list93 = iprot.readListBegin();
19644 this.columns = new ArrayList<byte[]>(_list93.size);
19645 for (int _i94 = 0; _i94 < _list93.size; ++_i94)
19646 {
19647 byte[] _elem95;
19648 _elem95 = iprot.readBinary();
19649 this.columns.add(_elem95);
19650 }
19651 iprot.readListEnd();
19652 }
19653 } else {
19654 TProtocolUtil.skip(iprot, field.type);
19655 }
19656 break;
19657 case TIMESTAMP:
19658 if (field.type == TType.I64) {
19659 this.timestamp = iprot.readI64();
19660 setTimestampIsSet(true);
19661 } else {
19662 TProtocolUtil.skip(iprot, field.type);
19663 }
19664 break;
19665 }
19666 iprot.readFieldEnd();
19667 }
19668 }
19669 iprot.readStructEnd();
19670
19671
19672 validate();
19673 }
19674
19675 public void write(TProtocol oprot) throws TException {
19676 validate();
19677
19678 oprot.writeStructBegin(STRUCT_DESC);
19679 if (this.tableName != null) {
19680 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
19681 oprot.writeBinary(this.tableName);
19682 oprot.writeFieldEnd();
19683 }
19684 if (this.rows != null) {
19685 oprot.writeFieldBegin(ROWS_FIELD_DESC);
19686 {
19687 oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
19688 for (byte[] _iter96 : this.rows)
19689 {
19690 oprot.writeBinary(_iter96);
19691 }
19692 oprot.writeListEnd();
19693 }
19694 oprot.writeFieldEnd();
19695 }
19696 if (this.columns != null) {
19697 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
19698 {
19699 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
19700 for (byte[] _iter97 : this.columns)
19701 {
19702 oprot.writeBinary(_iter97);
19703 }
19704 oprot.writeListEnd();
19705 }
19706 oprot.writeFieldEnd();
19707 }
19708 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
19709 oprot.writeI64(this.timestamp);
19710 oprot.writeFieldEnd();
19711 oprot.writeFieldStop();
19712 oprot.writeStructEnd();
19713 }
19714
19715 @Override
19716 public String toString() {
19717 StringBuilder sb = new StringBuilder("getRowsWithColumnsTs_args(");
19718 boolean first = true;
19719
19720 sb.append("tableName:");
19721 if (this.tableName == null) {
19722 sb.append("null");
19723 } else {
19724 sb.append(this.tableName);
19725 }
19726 first = false;
19727 if (!first) sb.append(", ");
19728 sb.append("rows:");
19729 if (this.rows == null) {
19730 sb.append("null");
19731 } else {
19732 sb.append(this.rows);
19733 }
19734 first = false;
19735 if (!first) sb.append(", ");
19736 sb.append("columns:");
19737 if (this.columns == null) {
19738 sb.append("null");
19739 } else {
19740 sb.append(this.columns);
19741 }
19742 first = false;
19743 if (!first) sb.append(", ");
19744 sb.append("timestamp:");
19745 sb.append(this.timestamp);
19746 first = false;
19747 sb.append(")");
19748 return sb.toString();
19749 }
19750
19751 public void validate() throws TException {
19752
19753 }
19754
19755 }
19756
19757 public static class getRowsWithColumnsTs_result implements TBase<getRowsWithColumnsTs_result._Fields>, java.io.Serializable, Cloneable {
19758 private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumnsTs_result");
19759
19760 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
19761 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
19762
19763 public List<TRowResult> success;
19764 public IOError io;
19765
19766
19767 public enum _Fields implements TFieldIdEnum {
19768 SUCCESS((short)0, "success"),
19769 IO((short)1, "io");
19770
19771 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
19772 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
19773
19774 static {
19775 for (_Fields field : EnumSet.allOf(_Fields.class)) {
19776 byId.put((int)field._thriftId, field);
19777 byName.put(field.getFieldName(), field);
19778 }
19779 }
19780
19781
19782
19783
19784 public static _Fields findByThriftId(int fieldId) {
19785 return byId.get(fieldId);
19786 }
19787
19788
19789
19790
19791
19792 public static _Fields findByThriftIdOrThrow(int fieldId) {
19793 _Fields fields = findByThriftId(fieldId);
19794 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
19795 return fields;
19796 }
19797
19798
19799
19800
19801 public static _Fields findByName(String name) {
19802 return byName.get(name);
19803 }
19804
19805 private final short _thriftId;
19806 private final String _fieldName;
19807
19808 _Fields(short thriftId, String fieldName) {
19809 _thriftId = thriftId;
19810 _fieldName = fieldName;
19811 }
19812
19813 public short getThriftFieldId() {
19814 return _thriftId;
19815 }
19816
19817 public String getFieldName() {
19818 return _fieldName;
19819 }
19820 }
19821
19822
19823
19824 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
19825 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
19826 new ListMetaData(TType.LIST,
19827 new StructMetaData(TType.STRUCT, TRowResult.class))));
19828 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
19829 new FieldValueMetaData(TType.STRUCT)));
19830 }});
19831
19832 static {
19833 FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_result.class, metaDataMap);
19834 }
19835
19836 public getRowsWithColumnsTs_result() {
19837 }
19838
19839 public getRowsWithColumnsTs_result(
19840 List<TRowResult> success,
19841 IOError io)
19842 {
19843 this();
19844 this.success = success;
19845 this.io = io;
19846 }
19847
19848
19849
19850
19851 public getRowsWithColumnsTs_result(getRowsWithColumnsTs_result other) {
19852 if (other.isSetSuccess()) {
19853 List<TRowResult> __this__success = new ArrayList<TRowResult>();
19854 for (TRowResult other_element : other.success) {
19855 __this__success.add(new TRowResult(other_element));
19856 }
19857 this.success = __this__success;
19858 }
19859 if (other.isSetIo()) {
19860 this.io = new IOError(other.io);
19861 }
19862 }
19863
19864 public getRowsWithColumnsTs_result deepCopy() {
19865 return new getRowsWithColumnsTs_result(this);
19866 }
19867
19868 @Deprecated
19869 public getRowsWithColumnsTs_result clone() {
19870 return new getRowsWithColumnsTs_result(this);
19871 }
19872
19873 public int getSuccessSize() {
19874 return (this.success == null) ? 0 : this.success.size();
19875 }
19876
19877 public java.util.Iterator<TRowResult> getSuccessIterator() {
19878 return (this.success == null) ? null : this.success.iterator();
19879 }
19880
19881 public void addToSuccess(TRowResult elem) {
19882 if (this.success == null) {
19883 this.success = new ArrayList<TRowResult>();
19884 }
19885 this.success.add(elem);
19886 }
19887
19888 public List<TRowResult> getSuccess() {
19889 return this.success;
19890 }
19891
19892 public getRowsWithColumnsTs_result setSuccess(List<TRowResult> success) {
19893 this.success = success;
19894 return this;
19895 }
19896
19897 public void unsetSuccess() {
19898 this.success = null;
19899 }
19900
19901
19902 public boolean isSetSuccess() {
19903 return this.success != null;
19904 }
19905
19906 public void setSuccessIsSet(boolean value) {
19907 if (!value) {
19908 this.success = null;
19909 }
19910 }
19911
19912 public IOError getIo() {
19913 return this.io;
19914 }
19915
19916 public getRowsWithColumnsTs_result setIo(IOError io) {
19917 this.io = io;
19918 return this;
19919 }
19920
19921 public void unsetIo() {
19922 this.io = null;
19923 }
19924
19925
19926 public boolean isSetIo() {
19927 return this.io != null;
19928 }
19929
19930 public void setIoIsSet(boolean value) {
19931 if (!value) {
19932 this.io = null;
19933 }
19934 }
19935
19936 public void setFieldValue(_Fields field, Object value) {
19937 switch (field) {
19938 case SUCCESS:
19939 if (value == null) {
19940 unsetSuccess();
19941 } else {
19942 setSuccess((List<TRowResult>)value);
19943 }
19944 break;
19945
19946 case IO:
19947 if (value == null) {
19948 unsetIo();
19949 } else {
19950 setIo((IOError)value);
19951 }
19952 break;
19953
19954 }
19955 }
19956
19957 public void setFieldValue(int fieldID, Object value) {
19958 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
19959 }
19960
19961 public Object getFieldValue(_Fields field) {
19962 switch (field) {
19963 case SUCCESS:
19964 return getSuccess();
19965
19966 case IO:
19967 return getIo();
19968
19969 }
19970 throw new IllegalStateException();
19971 }
19972
19973 public Object getFieldValue(int fieldId) {
19974 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
19975 }
19976
19977
19978 public boolean isSet(_Fields field) {
19979 switch (field) {
19980 case SUCCESS:
19981 return isSetSuccess();
19982 case IO:
19983 return isSetIo();
19984 }
19985 throw new IllegalStateException();
19986 }
19987
19988 public boolean isSet(int fieldID) {
19989 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
19990 }
19991
19992 @Override
19993 public boolean equals(Object that) {
19994 if (that == null)
19995 return false;
19996 if (that instanceof getRowsWithColumnsTs_result)
19997 return this.equals((getRowsWithColumnsTs_result)that);
19998 return false;
19999 }
20000
20001 public boolean equals(getRowsWithColumnsTs_result that) {
20002 if (that == null)
20003 return false;
20004
20005 boolean this_present_success = true && this.isSetSuccess();
20006 boolean that_present_success = true && that.isSetSuccess();
20007 if (this_present_success || that_present_success) {
20008 if (!(this_present_success && that_present_success))
20009 return false;
20010 if (!this.success.equals(that.success))
20011 return false;
20012 }
20013
20014 boolean this_present_io = true && this.isSetIo();
20015 boolean that_present_io = true && that.isSetIo();
20016 if (this_present_io || that_present_io) {
20017 if (!(this_present_io && that_present_io))
20018 return false;
20019 if (!this.io.equals(that.io))
20020 return false;
20021 }
20022
20023 return true;
20024 }
20025
20026 @Override
20027 public int hashCode() {
20028 HashCodeBuilder builder = new HashCodeBuilder();
20029
20030 boolean present_success = true && (isSetSuccess());
20031 builder.append(present_success);
20032 if (present_success)
20033 builder.append(success);
20034
20035 boolean present_io = true && (isSetIo());
20036 builder.append(present_io);
20037 if (present_io)
20038 builder.append(io);
20039
20040 return builder.toHashCode();
20041 }
20042
20043 public void read(TProtocol iprot) throws TException {
20044 TField field;
20045 iprot.readStructBegin();
20046 while (true)
20047 {
20048 field = iprot.readFieldBegin();
20049 if (field.type == TType.STOP) {
20050 break;
20051 }
20052 _Fields fieldId = _Fields.findByThriftId(field.id);
20053 if (fieldId == null) {
20054 TProtocolUtil.skip(iprot, field.type);
20055 } else {
20056 switch (fieldId) {
20057 case SUCCESS:
20058 if (field.type == TType.LIST) {
20059 {
20060 TList _list98 = iprot.readListBegin();
20061 this.success = new ArrayList<TRowResult>(_list98.size);
20062 for (int _i99 = 0; _i99 < _list98.size; ++_i99)
20063 {
20064 TRowResult _elem100;
20065 _elem100 = new TRowResult();
20066 _elem100.read(iprot);
20067 this.success.add(_elem100);
20068 }
20069 iprot.readListEnd();
20070 }
20071 } else {
20072 TProtocolUtil.skip(iprot, field.type);
20073 }
20074 break;
20075 case IO:
20076 if (field.type == TType.STRUCT) {
20077 this.io = new IOError();
20078 this.io.read(iprot);
20079 } else {
20080 TProtocolUtil.skip(iprot, field.type);
20081 }
20082 break;
20083 }
20084 iprot.readFieldEnd();
20085 }
20086 }
20087 iprot.readStructEnd();
20088
20089
20090 validate();
20091 }
20092
20093 public void write(TProtocol oprot) throws TException {
20094 oprot.writeStructBegin(STRUCT_DESC);
20095
20096 if (this.isSetSuccess()) {
20097 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20098 {
20099 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
20100 for (TRowResult _iter101 : this.success)
20101 {
20102 _iter101.write(oprot);
20103 }
20104 oprot.writeListEnd();
20105 }
20106 oprot.writeFieldEnd();
20107 } else if (this.isSetIo()) {
20108 oprot.writeFieldBegin(IO_FIELD_DESC);
20109 this.io.write(oprot);
20110 oprot.writeFieldEnd();
20111 }
20112 oprot.writeFieldStop();
20113 oprot.writeStructEnd();
20114 }
20115
20116 @Override
20117 public String toString() {
20118 StringBuilder sb = new StringBuilder("getRowsWithColumnsTs_result(");
20119 boolean first = true;
20120
20121 sb.append("success:");
20122 if (this.success == null) {
20123 sb.append("null");
20124 } else {
20125 sb.append(this.success);
20126 }
20127 first = false;
20128 if (!first) sb.append(", ");
20129 sb.append("io:");
20130 if (this.io == null) {
20131 sb.append("null");
20132 } else {
20133 sb.append(this.io);
20134 }
20135 first = false;
20136 sb.append(")");
20137 return sb.toString();
20138 }
20139
20140 public void validate() throws TException {
20141
20142 }
20143
20144 }
20145
20146 public static class mutateRow_args implements TBase<mutateRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_args> {
20147 private static final TStruct STRUCT_DESC = new TStruct("mutateRow_args");
20148
20149 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
20150 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
20151 private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3);
20152
20153
20154
20155
20156 public byte[] tableName;
20157
20158
20159
20160 public byte[] row;
20161
20162
20163
20164 public List<Mutation> mutations;
20165
20166
20167 public enum _Fields implements TFieldIdEnum {
20168
20169
20170
20171 TABLE_NAME((short)1, "tableName"),
20172
20173
20174
20175 ROW((short)2, "row"),
20176
20177
20178
20179 MUTATIONS((short)3, "mutations");
20180
20181 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
20182 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
20183
20184 static {
20185 for (_Fields field : EnumSet.allOf(_Fields.class)) {
20186 byId.put((int)field._thriftId, field);
20187 byName.put(field.getFieldName(), field);
20188 }
20189 }
20190
20191
20192
20193
20194 public static _Fields findByThriftId(int fieldId) {
20195 return byId.get(fieldId);
20196 }
20197
20198
20199
20200
20201
20202 public static _Fields findByThriftIdOrThrow(int fieldId) {
20203 _Fields fields = findByThriftId(fieldId);
20204 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
20205 return fields;
20206 }
20207
20208
20209
20210
20211 public static _Fields findByName(String name) {
20212 return byName.get(name);
20213 }
20214
20215 private final short _thriftId;
20216 private final String _fieldName;
20217
20218 _Fields(short thriftId, String fieldName) {
20219 _thriftId = thriftId;
20220 _fieldName = fieldName;
20221 }
20222
20223 public short getThriftFieldId() {
20224 return _thriftId;
20225 }
20226
20227 public String getFieldName() {
20228 return _fieldName;
20229 }
20230 }
20231
20232
20233
20234 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
20235 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
20236 new FieldValueMetaData(TType.STRING)));
20237 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
20238 new FieldValueMetaData(TType.STRING)));
20239 put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT,
20240 new ListMetaData(TType.LIST,
20241 new StructMetaData(TType.STRUCT, Mutation.class))));
20242 }});
20243
20244 static {
20245 FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
20246 }
20247
20248 public mutateRow_args() {
20249 }
20250
20251 public mutateRow_args(
20252 byte[] tableName,
20253 byte[] row,
20254 List<Mutation> mutations)
20255 {
20256 this();
20257 this.tableName = tableName;
20258 this.row = row;
20259 this.mutations = mutations;
20260 }
20261
20262
20263
20264
20265 public mutateRow_args(mutateRow_args other) {
20266 if (other.isSetTableName()) {
20267 this.tableName = other.tableName;
20268 }
20269 if (other.isSetRow()) {
20270 this.row = other.row;
20271 }
20272 if (other.isSetMutations()) {
20273 List<Mutation> __this__mutations = new ArrayList<Mutation>();
20274 for (Mutation other_element : other.mutations) {
20275 __this__mutations.add(new Mutation(other_element));
20276 }
20277 this.mutations = __this__mutations;
20278 }
20279 }
20280
20281 public mutateRow_args deepCopy() {
20282 return new mutateRow_args(this);
20283 }
20284
20285 @Deprecated
20286 public mutateRow_args clone() {
20287 return new mutateRow_args(this);
20288 }
20289
20290
20291
20292
20293 public byte[] getTableName() {
20294 return this.tableName;
20295 }
20296
20297
20298
20299
20300 public mutateRow_args setTableName(byte[] tableName) {
20301 this.tableName = tableName;
20302 return this;
20303 }
20304
20305 public void unsetTableName() {
20306 this.tableName = null;
20307 }
20308
20309
20310 public boolean isSetTableName() {
20311 return this.tableName != null;
20312 }
20313
20314 public void setTableNameIsSet(boolean value) {
20315 if (!value) {
20316 this.tableName = null;
20317 }
20318 }
20319
20320
20321
20322
20323 public byte[] getRow() {
20324 return this.row;
20325 }
20326
20327
20328
20329
20330 public mutateRow_args setRow(byte[] row) {
20331 this.row = row;
20332 return this;
20333 }
20334
20335 public void unsetRow() {
20336 this.row = null;
20337 }
20338
20339
20340 public boolean isSetRow() {
20341 return this.row != null;
20342 }
20343
20344 public void setRowIsSet(boolean value) {
20345 if (!value) {
20346 this.row = null;
20347 }
20348 }
20349
20350 public int getMutationsSize() {
20351 return (this.mutations == null) ? 0 : this.mutations.size();
20352 }
20353
20354 public java.util.Iterator<Mutation> getMutationsIterator() {
20355 return (this.mutations == null) ? null : this.mutations.iterator();
20356 }
20357
20358 public void addToMutations(Mutation elem) {
20359 if (this.mutations == null) {
20360 this.mutations = new ArrayList<Mutation>();
20361 }
20362 this.mutations.add(elem);
20363 }
20364
20365
20366
20367
20368 public List<Mutation> getMutations() {
20369 return this.mutations;
20370 }
20371
20372
20373
20374
20375 public mutateRow_args setMutations(List<Mutation> mutations) {
20376 this.mutations = mutations;
20377 return this;
20378 }
20379
20380 public void unsetMutations() {
20381 this.mutations = null;
20382 }
20383
20384
20385 public boolean isSetMutations() {
20386 return this.mutations != null;
20387 }
20388
20389 public void setMutationsIsSet(boolean value) {
20390 if (!value) {
20391 this.mutations = null;
20392 }
20393 }
20394
20395 public void setFieldValue(_Fields field, Object value) {
20396 switch (field) {
20397 case TABLE_NAME:
20398 if (value == null) {
20399 unsetTableName();
20400 } else {
20401 setTableName((byte[])value);
20402 }
20403 break;
20404
20405 case ROW:
20406 if (value == null) {
20407 unsetRow();
20408 } else {
20409 setRow((byte[])value);
20410 }
20411 break;
20412
20413 case MUTATIONS:
20414 if (value == null) {
20415 unsetMutations();
20416 } else {
20417 setMutations((List<Mutation>)value);
20418 }
20419 break;
20420
20421 }
20422 }
20423
20424 public void setFieldValue(int fieldID, Object value) {
20425 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
20426 }
20427
20428 public Object getFieldValue(_Fields field) {
20429 switch (field) {
20430 case TABLE_NAME:
20431 return getTableName();
20432
20433 case ROW:
20434 return getRow();
20435
20436 case MUTATIONS:
20437 return getMutations();
20438
20439 }
20440 throw new IllegalStateException();
20441 }
20442
20443 public Object getFieldValue(int fieldId) {
20444 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
20445 }
20446
20447
20448 public boolean isSet(_Fields field) {
20449 switch (field) {
20450 case TABLE_NAME:
20451 return isSetTableName();
20452 case ROW:
20453 return isSetRow();
20454 case MUTATIONS:
20455 return isSetMutations();
20456 }
20457 throw new IllegalStateException();
20458 }
20459
20460 public boolean isSet(int fieldID) {
20461 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
20462 }
20463
20464 @Override
20465 public boolean equals(Object that) {
20466 if (that == null)
20467 return false;
20468 if (that instanceof mutateRow_args)
20469 return this.equals((mutateRow_args)that);
20470 return false;
20471 }
20472
20473 public boolean equals(mutateRow_args that) {
20474 if (that == null)
20475 return false;
20476
20477 boolean this_present_tableName = true && this.isSetTableName();
20478 boolean that_present_tableName = true && that.isSetTableName();
20479 if (this_present_tableName || that_present_tableName) {
20480 if (!(this_present_tableName && that_present_tableName))
20481 return false;
20482 if (!java.util.Arrays.equals(this.tableName, that.tableName))
20483 return false;
20484 }
20485
20486 boolean this_present_row = true && this.isSetRow();
20487 boolean that_present_row = true && that.isSetRow();
20488 if (this_present_row || that_present_row) {
20489 if (!(this_present_row && that_present_row))
20490 return false;
20491 if (!java.util.Arrays.equals(this.row, that.row))
20492 return false;
20493 }
20494
20495 boolean this_present_mutations = true && this.isSetMutations();
20496 boolean that_present_mutations = true && that.isSetMutations();
20497 if (this_present_mutations || that_present_mutations) {
20498 if (!(this_present_mutations && that_present_mutations))
20499 return false;
20500 if (!this.mutations.equals(that.mutations))
20501 return false;
20502 }
20503
20504 return true;
20505 }
20506
20507 @Override
20508 public int hashCode() {
20509 HashCodeBuilder builder = new HashCodeBuilder();
20510
20511 boolean present_tableName = true && (isSetTableName());
20512 builder.append(present_tableName);
20513 if (present_tableName)
20514 builder.append(tableName);
20515
20516 boolean present_row = true && (isSetRow());
20517 builder.append(present_row);
20518 if (present_row)
20519 builder.append(row);
20520
20521 boolean present_mutations = true && (isSetMutations());
20522 builder.append(present_mutations);
20523 if (present_mutations)
20524 builder.append(mutations);
20525
20526 return builder.toHashCode();
20527 }
20528
20529 public int compareTo(mutateRow_args other) {
20530 if (!getClass().equals(other.getClass())) {
20531 return getClass().getName().compareTo(other.getClass().getName());
20532 }
20533
20534 int lastComparison = 0;
20535 mutateRow_args typedOther = (mutateRow_args)other;
20536
20537 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
20538 if (lastComparison != 0) {
20539 return lastComparison;
20540 }
20541 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
20542 if (lastComparison != 0) {
20543 return lastComparison;
20544 }
20545 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
20546 if (lastComparison != 0) {
20547 return lastComparison;
20548 }
20549 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
20550 if (lastComparison != 0) {
20551 return lastComparison;
20552 }
20553 lastComparison = Boolean.valueOf(isSetMutations()).compareTo(isSetMutations());
20554 if (lastComparison != 0) {
20555 return lastComparison;
20556 }
20557 lastComparison = TBaseHelper.compareTo(mutations, typedOther.mutations);
20558 if (lastComparison != 0) {
20559 return lastComparison;
20560 }
20561 return 0;
20562 }
20563
20564 public void read(TProtocol iprot) throws TException {
20565 TField field;
20566 iprot.readStructBegin();
20567 while (true)
20568 {
20569 field = iprot.readFieldBegin();
20570 if (field.type == TType.STOP) {
20571 break;
20572 }
20573 _Fields fieldId = _Fields.findByThriftId(field.id);
20574 if (fieldId == null) {
20575 TProtocolUtil.skip(iprot, field.type);
20576 } else {
20577 switch (fieldId) {
20578 case TABLE_NAME:
20579 if (field.type == TType.STRING) {
20580 this.tableName = iprot.readBinary();
20581 } else {
20582 TProtocolUtil.skip(iprot, field.type);
20583 }
20584 break;
20585 case ROW:
20586 if (field.type == TType.STRING) {
20587 this.row = iprot.readBinary();
20588 } else {
20589 TProtocolUtil.skip(iprot, field.type);
20590 }
20591 break;
20592 case MUTATIONS:
20593 if (field.type == TType.LIST) {
20594 {
20595 TList _list102 = iprot.readListBegin();
20596 this.mutations = new ArrayList<Mutation>(_list102.size);
20597 for (int _i103 = 0; _i103 < _list102.size; ++_i103)
20598 {
20599 Mutation _elem104;
20600 _elem104 = new Mutation();
20601 _elem104.read(iprot);
20602 this.mutations.add(_elem104);
20603 }
20604 iprot.readListEnd();
20605 }
20606 } else {
20607 TProtocolUtil.skip(iprot, field.type);
20608 }
20609 break;
20610 }
20611 iprot.readFieldEnd();
20612 }
20613 }
20614 iprot.readStructEnd();
20615
20616
20617 validate();
20618 }
20619
20620 public void write(TProtocol oprot) throws TException {
20621 validate();
20622
20623 oprot.writeStructBegin(STRUCT_DESC);
20624 if (this.tableName != null) {
20625 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
20626 oprot.writeBinary(this.tableName);
20627 oprot.writeFieldEnd();
20628 }
20629 if (this.row != null) {
20630 oprot.writeFieldBegin(ROW_FIELD_DESC);
20631 oprot.writeBinary(this.row);
20632 oprot.writeFieldEnd();
20633 }
20634 if (this.mutations != null) {
20635 oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
20636 {
20637 oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size()));
20638 for (Mutation _iter105 : this.mutations)
20639 {
20640 _iter105.write(oprot);
20641 }
20642 oprot.writeListEnd();
20643 }
20644 oprot.writeFieldEnd();
20645 }
20646 oprot.writeFieldStop();
20647 oprot.writeStructEnd();
20648 }
20649
20650 @Override
20651 public String toString() {
20652 StringBuilder sb = new StringBuilder("mutateRow_args(");
20653 boolean first = true;
20654
20655 sb.append("tableName:");
20656 if (this.tableName == null) {
20657 sb.append("null");
20658 } else {
20659 sb.append(this.tableName);
20660 }
20661 first = false;
20662 if (!first) sb.append(", ");
20663 sb.append("row:");
20664 if (this.row == null) {
20665 sb.append("null");
20666 } else {
20667 sb.append(this.row);
20668 }
20669 first = false;
20670 if (!first) sb.append(", ");
20671 sb.append("mutations:");
20672 if (this.mutations == null) {
20673 sb.append("null");
20674 } else {
20675 sb.append(this.mutations);
20676 }
20677 first = false;
20678 sb.append(")");
20679 return sb.toString();
20680 }
20681
20682 public void validate() throws TException {
20683
20684 }
20685
20686 }
20687
20688 public static class mutateRow_result implements TBase<mutateRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_result> {
20689 private static final TStruct STRUCT_DESC = new TStruct("mutateRow_result");
20690
20691 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
20692 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
20693
20694 public IOError io;
20695 public IllegalArgument ia;
20696
20697
20698 public enum _Fields implements TFieldIdEnum {
20699 IO((short)1, "io"),
20700 IA((short)2, "ia");
20701
20702 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
20703 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
20704
20705 static {
20706 for (_Fields field : EnumSet.allOf(_Fields.class)) {
20707 byId.put((int)field._thriftId, field);
20708 byName.put(field.getFieldName(), field);
20709 }
20710 }
20711
20712
20713
20714
20715 public static _Fields findByThriftId(int fieldId) {
20716 return byId.get(fieldId);
20717 }
20718
20719
20720
20721
20722
20723 public static _Fields findByThriftIdOrThrow(int fieldId) {
20724 _Fields fields = findByThriftId(fieldId);
20725 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
20726 return fields;
20727 }
20728
20729
20730
20731
20732 public static _Fields findByName(String name) {
20733 return byName.get(name);
20734 }
20735
20736 private final short _thriftId;
20737 private final String _fieldName;
20738
20739 _Fields(short thriftId, String fieldName) {
20740 _thriftId = thriftId;
20741 _fieldName = fieldName;
20742 }
20743
20744 public short getThriftFieldId() {
20745 return _thriftId;
20746 }
20747
20748 public String getFieldName() {
20749 return _fieldName;
20750 }
20751 }
20752
20753
20754
20755 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
20756 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
20757 new FieldValueMetaData(TType.STRUCT)));
20758 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
20759 new FieldValueMetaData(TType.STRUCT)));
20760 }});
20761
20762 static {
20763 FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap);
20764 }
20765
20766 public mutateRow_result() {
20767 }
20768
20769 public mutateRow_result(
20770 IOError io,
20771 IllegalArgument ia)
20772 {
20773 this();
20774 this.io = io;
20775 this.ia = ia;
20776 }
20777
20778
20779
20780
20781 public mutateRow_result(mutateRow_result other) {
20782 if (other.isSetIo()) {
20783 this.io = new IOError(other.io);
20784 }
20785 if (other.isSetIa()) {
20786 this.ia = new IllegalArgument(other.ia);
20787 }
20788 }
20789
20790 public mutateRow_result deepCopy() {
20791 return new mutateRow_result(this);
20792 }
20793
20794 @Deprecated
20795 public mutateRow_result clone() {
20796 return new mutateRow_result(this);
20797 }
20798
20799 public IOError getIo() {
20800 return this.io;
20801 }
20802
20803 public mutateRow_result setIo(IOError io) {
20804 this.io = io;
20805 return this;
20806 }
20807
20808 public void unsetIo() {
20809 this.io = null;
20810 }
20811
20812
20813 public boolean isSetIo() {
20814 return this.io != null;
20815 }
20816
20817 public void setIoIsSet(boolean value) {
20818 if (!value) {
20819 this.io = null;
20820 }
20821 }
20822
20823 public IllegalArgument getIa() {
20824 return this.ia;
20825 }
20826
20827 public mutateRow_result setIa(IllegalArgument ia) {
20828 this.ia = ia;
20829 return this;
20830 }
20831
20832 public void unsetIa() {
20833 this.ia = null;
20834 }
20835
20836
20837 public boolean isSetIa() {
20838 return this.ia != null;
20839 }
20840
20841 public void setIaIsSet(boolean value) {
20842 if (!value) {
20843 this.ia = null;
20844 }
20845 }
20846
20847 public void setFieldValue(_Fields field, Object value) {
20848 switch (field) {
20849 case IO:
20850 if (value == null) {
20851 unsetIo();
20852 } else {
20853 setIo((IOError)value);
20854 }
20855 break;
20856
20857 case IA:
20858 if (value == null) {
20859 unsetIa();
20860 } else {
20861 setIa((IllegalArgument)value);
20862 }
20863 break;
20864
20865 }
20866 }
20867
20868 public void setFieldValue(int fieldID, Object value) {
20869 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
20870 }
20871
20872 public Object getFieldValue(_Fields field) {
20873 switch (field) {
20874 case IO:
20875 return getIo();
20876
20877 case IA:
20878 return getIa();
20879
20880 }
20881 throw new IllegalStateException();
20882 }
20883
20884 public Object getFieldValue(int fieldId) {
20885 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
20886 }
20887
20888
20889 public boolean isSet(_Fields field) {
20890 switch (field) {
20891 case IO:
20892 return isSetIo();
20893 case IA:
20894 return isSetIa();
20895 }
20896 throw new IllegalStateException();
20897 }
20898
20899 public boolean isSet(int fieldID) {
20900 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
20901 }
20902
20903 @Override
20904 public boolean equals(Object that) {
20905 if (that == null)
20906 return false;
20907 if (that instanceof mutateRow_result)
20908 return this.equals((mutateRow_result)that);
20909 return false;
20910 }
20911
20912 public boolean equals(mutateRow_result that) {
20913 if (that == null)
20914 return false;
20915
20916 boolean this_present_io = true && this.isSetIo();
20917 boolean that_present_io = true && that.isSetIo();
20918 if (this_present_io || that_present_io) {
20919 if (!(this_present_io && that_present_io))
20920 return false;
20921 if (!this.io.equals(that.io))
20922 return false;
20923 }
20924
20925 boolean this_present_ia = true && this.isSetIa();
20926 boolean that_present_ia = true && that.isSetIa();
20927 if (this_present_ia || that_present_ia) {
20928 if (!(this_present_ia && that_present_ia))
20929 return false;
20930 if (!this.ia.equals(that.ia))
20931 return false;
20932 }
20933
20934 return true;
20935 }
20936
20937 @Override
20938 public int hashCode() {
20939 HashCodeBuilder builder = new HashCodeBuilder();
20940
20941 boolean present_io = true && (isSetIo());
20942 builder.append(present_io);
20943 if (present_io)
20944 builder.append(io);
20945
20946 boolean present_ia = true && (isSetIa());
20947 builder.append(present_ia);
20948 if (present_ia)
20949 builder.append(ia);
20950
20951 return builder.toHashCode();
20952 }
20953
20954 public int compareTo(mutateRow_result other) {
20955 if (!getClass().equals(other.getClass())) {
20956 return getClass().getName().compareTo(other.getClass().getName());
20957 }
20958
20959 int lastComparison = 0;
20960 mutateRow_result typedOther = (mutateRow_result)other;
20961
20962 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
20963 if (lastComparison != 0) {
20964 return lastComparison;
20965 }
20966 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
20967 if (lastComparison != 0) {
20968 return lastComparison;
20969 }
20970 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
20971 if (lastComparison != 0) {
20972 return lastComparison;
20973 }
20974 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
20975 if (lastComparison != 0) {
20976 return lastComparison;
20977 }
20978 return 0;
20979 }
20980
20981 public void read(TProtocol iprot) throws TException {
20982 TField field;
20983 iprot.readStructBegin();
20984 while (true)
20985 {
20986 field = iprot.readFieldBegin();
20987 if (field.type == TType.STOP) {
20988 break;
20989 }
20990 _Fields fieldId = _Fields.findByThriftId(field.id);
20991 if (fieldId == null) {
20992 TProtocolUtil.skip(iprot, field.type);
20993 } else {
20994 switch (fieldId) {
20995 case IO:
20996 if (field.type == TType.STRUCT) {
20997 this.io = new IOError();
20998 this.io.read(iprot);
20999 } else {
21000 TProtocolUtil.skip(iprot, field.type);
21001 }
21002 break;
21003 case IA:
21004 if (field.type == TType.STRUCT) {
21005 this.ia = new IllegalArgument();
21006 this.ia.read(iprot);
21007 } else {
21008 TProtocolUtil.skip(iprot, field.type);
21009 }
21010 break;
21011 }
21012 iprot.readFieldEnd();
21013 }
21014 }
21015 iprot.readStructEnd();
21016
21017
21018 validate();
21019 }
21020
21021 public void write(TProtocol oprot) throws TException {
21022 oprot.writeStructBegin(STRUCT_DESC);
21023
21024 if (this.isSetIo()) {
21025 oprot.writeFieldBegin(IO_FIELD_DESC);
21026 this.io.write(oprot);
21027 oprot.writeFieldEnd();
21028 } else if (this.isSetIa()) {
21029 oprot.writeFieldBegin(IA_FIELD_DESC);
21030 this.ia.write(oprot);
21031 oprot.writeFieldEnd();
21032 }
21033 oprot.writeFieldStop();
21034 oprot.writeStructEnd();
21035 }
21036
21037 @Override
21038 public String toString() {
21039 StringBuilder sb = new StringBuilder("mutateRow_result(");
21040 boolean first = true;
21041
21042 sb.append("io:");
21043 if (this.io == null) {
21044 sb.append("null");
21045 } else {
21046 sb.append(this.io);
21047 }
21048 first = false;
21049 if (!first) sb.append(", ");
21050 sb.append("ia:");
21051 if (this.ia == null) {
21052 sb.append("null");
21053 } else {
21054 sb.append(this.ia);
21055 }
21056 first = false;
21057 sb.append(")");
21058 return sb.toString();
21059 }
21060
21061 public void validate() throws TException {
21062
21063 }
21064
21065 }
21066
21067 public static class mutateRowTs_args implements TBase<mutateRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_args> {
21068 private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_args");
21069
21070 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
21071 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
21072 private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3);
21073 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
21074
21075
21076
21077
21078 public byte[] tableName;
21079
21080
21081
21082 public byte[] row;
21083
21084
21085
21086 public List<Mutation> mutations;
21087
21088
21089
21090 public long timestamp;
21091
21092
21093 public enum _Fields implements TFieldIdEnum {
21094
21095
21096
21097 TABLE_NAME((short)1, "tableName"),
21098
21099
21100
21101 ROW((short)2, "row"),
21102
21103
21104
21105 MUTATIONS((short)3, "mutations"),
21106
21107
21108
21109 TIMESTAMP((short)4, "timestamp");
21110
21111 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
21112 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
21113
21114 static {
21115 for (_Fields field : EnumSet.allOf(_Fields.class)) {
21116 byId.put((int)field._thriftId, field);
21117 byName.put(field.getFieldName(), field);
21118 }
21119 }
21120
21121
21122
21123
21124 public static _Fields findByThriftId(int fieldId) {
21125 return byId.get(fieldId);
21126 }
21127
21128
21129
21130
21131
21132 public static _Fields findByThriftIdOrThrow(int fieldId) {
21133 _Fields fields = findByThriftId(fieldId);
21134 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
21135 return fields;
21136 }
21137
21138
21139
21140
21141 public static _Fields findByName(String name) {
21142 return byName.get(name);
21143 }
21144
21145 private final short _thriftId;
21146 private final String _fieldName;
21147
21148 _Fields(short thriftId, String fieldName) {
21149 _thriftId = thriftId;
21150 _fieldName = fieldName;
21151 }
21152
21153 public short getThriftFieldId() {
21154 return _thriftId;
21155 }
21156
21157 public String getFieldName() {
21158 return _fieldName;
21159 }
21160 }
21161
21162
21163 private static final int __TIMESTAMP_ISSET_ID = 0;
21164 private BitSet __isset_bit_vector = new BitSet(1);
21165
21166 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
21167 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
21168 new FieldValueMetaData(TType.STRING)));
21169 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
21170 new FieldValueMetaData(TType.STRING)));
21171 put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT,
21172 new ListMetaData(TType.LIST,
21173 new StructMetaData(TType.STRUCT, Mutation.class))));
21174 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
21175 new FieldValueMetaData(TType.I64)));
21176 }});
21177
21178 static {
21179 FieldMetaData.addStructMetaDataMap(mutateRowTs_args.class, metaDataMap);
21180 }
21181
21182 public mutateRowTs_args() {
21183 }
21184
21185 public mutateRowTs_args(
21186 byte[] tableName,
21187 byte[] row,
21188 List<Mutation> mutations,
21189 long timestamp)
21190 {
21191 this();
21192 this.tableName = tableName;
21193 this.row = row;
21194 this.mutations = mutations;
21195 this.timestamp = timestamp;
21196 setTimestampIsSet(true);
21197 }
21198
21199
21200
21201
21202 public mutateRowTs_args(mutateRowTs_args other) {
21203 __isset_bit_vector.clear();
21204 __isset_bit_vector.or(other.__isset_bit_vector);
21205 if (other.isSetTableName()) {
21206 this.tableName = other.tableName;
21207 }
21208 if (other.isSetRow()) {
21209 this.row = other.row;
21210 }
21211 if (other.isSetMutations()) {
21212 List<Mutation> __this__mutations = new ArrayList<Mutation>();
21213 for (Mutation other_element : other.mutations) {
21214 __this__mutations.add(new Mutation(other_element));
21215 }
21216 this.mutations = __this__mutations;
21217 }
21218 this.timestamp = other.timestamp;
21219 }
21220
21221 public mutateRowTs_args deepCopy() {
21222 return new mutateRowTs_args(this);
21223 }
21224
21225 @Deprecated
21226 public mutateRowTs_args clone() {
21227 return new mutateRowTs_args(this);
21228 }
21229
21230
21231
21232
21233 public byte[] getTableName() {
21234 return this.tableName;
21235 }
21236
21237
21238
21239
21240 public mutateRowTs_args setTableName(byte[] tableName) {
21241 this.tableName = tableName;
21242 return this;
21243 }
21244
21245 public void unsetTableName() {
21246 this.tableName = null;
21247 }
21248
21249
21250 public boolean isSetTableName() {
21251 return this.tableName != null;
21252 }
21253
21254 public void setTableNameIsSet(boolean value) {
21255 if (!value) {
21256 this.tableName = null;
21257 }
21258 }
21259
21260
21261
21262
21263 public byte[] getRow() {
21264 return this.row;
21265 }
21266
21267
21268
21269
21270 public mutateRowTs_args setRow(byte[] row) {
21271 this.row = row;
21272 return this;
21273 }
21274
21275 public void unsetRow() {
21276 this.row = null;
21277 }
21278
21279
21280 public boolean isSetRow() {
21281 return this.row != null;
21282 }
21283
21284 public void setRowIsSet(boolean value) {
21285 if (!value) {
21286 this.row = null;
21287 }
21288 }
21289
21290 public int getMutationsSize() {
21291 return (this.mutations == null) ? 0 : this.mutations.size();
21292 }
21293
21294 public java.util.Iterator<Mutation> getMutationsIterator() {
21295 return (this.mutations == null) ? null : this.mutations.iterator();
21296 }
21297
21298 public void addToMutations(Mutation elem) {
21299 if (this.mutations == null) {
21300 this.mutations = new ArrayList<Mutation>();
21301 }
21302 this.mutations.add(elem);
21303 }
21304
21305
21306
21307
21308 public List<Mutation> getMutations() {
21309 return this.mutations;
21310 }
21311
21312
21313
21314
21315 public mutateRowTs_args setMutations(List<Mutation> mutations) {
21316 this.mutations = mutations;
21317 return this;
21318 }
21319
21320 public void unsetMutations() {
21321 this.mutations = null;
21322 }
21323
21324
21325 public boolean isSetMutations() {
21326 return this.mutations != null;
21327 }
21328
21329 public void setMutationsIsSet(boolean value) {
21330 if (!value) {
21331 this.mutations = null;
21332 }
21333 }
21334
21335
21336
21337
21338 public long getTimestamp() {
21339 return this.timestamp;
21340 }
21341
21342
21343
21344
21345 public mutateRowTs_args setTimestamp(long timestamp) {
21346 this.timestamp = timestamp;
21347 setTimestampIsSet(true);
21348 return this;
21349 }
21350
21351 public void unsetTimestamp() {
21352 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
21353 }
21354
21355
21356 public boolean isSetTimestamp() {
21357 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
21358 }
21359
21360 public void setTimestampIsSet(boolean value) {
21361 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
21362 }
21363
21364 public void setFieldValue(_Fields field, Object value) {
21365 switch (field) {
21366 case TABLE_NAME:
21367 if (value == null) {
21368 unsetTableName();
21369 } else {
21370 setTableName((byte[])value);
21371 }
21372 break;
21373
21374 case ROW:
21375 if (value == null) {
21376 unsetRow();
21377 } else {
21378 setRow((byte[])value);
21379 }
21380 break;
21381
21382 case MUTATIONS:
21383 if (value == null) {
21384 unsetMutations();
21385 } else {
21386 setMutations((List<Mutation>)value);
21387 }
21388 break;
21389
21390 case TIMESTAMP:
21391 if (value == null) {
21392 unsetTimestamp();
21393 } else {
21394 setTimestamp((Long)value);
21395 }
21396 break;
21397
21398 }
21399 }
21400
21401 public void setFieldValue(int fieldID, Object value) {
21402 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21403 }
21404
21405 public Object getFieldValue(_Fields field) {
21406 switch (field) {
21407 case TABLE_NAME:
21408 return getTableName();
21409
21410 case ROW:
21411 return getRow();
21412
21413 case MUTATIONS:
21414 return getMutations();
21415
21416 case TIMESTAMP:
21417 return new Long(getTimestamp());
21418
21419 }
21420 throw new IllegalStateException();
21421 }
21422
21423 public Object getFieldValue(int fieldId) {
21424 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21425 }
21426
21427
21428 public boolean isSet(_Fields field) {
21429 switch (field) {
21430 case TABLE_NAME:
21431 return isSetTableName();
21432 case ROW:
21433 return isSetRow();
21434 case MUTATIONS:
21435 return isSetMutations();
21436 case TIMESTAMP:
21437 return isSetTimestamp();
21438 }
21439 throw new IllegalStateException();
21440 }
21441
21442 public boolean isSet(int fieldID) {
21443 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21444 }
21445
21446 @Override
21447 public boolean equals(Object that) {
21448 if (that == null)
21449 return false;
21450 if (that instanceof mutateRowTs_args)
21451 return this.equals((mutateRowTs_args)that);
21452 return false;
21453 }
21454
21455 public boolean equals(mutateRowTs_args that) {
21456 if (that == null)
21457 return false;
21458
21459 boolean this_present_tableName = true && this.isSetTableName();
21460 boolean that_present_tableName = true && that.isSetTableName();
21461 if (this_present_tableName || that_present_tableName) {
21462 if (!(this_present_tableName && that_present_tableName))
21463 return false;
21464 if (!java.util.Arrays.equals(this.tableName, that.tableName))
21465 return false;
21466 }
21467
21468 boolean this_present_row = true && this.isSetRow();
21469 boolean that_present_row = true && that.isSetRow();
21470 if (this_present_row || that_present_row) {
21471 if (!(this_present_row && that_present_row))
21472 return false;
21473 if (!java.util.Arrays.equals(this.row, that.row))
21474 return false;
21475 }
21476
21477 boolean this_present_mutations = true && this.isSetMutations();
21478 boolean that_present_mutations = true && that.isSetMutations();
21479 if (this_present_mutations || that_present_mutations) {
21480 if (!(this_present_mutations && that_present_mutations))
21481 return false;
21482 if (!this.mutations.equals(that.mutations))
21483 return false;
21484 }
21485
21486 boolean this_present_timestamp = true;
21487 boolean that_present_timestamp = true;
21488 if (this_present_timestamp || that_present_timestamp) {
21489 if (!(this_present_timestamp && that_present_timestamp))
21490 return false;
21491 if (this.timestamp != that.timestamp)
21492 return false;
21493 }
21494
21495 return true;
21496 }
21497
21498 @Override
21499 public int hashCode() {
21500 HashCodeBuilder builder = new HashCodeBuilder();
21501
21502 boolean present_tableName = true && (isSetTableName());
21503 builder.append(present_tableName);
21504 if (present_tableName)
21505 builder.append(tableName);
21506
21507 boolean present_row = true && (isSetRow());
21508 builder.append(present_row);
21509 if (present_row)
21510 builder.append(row);
21511
21512 boolean present_mutations = true && (isSetMutations());
21513 builder.append(present_mutations);
21514 if (present_mutations)
21515 builder.append(mutations);
21516
21517 boolean present_timestamp = true;
21518 builder.append(present_timestamp);
21519 if (present_timestamp)
21520 builder.append(timestamp);
21521
21522 return builder.toHashCode();
21523 }
21524
21525 public int compareTo(mutateRowTs_args other) {
21526 if (!getClass().equals(other.getClass())) {
21527 return getClass().getName().compareTo(other.getClass().getName());
21528 }
21529
21530 int lastComparison = 0;
21531 mutateRowTs_args typedOther = (mutateRowTs_args)other;
21532
21533 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
21534 if (lastComparison != 0) {
21535 return lastComparison;
21536 }
21537 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
21538 if (lastComparison != 0) {
21539 return lastComparison;
21540 }
21541 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
21542 if (lastComparison != 0) {
21543 return lastComparison;
21544 }
21545 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
21546 if (lastComparison != 0) {
21547 return lastComparison;
21548 }
21549 lastComparison = Boolean.valueOf(isSetMutations()).compareTo(isSetMutations());
21550 if (lastComparison != 0) {
21551 return lastComparison;
21552 }
21553 lastComparison = TBaseHelper.compareTo(mutations, typedOther.mutations);
21554 if (lastComparison != 0) {
21555 return lastComparison;
21556 }
21557 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
21558 if (lastComparison != 0) {
21559 return lastComparison;
21560 }
21561 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
21562 if (lastComparison != 0) {
21563 return lastComparison;
21564 }
21565 return 0;
21566 }
21567
21568 public void read(TProtocol iprot) throws TException {
21569 TField field;
21570 iprot.readStructBegin();
21571 while (true)
21572 {
21573 field = iprot.readFieldBegin();
21574 if (field.type == TType.STOP) {
21575 break;
21576 }
21577 _Fields fieldId = _Fields.findByThriftId(field.id);
21578 if (fieldId == null) {
21579 TProtocolUtil.skip(iprot, field.type);
21580 } else {
21581 switch (fieldId) {
21582 case TABLE_NAME:
21583 if (field.type == TType.STRING) {
21584 this.tableName = iprot.readBinary();
21585 } else {
21586 TProtocolUtil.skip(iprot, field.type);
21587 }
21588 break;
21589 case ROW:
21590 if (field.type == TType.STRING) {
21591 this.row = iprot.readBinary();
21592 } else {
21593 TProtocolUtil.skip(iprot, field.type);
21594 }
21595 break;
21596 case MUTATIONS:
21597 if (field.type == TType.LIST) {
21598 {
21599 TList _list106 = iprot.readListBegin();
21600 this.mutations = new ArrayList<Mutation>(_list106.size);
21601 for (int _i107 = 0; _i107 < _list106.size; ++_i107)
21602 {
21603 Mutation _elem108;
21604 _elem108 = new Mutation();
21605 _elem108.read(iprot);
21606 this.mutations.add(_elem108);
21607 }
21608 iprot.readListEnd();
21609 }
21610 } else {
21611 TProtocolUtil.skip(iprot, field.type);
21612 }
21613 break;
21614 case TIMESTAMP:
21615 if (field.type == TType.I64) {
21616 this.timestamp = iprot.readI64();
21617 setTimestampIsSet(true);
21618 } else {
21619 TProtocolUtil.skip(iprot, field.type);
21620 }
21621 break;
21622 }
21623 iprot.readFieldEnd();
21624 }
21625 }
21626 iprot.readStructEnd();
21627
21628
21629 validate();
21630 }
21631
21632 public void write(TProtocol oprot) throws TException {
21633 validate();
21634
21635 oprot.writeStructBegin(STRUCT_DESC);
21636 if (this.tableName != null) {
21637 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
21638 oprot.writeBinary(this.tableName);
21639 oprot.writeFieldEnd();
21640 }
21641 if (this.row != null) {
21642 oprot.writeFieldBegin(ROW_FIELD_DESC);
21643 oprot.writeBinary(this.row);
21644 oprot.writeFieldEnd();
21645 }
21646 if (this.mutations != null) {
21647 oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
21648 {
21649 oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size()));
21650 for (Mutation _iter109 : this.mutations)
21651 {
21652 _iter109.write(oprot);
21653 }
21654 oprot.writeListEnd();
21655 }
21656 oprot.writeFieldEnd();
21657 }
21658 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
21659 oprot.writeI64(this.timestamp);
21660 oprot.writeFieldEnd();
21661 oprot.writeFieldStop();
21662 oprot.writeStructEnd();
21663 }
21664
21665 @Override
21666 public String toString() {
21667 StringBuilder sb = new StringBuilder("mutateRowTs_args(");
21668 boolean first = true;
21669
21670 sb.append("tableName:");
21671 if (this.tableName == null) {
21672 sb.append("null");
21673 } else {
21674 sb.append(this.tableName);
21675 }
21676 first = false;
21677 if (!first) sb.append(", ");
21678 sb.append("row:");
21679 if (this.row == null) {
21680 sb.append("null");
21681 } else {
21682 sb.append(this.row);
21683 }
21684 first = false;
21685 if (!first) sb.append(", ");
21686 sb.append("mutations:");
21687 if (this.mutations == null) {
21688 sb.append("null");
21689 } else {
21690 sb.append(this.mutations);
21691 }
21692 first = false;
21693 if (!first) sb.append(", ");
21694 sb.append("timestamp:");
21695 sb.append(this.timestamp);
21696 first = false;
21697 sb.append(")");
21698 return sb.toString();
21699 }
21700
21701 public void validate() throws TException {
21702
21703 }
21704
21705 }
21706
21707 public static class mutateRowTs_result implements TBase<mutateRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_result> {
21708 private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_result");
21709
21710 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
21711 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
21712
21713 public IOError io;
21714 public IllegalArgument ia;
21715
21716
21717 public enum _Fields implements TFieldIdEnum {
21718 IO((short)1, "io"),
21719 IA((short)2, "ia");
21720
21721 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
21722 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
21723
21724 static {
21725 for (_Fields field : EnumSet.allOf(_Fields.class)) {
21726 byId.put((int)field._thriftId, field);
21727 byName.put(field.getFieldName(), field);
21728 }
21729 }
21730
21731
21732
21733
21734 public static _Fields findByThriftId(int fieldId) {
21735 return byId.get(fieldId);
21736 }
21737
21738
21739
21740
21741
21742 public static _Fields findByThriftIdOrThrow(int fieldId) {
21743 _Fields fields = findByThriftId(fieldId);
21744 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
21745 return fields;
21746 }
21747
21748
21749
21750
21751 public static _Fields findByName(String name) {
21752 return byName.get(name);
21753 }
21754
21755 private final short _thriftId;
21756 private final String _fieldName;
21757
21758 _Fields(short thriftId, String fieldName) {
21759 _thriftId = thriftId;
21760 _fieldName = fieldName;
21761 }
21762
21763 public short getThriftFieldId() {
21764 return _thriftId;
21765 }
21766
21767 public String getFieldName() {
21768 return _fieldName;
21769 }
21770 }
21771
21772
21773
21774 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
21775 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
21776 new FieldValueMetaData(TType.STRUCT)));
21777 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
21778 new FieldValueMetaData(TType.STRUCT)));
21779 }});
21780
21781 static {
21782 FieldMetaData.addStructMetaDataMap(mutateRowTs_result.class, metaDataMap);
21783 }
21784
21785 public mutateRowTs_result() {
21786 }
21787
21788 public mutateRowTs_result(
21789 IOError io,
21790 IllegalArgument ia)
21791 {
21792 this();
21793 this.io = io;
21794 this.ia = ia;
21795 }
21796
21797
21798
21799
21800 public mutateRowTs_result(mutateRowTs_result other) {
21801 if (other.isSetIo()) {
21802 this.io = new IOError(other.io);
21803 }
21804 if (other.isSetIa()) {
21805 this.ia = new IllegalArgument(other.ia);
21806 }
21807 }
21808
21809 public mutateRowTs_result deepCopy() {
21810 return new mutateRowTs_result(this);
21811 }
21812
21813 @Deprecated
21814 public mutateRowTs_result clone() {
21815 return new mutateRowTs_result(this);
21816 }
21817
21818 public IOError getIo() {
21819 return this.io;
21820 }
21821
21822 public mutateRowTs_result setIo(IOError io) {
21823 this.io = io;
21824 return this;
21825 }
21826
21827 public void unsetIo() {
21828 this.io = null;
21829 }
21830
21831
21832 public boolean isSetIo() {
21833 return this.io != null;
21834 }
21835
21836 public void setIoIsSet(boolean value) {
21837 if (!value) {
21838 this.io = null;
21839 }
21840 }
21841
21842 public IllegalArgument getIa() {
21843 return this.ia;
21844 }
21845
21846 public mutateRowTs_result setIa(IllegalArgument ia) {
21847 this.ia = ia;
21848 return this;
21849 }
21850
21851 public void unsetIa() {
21852 this.ia = null;
21853 }
21854
21855
21856 public boolean isSetIa() {
21857 return this.ia != null;
21858 }
21859
21860 public void setIaIsSet(boolean value) {
21861 if (!value) {
21862 this.ia = null;
21863 }
21864 }
21865
21866 public void setFieldValue(_Fields field, Object value) {
21867 switch (field) {
21868 case IO:
21869 if (value == null) {
21870 unsetIo();
21871 } else {
21872 setIo((IOError)value);
21873 }
21874 break;
21875
21876 case IA:
21877 if (value == null) {
21878 unsetIa();
21879 } else {
21880 setIa((IllegalArgument)value);
21881 }
21882 break;
21883
21884 }
21885 }
21886
21887 public void setFieldValue(int fieldID, Object value) {
21888 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21889 }
21890
21891 public Object getFieldValue(_Fields field) {
21892 switch (field) {
21893 case IO:
21894 return getIo();
21895
21896 case IA:
21897 return getIa();
21898
21899 }
21900 throw new IllegalStateException();
21901 }
21902
21903 public Object getFieldValue(int fieldId) {
21904 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21905 }
21906
21907
21908 public boolean isSet(_Fields field) {
21909 switch (field) {
21910 case IO:
21911 return isSetIo();
21912 case IA:
21913 return isSetIa();
21914 }
21915 throw new IllegalStateException();
21916 }
21917
21918 public boolean isSet(int fieldID) {
21919 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21920 }
21921
21922 @Override
21923 public boolean equals(Object that) {
21924 if (that == null)
21925 return false;
21926 if (that instanceof mutateRowTs_result)
21927 return this.equals((mutateRowTs_result)that);
21928 return false;
21929 }
21930
21931 public boolean equals(mutateRowTs_result that) {
21932 if (that == null)
21933 return false;
21934
21935 boolean this_present_io = true && this.isSetIo();
21936 boolean that_present_io = true && that.isSetIo();
21937 if (this_present_io || that_present_io) {
21938 if (!(this_present_io && that_present_io))
21939 return false;
21940 if (!this.io.equals(that.io))
21941 return false;
21942 }
21943
21944 boolean this_present_ia = true && this.isSetIa();
21945 boolean that_present_ia = true && that.isSetIa();
21946 if (this_present_ia || that_present_ia) {
21947 if (!(this_present_ia && that_present_ia))
21948 return false;
21949 if (!this.ia.equals(that.ia))
21950 return false;
21951 }
21952
21953 return true;
21954 }
21955
21956 @Override
21957 public int hashCode() {
21958 HashCodeBuilder builder = new HashCodeBuilder();
21959
21960 boolean present_io = true && (isSetIo());
21961 builder.append(present_io);
21962 if (present_io)
21963 builder.append(io);
21964
21965 boolean present_ia = true && (isSetIa());
21966 builder.append(present_ia);
21967 if (present_ia)
21968 builder.append(ia);
21969
21970 return builder.toHashCode();
21971 }
21972
21973 public int compareTo(mutateRowTs_result other) {
21974 if (!getClass().equals(other.getClass())) {
21975 return getClass().getName().compareTo(other.getClass().getName());
21976 }
21977
21978 int lastComparison = 0;
21979 mutateRowTs_result typedOther = (mutateRowTs_result)other;
21980
21981 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
21982 if (lastComparison != 0) {
21983 return lastComparison;
21984 }
21985 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
21986 if (lastComparison != 0) {
21987 return lastComparison;
21988 }
21989 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
21990 if (lastComparison != 0) {
21991 return lastComparison;
21992 }
21993 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
21994 if (lastComparison != 0) {
21995 return lastComparison;
21996 }
21997 return 0;
21998 }
21999
22000 public void read(TProtocol iprot) throws TException {
22001 TField field;
22002 iprot.readStructBegin();
22003 while (true)
22004 {
22005 field = iprot.readFieldBegin();
22006 if (field.type == TType.STOP) {
22007 break;
22008 }
22009 _Fields fieldId = _Fields.findByThriftId(field.id);
22010 if (fieldId == null) {
22011 TProtocolUtil.skip(iprot, field.type);
22012 } else {
22013 switch (fieldId) {
22014 case IO:
22015 if (field.type == TType.STRUCT) {
22016 this.io = new IOError();
22017 this.io.read(iprot);
22018 } else {
22019 TProtocolUtil.skip(iprot, field.type);
22020 }
22021 break;
22022 case IA:
22023 if (field.type == TType.STRUCT) {
22024 this.ia = new IllegalArgument();
22025 this.ia.read(iprot);
22026 } else {
22027 TProtocolUtil.skip(iprot, field.type);
22028 }
22029 break;
22030 }
22031 iprot.readFieldEnd();
22032 }
22033 }
22034 iprot.readStructEnd();
22035
22036
22037 validate();
22038 }
22039
22040 public void write(TProtocol oprot) throws TException {
22041 oprot.writeStructBegin(STRUCT_DESC);
22042
22043 if (this.isSetIo()) {
22044 oprot.writeFieldBegin(IO_FIELD_DESC);
22045 this.io.write(oprot);
22046 oprot.writeFieldEnd();
22047 } else if (this.isSetIa()) {
22048 oprot.writeFieldBegin(IA_FIELD_DESC);
22049 this.ia.write(oprot);
22050 oprot.writeFieldEnd();
22051 }
22052 oprot.writeFieldStop();
22053 oprot.writeStructEnd();
22054 }
22055
22056 @Override
22057 public String toString() {
22058 StringBuilder sb = new StringBuilder("mutateRowTs_result(");
22059 boolean first = true;
22060
22061 sb.append("io:");
22062 if (this.io == null) {
22063 sb.append("null");
22064 } else {
22065 sb.append(this.io);
22066 }
22067 first = false;
22068 if (!first) sb.append(", ");
22069 sb.append("ia:");
22070 if (this.ia == null) {
22071 sb.append("null");
22072 } else {
22073 sb.append(this.ia);
22074 }
22075 first = false;
22076 sb.append(")");
22077 return sb.toString();
22078 }
22079
22080 public void validate() throws TException {
22081
22082 }
22083
22084 }
22085
22086 public static class mutateRows_args implements TBase<mutateRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_args> {
22087 private static final TStruct STRUCT_DESC = new TStruct("mutateRows_args");
22088
22089 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
22090 private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2);
22091
22092
22093
22094
22095 public byte[] tableName;
22096
22097
22098
22099 public List<BatchMutation> rowBatches;
22100
22101
22102 public enum _Fields implements TFieldIdEnum {
22103
22104
22105
22106 TABLE_NAME((short)1, "tableName"),
22107
22108
22109
22110 ROW_BATCHES((short)2, "rowBatches");
22111
22112 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22113 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22114
22115 static {
22116 for (_Fields field : EnumSet.allOf(_Fields.class)) {
22117 byId.put((int)field._thriftId, field);
22118 byName.put(field.getFieldName(), field);
22119 }
22120 }
22121
22122
22123
22124
22125 public static _Fields findByThriftId(int fieldId) {
22126 return byId.get(fieldId);
22127 }
22128
22129
22130
22131
22132
22133 public static _Fields findByThriftIdOrThrow(int fieldId) {
22134 _Fields fields = findByThriftId(fieldId);
22135 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22136 return fields;
22137 }
22138
22139
22140
22141
22142 public static _Fields findByName(String name) {
22143 return byName.get(name);
22144 }
22145
22146 private final short _thriftId;
22147 private final String _fieldName;
22148
22149 _Fields(short thriftId, String fieldName) {
22150 _thriftId = thriftId;
22151 _fieldName = fieldName;
22152 }
22153
22154 public short getThriftFieldId() {
22155 return _thriftId;
22156 }
22157
22158 public String getFieldName() {
22159 return _fieldName;
22160 }
22161 }
22162
22163
22164
22165 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22166 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
22167 new FieldValueMetaData(TType.STRING)));
22168 put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT,
22169 new ListMetaData(TType.LIST,
22170 new StructMetaData(TType.STRUCT, BatchMutation.class))));
22171 }});
22172
22173 static {
22174 FieldMetaData.addStructMetaDataMap(mutateRows_args.class, metaDataMap);
22175 }
22176
22177 public mutateRows_args() {
22178 }
22179
22180 public mutateRows_args(
22181 byte[] tableName,
22182 List<BatchMutation> rowBatches)
22183 {
22184 this();
22185 this.tableName = tableName;
22186 this.rowBatches = rowBatches;
22187 }
22188
22189
22190
22191
22192 public mutateRows_args(mutateRows_args other) {
22193 if (other.isSetTableName()) {
22194 this.tableName = other.tableName;
22195 }
22196 if (other.isSetRowBatches()) {
22197 List<BatchMutation> __this__rowBatches = new ArrayList<BatchMutation>();
22198 for (BatchMutation other_element : other.rowBatches) {
22199 __this__rowBatches.add(new BatchMutation(other_element));
22200 }
22201 this.rowBatches = __this__rowBatches;
22202 }
22203 }
22204
22205 public mutateRows_args deepCopy() {
22206 return new mutateRows_args(this);
22207 }
22208
22209 @Deprecated
22210 public mutateRows_args clone() {
22211 return new mutateRows_args(this);
22212 }
22213
22214
22215
22216
22217 public byte[] getTableName() {
22218 return this.tableName;
22219 }
22220
22221
22222
22223
22224 public mutateRows_args setTableName(byte[] tableName) {
22225 this.tableName = tableName;
22226 return this;
22227 }
22228
22229 public void unsetTableName() {
22230 this.tableName = null;
22231 }
22232
22233
22234 public boolean isSetTableName() {
22235 return this.tableName != null;
22236 }
22237
22238 public void setTableNameIsSet(boolean value) {
22239 if (!value) {
22240 this.tableName = null;
22241 }
22242 }
22243
22244 public int getRowBatchesSize() {
22245 return (this.rowBatches == null) ? 0 : this.rowBatches.size();
22246 }
22247
22248 public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
22249 return (this.rowBatches == null) ? null : this.rowBatches.iterator();
22250 }
22251
22252 public void addToRowBatches(BatchMutation elem) {
22253 if (this.rowBatches == null) {
22254 this.rowBatches = new ArrayList<BatchMutation>();
22255 }
22256 this.rowBatches.add(elem);
22257 }
22258
22259
22260
22261
22262 public List<BatchMutation> getRowBatches() {
22263 return this.rowBatches;
22264 }
22265
22266
22267
22268
22269 public mutateRows_args setRowBatches(List<BatchMutation> rowBatches) {
22270 this.rowBatches = rowBatches;
22271 return this;
22272 }
22273
22274 public void unsetRowBatches() {
22275 this.rowBatches = null;
22276 }
22277
22278
22279 public boolean isSetRowBatches() {
22280 return this.rowBatches != null;
22281 }
22282
22283 public void setRowBatchesIsSet(boolean value) {
22284 if (!value) {
22285 this.rowBatches = null;
22286 }
22287 }
22288
22289 public void setFieldValue(_Fields field, Object value) {
22290 switch (field) {
22291 case TABLE_NAME:
22292 if (value == null) {
22293 unsetTableName();
22294 } else {
22295 setTableName((byte[])value);
22296 }
22297 break;
22298
22299 case ROW_BATCHES:
22300 if (value == null) {
22301 unsetRowBatches();
22302 } else {
22303 setRowBatches((List<BatchMutation>)value);
22304 }
22305 break;
22306
22307 }
22308 }
22309
22310 public void setFieldValue(int fieldID, Object value) {
22311 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
22312 }
22313
22314 public Object getFieldValue(_Fields field) {
22315 switch (field) {
22316 case TABLE_NAME:
22317 return getTableName();
22318
22319 case ROW_BATCHES:
22320 return getRowBatches();
22321
22322 }
22323 throw new IllegalStateException();
22324 }
22325
22326 public Object getFieldValue(int fieldId) {
22327 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
22328 }
22329
22330
22331 public boolean isSet(_Fields field) {
22332 switch (field) {
22333 case TABLE_NAME:
22334 return isSetTableName();
22335 case ROW_BATCHES:
22336 return isSetRowBatches();
22337 }
22338 throw new IllegalStateException();
22339 }
22340
22341 public boolean isSet(int fieldID) {
22342 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
22343 }
22344
22345 @Override
22346 public boolean equals(Object that) {
22347 if (that == null)
22348 return false;
22349 if (that instanceof mutateRows_args)
22350 return this.equals((mutateRows_args)that);
22351 return false;
22352 }
22353
22354 public boolean equals(mutateRows_args that) {
22355 if (that == null)
22356 return false;
22357
22358 boolean this_present_tableName = true && this.isSetTableName();
22359 boolean that_present_tableName = true && that.isSetTableName();
22360 if (this_present_tableName || that_present_tableName) {
22361 if (!(this_present_tableName && that_present_tableName))
22362 return false;
22363 if (!java.util.Arrays.equals(this.tableName, that.tableName))
22364 return false;
22365 }
22366
22367 boolean this_present_rowBatches = true && this.isSetRowBatches();
22368 boolean that_present_rowBatches = true && that.isSetRowBatches();
22369 if (this_present_rowBatches || that_present_rowBatches) {
22370 if (!(this_present_rowBatches && that_present_rowBatches))
22371 return false;
22372 if (!this.rowBatches.equals(that.rowBatches))
22373 return false;
22374 }
22375
22376 return true;
22377 }
22378
22379 @Override
22380 public int hashCode() {
22381 HashCodeBuilder builder = new HashCodeBuilder();
22382
22383 boolean present_tableName = true && (isSetTableName());
22384 builder.append(present_tableName);
22385 if (present_tableName)
22386 builder.append(tableName);
22387
22388 boolean present_rowBatches = true && (isSetRowBatches());
22389 builder.append(present_rowBatches);
22390 if (present_rowBatches)
22391 builder.append(rowBatches);
22392
22393 return builder.toHashCode();
22394 }
22395
22396 public int compareTo(mutateRows_args other) {
22397 if (!getClass().equals(other.getClass())) {
22398 return getClass().getName().compareTo(other.getClass().getName());
22399 }
22400
22401 int lastComparison = 0;
22402 mutateRows_args typedOther = (mutateRows_args)other;
22403
22404 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
22405 if (lastComparison != 0) {
22406 return lastComparison;
22407 }
22408 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
22409 if (lastComparison != 0) {
22410 return lastComparison;
22411 }
22412 lastComparison = Boolean.valueOf(isSetRowBatches()).compareTo(isSetRowBatches());
22413 if (lastComparison != 0) {
22414 return lastComparison;
22415 }
22416 lastComparison = TBaseHelper.compareTo(rowBatches, typedOther.rowBatches);
22417 if (lastComparison != 0) {
22418 return lastComparison;
22419 }
22420 return 0;
22421 }
22422
22423 public void read(TProtocol iprot) throws TException {
22424 TField field;
22425 iprot.readStructBegin();
22426 while (true)
22427 {
22428 field = iprot.readFieldBegin();
22429 if (field.type == TType.STOP) {
22430 break;
22431 }
22432 _Fields fieldId = _Fields.findByThriftId(field.id);
22433 if (fieldId == null) {
22434 TProtocolUtil.skip(iprot, field.type);
22435 } else {
22436 switch (fieldId) {
22437 case TABLE_NAME:
22438 if (field.type == TType.STRING) {
22439 this.tableName = iprot.readBinary();
22440 } else {
22441 TProtocolUtil.skip(iprot, field.type);
22442 }
22443 break;
22444 case ROW_BATCHES:
22445 if (field.type == TType.LIST) {
22446 {
22447 TList _list110 = iprot.readListBegin();
22448 this.rowBatches = new ArrayList<BatchMutation>(_list110.size);
22449 for (int _i111 = 0; _i111 < _list110.size; ++_i111)
22450 {
22451 BatchMutation _elem112;
22452 _elem112 = new BatchMutation();
22453 _elem112.read(iprot);
22454 this.rowBatches.add(_elem112);
22455 }
22456 iprot.readListEnd();
22457 }
22458 } else {
22459 TProtocolUtil.skip(iprot, field.type);
22460 }
22461 break;
22462 }
22463 iprot.readFieldEnd();
22464 }
22465 }
22466 iprot.readStructEnd();
22467
22468
22469 validate();
22470 }
22471
22472 public void write(TProtocol oprot) throws TException {
22473 validate();
22474
22475 oprot.writeStructBegin(STRUCT_DESC);
22476 if (this.tableName != null) {
22477 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
22478 oprot.writeBinary(this.tableName);
22479 oprot.writeFieldEnd();
22480 }
22481 if (this.rowBatches != null) {
22482 oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
22483 {
22484 oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size()));
22485 for (BatchMutation _iter113 : this.rowBatches)
22486 {
22487 _iter113.write(oprot);
22488 }
22489 oprot.writeListEnd();
22490 }
22491 oprot.writeFieldEnd();
22492 }
22493 oprot.writeFieldStop();
22494 oprot.writeStructEnd();
22495 }
22496
22497 @Override
22498 public String toString() {
22499 StringBuilder sb = new StringBuilder("mutateRows_args(");
22500 boolean first = true;
22501
22502 sb.append("tableName:");
22503 if (this.tableName == null) {
22504 sb.append("null");
22505 } else {
22506 sb.append(this.tableName);
22507 }
22508 first = false;
22509 if (!first) sb.append(", ");
22510 sb.append("rowBatches:");
22511 if (this.rowBatches == null) {
22512 sb.append("null");
22513 } else {
22514 sb.append(this.rowBatches);
22515 }
22516 first = false;
22517 sb.append(")");
22518 return sb.toString();
22519 }
22520
22521 public void validate() throws TException {
22522
22523 }
22524
22525 }
22526
22527 public static class mutateRows_result implements TBase<mutateRows_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_result> {
22528 private static final TStruct STRUCT_DESC = new TStruct("mutateRows_result");
22529
22530 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
22531 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
22532
22533 public IOError io;
22534 public IllegalArgument ia;
22535
22536
22537 public enum _Fields implements TFieldIdEnum {
22538 IO((short)1, "io"),
22539 IA((short)2, "ia");
22540
22541 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22542 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22543
22544 static {
22545 for (_Fields field : EnumSet.allOf(_Fields.class)) {
22546 byId.put((int)field._thriftId, field);
22547 byName.put(field.getFieldName(), field);
22548 }
22549 }
22550
22551
22552
22553
22554 public static _Fields findByThriftId(int fieldId) {
22555 return byId.get(fieldId);
22556 }
22557
22558
22559
22560
22561
22562 public static _Fields findByThriftIdOrThrow(int fieldId) {
22563 _Fields fields = findByThriftId(fieldId);
22564 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22565 return fields;
22566 }
22567
22568
22569
22570
22571 public static _Fields findByName(String name) {
22572 return byName.get(name);
22573 }
22574
22575 private final short _thriftId;
22576 private final String _fieldName;
22577
22578 _Fields(short thriftId, String fieldName) {
22579 _thriftId = thriftId;
22580 _fieldName = fieldName;
22581 }
22582
22583 public short getThriftFieldId() {
22584 return _thriftId;
22585 }
22586
22587 public String getFieldName() {
22588 return _fieldName;
22589 }
22590 }
22591
22592
22593
22594 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22595 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
22596 new FieldValueMetaData(TType.STRUCT)));
22597 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
22598 new FieldValueMetaData(TType.STRUCT)));
22599 }});
22600
22601 static {
22602 FieldMetaData.addStructMetaDataMap(mutateRows_result.class, metaDataMap);
22603 }
22604
22605 public mutateRows_result() {
22606 }
22607
22608 public mutateRows_result(
22609 IOError io,
22610 IllegalArgument ia)
22611 {
22612 this();
22613 this.io = io;
22614 this.ia = ia;
22615 }
22616
22617
22618
22619
22620 public mutateRows_result(mutateRows_result other) {
22621 if (other.isSetIo()) {
22622 this.io = new IOError(other.io);
22623 }
22624 if (other.isSetIa()) {
22625 this.ia = new IllegalArgument(other.ia);
22626 }
22627 }
22628
22629 public mutateRows_result deepCopy() {
22630 return new mutateRows_result(this);
22631 }
22632
22633 @Deprecated
22634 public mutateRows_result clone() {
22635 return new mutateRows_result(this);
22636 }
22637
22638 public IOError getIo() {
22639 return this.io;
22640 }
22641
22642 public mutateRows_result setIo(IOError io) {
22643 this.io = io;
22644 return this;
22645 }
22646
22647 public void unsetIo() {
22648 this.io = null;
22649 }
22650
22651
22652 public boolean isSetIo() {
22653 return this.io != null;
22654 }
22655
22656 public void setIoIsSet(boolean value) {
22657 if (!value) {
22658 this.io = null;
22659 }
22660 }
22661
22662 public IllegalArgument getIa() {
22663 return this.ia;
22664 }
22665
22666 public mutateRows_result setIa(IllegalArgument ia) {
22667 this.ia = ia;
22668 return this;
22669 }
22670
22671 public void unsetIa() {
22672 this.ia = null;
22673 }
22674
22675
22676 public boolean isSetIa() {
22677 return this.ia != null;
22678 }
22679
22680 public void setIaIsSet(boolean value) {
22681 if (!value) {
22682 this.ia = null;
22683 }
22684 }
22685
22686 public void setFieldValue(_Fields field, Object value) {
22687 switch (field) {
22688 case IO:
22689 if (value == null) {
22690 unsetIo();
22691 } else {
22692 setIo((IOError)value);
22693 }
22694 break;
22695
22696 case IA:
22697 if (value == null) {
22698 unsetIa();
22699 } else {
22700 setIa((IllegalArgument)value);
22701 }
22702 break;
22703
22704 }
22705 }
22706
22707 public void setFieldValue(int fieldID, Object value) {
22708 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
22709 }
22710
22711 public Object getFieldValue(_Fields field) {
22712 switch (field) {
22713 case IO:
22714 return getIo();
22715
22716 case IA:
22717 return getIa();
22718
22719 }
22720 throw new IllegalStateException();
22721 }
22722
22723 public Object getFieldValue(int fieldId) {
22724 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
22725 }
22726
22727
22728 public boolean isSet(_Fields field) {
22729 switch (field) {
22730 case IO:
22731 return isSetIo();
22732 case IA:
22733 return isSetIa();
22734 }
22735 throw new IllegalStateException();
22736 }
22737
22738 public boolean isSet(int fieldID) {
22739 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
22740 }
22741
22742 @Override
22743 public boolean equals(Object that) {
22744 if (that == null)
22745 return false;
22746 if (that instanceof mutateRows_result)
22747 return this.equals((mutateRows_result)that);
22748 return false;
22749 }
22750
22751 public boolean equals(mutateRows_result that) {
22752 if (that == null)
22753 return false;
22754
22755 boolean this_present_io = true && this.isSetIo();
22756 boolean that_present_io = true && that.isSetIo();
22757 if (this_present_io || that_present_io) {
22758 if (!(this_present_io && that_present_io))
22759 return false;
22760 if (!this.io.equals(that.io))
22761 return false;
22762 }
22763
22764 boolean this_present_ia = true && this.isSetIa();
22765 boolean that_present_ia = true && that.isSetIa();
22766 if (this_present_ia || that_present_ia) {
22767 if (!(this_present_ia && that_present_ia))
22768 return false;
22769 if (!this.ia.equals(that.ia))
22770 return false;
22771 }
22772
22773 return true;
22774 }
22775
22776 @Override
22777 public int hashCode() {
22778 HashCodeBuilder builder = new HashCodeBuilder();
22779
22780 boolean present_io = true && (isSetIo());
22781 builder.append(present_io);
22782 if (present_io)
22783 builder.append(io);
22784
22785 boolean present_ia = true && (isSetIa());
22786 builder.append(present_ia);
22787 if (present_ia)
22788 builder.append(ia);
22789
22790 return builder.toHashCode();
22791 }
22792
22793 public int compareTo(mutateRows_result other) {
22794 if (!getClass().equals(other.getClass())) {
22795 return getClass().getName().compareTo(other.getClass().getName());
22796 }
22797
22798 int lastComparison = 0;
22799 mutateRows_result typedOther = (mutateRows_result)other;
22800
22801 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
22802 if (lastComparison != 0) {
22803 return lastComparison;
22804 }
22805 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
22806 if (lastComparison != 0) {
22807 return lastComparison;
22808 }
22809 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
22810 if (lastComparison != 0) {
22811 return lastComparison;
22812 }
22813 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
22814 if (lastComparison != 0) {
22815 return lastComparison;
22816 }
22817 return 0;
22818 }
22819
22820 public void read(TProtocol iprot) throws TException {
22821 TField field;
22822 iprot.readStructBegin();
22823 while (true)
22824 {
22825 field = iprot.readFieldBegin();
22826 if (field.type == TType.STOP) {
22827 break;
22828 }
22829 _Fields fieldId = _Fields.findByThriftId(field.id);
22830 if (fieldId == null) {
22831 TProtocolUtil.skip(iprot, field.type);
22832 } else {
22833 switch (fieldId) {
22834 case IO:
22835 if (field.type == TType.STRUCT) {
22836 this.io = new IOError();
22837 this.io.read(iprot);
22838 } else {
22839 TProtocolUtil.skip(iprot, field.type);
22840 }
22841 break;
22842 case IA:
22843 if (field.type == TType.STRUCT) {
22844 this.ia = new IllegalArgument();
22845 this.ia.read(iprot);
22846 } else {
22847 TProtocolUtil.skip(iprot, field.type);
22848 }
22849 break;
22850 }
22851 iprot.readFieldEnd();
22852 }
22853 }
22854 iprot.readStructEnd();
22855
22856
22857 validate();
22858 }
22859
22860 public void write(TProtocol oprot) throws TException {
22861 oprot.writeStructBegin(STRUCT_DESC);
22862
22863 if (this.isSetIo()) {
22864 oprot.writeFieldBegin(IO_FIELD_DESC);
22865 this.io.write(oprot);
22866 oprot.writeFieldEnd();
22867 } else if (this.isSetIa()) {
22868 oprot.writeFieldBegin(IA_FIELD_DESC);
22869 this.ia.write(oprot);
22870 oprot.writeFieldEnd();
22871 }
22872 oprot.writeFieldStop();
22873 oprot.writeStructEnd();
22874 }
22875
22876 @Override
22877 public String toString() {
22878 StringBuilder sb = new StringBuilder("mutateRows_result(");
22879 boolean first = true;
22880
22881 sb.append("io:");
22882 if (this.io == null) {
22883 sb.append("null");
22884 } else {
22885 sb.append(this.io);
22886 }
22887 first = false;
22888 if (!first) sb.append(", ");
22889 sb.append("ia:");
22890 if (this.ia == null) {
22891 sb.append("null");
22892 } else {
22893 sb.append(this.ia);
22894 }
22895 first = false;
22896 sb.append(")");
22897 return sb.toString();
22898 }
22899
22900 public void validate() throws TException {
22901
22902 }
22903
22904 }
22905
22906 public static class mutateRowsTs_args implements TBase<mutateRowsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_args> {
22907 private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_args");
22908
22909 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
22910 private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2);
22911 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
22912
22913
22914
22915
22916 public byte[] tableName;
22917
22918
22919
22920 public List<BatchMutation> rowBatches;
22921
22922
22923
22924 public long timestamp;
22925
22926
22927 public enum _Fields implements TFieldIdEnum {
22928
22929
22930
22931 TABLE_NAME((short)1, "tableName"),
22932
22933
22934
22935 ROW_BATCHES((short)2, "rowBatches"),
22936
22937
22938
22939 TIMESTAMP((short)3, "timestamp");
22940
22941 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22942 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22943
22944 static {
22945 for (_Fields field : EnumSet.allOf(_Fields.class)) {
22946 byId.put((int)field._thriftId, field);
22947 byName.put(field.getFieldName(), field);
22948 }
22949 }
22950
22951
22952
22953
22954 public static _Fields findByThriftId(int fieldId) {
22955 return byId.get(fieldId);
22956 }
22957
22958
22959
22960
22961
22962 public static _Fields findByThriftIdOrThrow(int fieldId) {
22963 _Fields fields = findByThriftId(fieldId);
22964 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22965 return fields;
22966 }
22967
22968
22969
22970
22971 public static _Fields findByName(String name) {
22972 return byName.get(name);
22973 }
22974
22975 private final short _thriftId;
22976 private final String _fieldName;
22977
22978 _Fields(short thriftId, String fieldName) {
22979 _thriftId = thriftId;
22980 _fieldName = fieldName;
22981 }
22982
22983 public short getThriftFieldId() {
22984 return _thriftId;
22985 }
22986
22987 public String getFieldName() {
22988 return _fieldName;
22989 }
22990 }
22991
22992
22993 private static final int __TIMESTAMP_ISSET_ID = 0;
22994 private BitSet __isset_bit_vector = new BitSet(1);
22995
22996 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22997 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
22998 new FieldValueMetaData(TType.STRING)));
22999 put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT,
23000 new ListMetaData(TType.LIST,
23001 new StructMetaData(TType.STRUCT, BatchMutation.class))));
23002 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
23003 new FieldValueMetaData(TType.I64)));
23004 }});
23005
23006 static {
23007 FieldMetaData.addStructMetaDataMap(mutateRowsTs_args.class, metaDataMap);
23008 }
23009
23010 public mutateRowsTs_args() {
23011 }
23012
23013 public mutateRowsTs_args(
23014 byte[] tableName,
23015 List<BatchMutation> rowBatches,
23016 long timestamp)
23017 {
23018 this();
23019 this.tableName = tableName;
23020 this.rowBatches = rowBatches;
23021 this.timestamp = timestamp;
23022 setTimestampIsSet(true);
23023 }
23024
23025
23026
23027
23028 public mutateRowsTs_args(mutateRowsTs_args other) {
23029 __isset_bit_vector.clear();
23030 __isset_bit_vector.or(other.__isset_bit_vector);
23031 if (other.isSetTableName()) {
23032 this.tableName = other.tableName;
23033 }
23034 if (other.isSetRowBatches()) {
23035 List<BatchMutation> __this__rowBatches = new ArrayList<BatchMutation>();
23036 for (BatchMutation other_element : other.rowBatches) {
23037 __this__rowBatches.add(new BatchMutation(other_element));
23038 }
23039 this.rowBatches = __this__rowBatches;
23040 }
23041 this.timestamp = other.timestamp;
23042 }
23043
23044 public mutateRowsTs_args deepCopy() {
23045 return new mutateRowsTs_args(this);
23046 }
23047
23048 @Deprecated
23049 public mutateRowsTs_args clone() {
23050 return new mutateRowsTs_args(this);
23051 }
23052
23053
23054
23055
23056 public byte[] getTableName() {
23057 return this.tableName;
23058 }
23059
23060
23061
23062
23063 public mutateRowsTs_args setTableName(byte[] tableName) {
23064 this.tableName = tableName;
23065 return this;
23066 }
23067
23068 public void unsetTableName() {
23069 this.tableName = null;
23070 }
23071
23072
23073 public boolean isSetTableName() {
23074 return this.tableName != null;
23075 }
23076
23077 public void setTableNameIsSet(boolean value) {
23078 if (!value) {
23079 this.tableName = null;
23080 }
23081 }
23082
23083 public int getRowBatchesSize() {
23084 return (this.rowBatches == null) ? 0 : this.rowBatches.size();
23085 }
23086
23087 public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
23088 return (this.rowBatches == null) ? null : this.rowBatches.iterator();
23089 }
23090
23091 public void addToRowBatches(BatchMutation elem) {
23092 if (this.rowBatches == null) {
23093 this.rowBatches = new ArrayList<BatchMutation>();
23094 }
23095 this.rowBatches.add(elem);
23096 }
23097
23098
23099
23100
23101 public List<BatchMutation> getRowBatches() {
23102 return this.rowBatches;
23103 }
23104
23105
23106
23107
23108 public mutateRowsTs_args setRowBatches(List<BatchMutation> rowBatches) {
23109 this.rowBatches = rowBatches;
23110 return this;
23111 }
23112
23113 public void unsetRowBatches() {
23114 this.rowBatches = null;
23115 }
23116
23117
23118 public boolean isSetRowBatches() {
23119 return this.rowBatches != null;
23120 }
23121
23122 public void setRowBatchesIsSet(boolean value) {
23123 if (!value) {
23124 this.rowBatches = null;
23125 }
23126 }
23127
23128
23129
23130
23131 public long getTimestamp() {
23132 return this.timestamp;
23133 }
23134
23135
23136
23137
23138 public mutateRowsTs_args setTimestamp(long timestamp) {
23139 this.timestamp = timestamp;
23140 setTimestampIsSet(true);
23141 return this;
23142 }
23143
23144 public void unsetTimestamp() {
23145 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
23146 }
23147
23148
23149 public boolean isSetTimestamp() {
23150 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
23151 }
23152
23153 public void setTimestampIsSet(boolean value) {
23154 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
23155 }
23156
23157 public void setFieldValue(_Fields field, Object value) {
23158 switch (field) {
23159 case TABLE_NAME:
23160 if (value == null) {
23161 unsetTableName();
23162 } else {
23163 setTableName((byte[])value);
23164 }
23165 break;
23166
23167 case ROW_BATCHES:
23168 if (value == null) {
23169 unsetRowBatches();
23170 } else {
23171 setRowBatches((List<BatchMutation>)value);
23172 }
23173 break;
23174
23175 case TIMESTAMP:
23176 if (value == null) {
23177 unsetTimestamp();
23178 } else {
23179 setTimestamp((Long)value);
23180 }
23181 break;
23182
23183 }
23184 }
23185
23186 public void setFieldValue(int fieldID, Object value) {
23187 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23188 }
23189
23190 public Object getFieldValue(_Fields field) {
23191 switch (field) {
23192 case TABLE_NAME:
23193 return getTableName();
23194
23195 case ROW_BATCHES:
23196 return getRowBatches();
23197
23198 case TIMESTAMP:
23199 return new Long(getTimestamp());
23200
23201 }
23202 throw new IllegalStateException();
23203 }
23204
23205 public Object getFieldValue(int fieldId) {
23206 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23207 }
23208
23209
23210 public boolean isSet(_Fields field) {
23211 switch (field) {
23212 case TABLE_NAME:
23213 return isSetTableName();
23214 case ROW_BATCHES:
23215 return isSetRowBatches();
23216 case TIMESTAMP:
23217 return isSetTimestamp();
23218 }
23219 throw new IllegalStateException();
23220 }
23221
23222 public boolean isSet(int fieldID) {
23223 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23224 }
23225
23226 @Override
23227 public boolean equals(Object that) {
23228 if (that == null)
23229 return false;
23230 if (that instanceof mutateRowsTs_args)
23231 return this.equals((mutateRowsTs_args)that);
23232 return false;
23233 }
23234
23235 public boolean equals(mutateRowsTs_args that) {
23236 if (that == null)
23237 return false;
23238
23239 boolean this_present_tableName = true && this.isSetTableName();
23240 boolean that_present_tableName = true && that.isSetTableName();
23241 if (this_present_tableName || that_present_tableName) {
23242 if (!(this_present_tableName && that_present_tableName))
23243 return false;
23244 if (!java.util.Arrays.equals(this.tableName, that.tableName))
23245 return false;
23246 }
23247
23248 boolean this_present_rowBatches = true && this.isSetRowBatches();
23249 boolean that_present_rowBatches = true && that.isSetRowBatches();
23250 if (this_present_rowBatches || that_present_rowBatches) {
23251 if (!(this_present_rowBatches && that_present_rowBatches))
23252 return false;
23253 if (!this.rowBatches.equals(that.rowBatches))
23254 return false;
23255 }
23256
23257 boolean this_present_timestamp = true;
23258 boolean that_present_timestamp = true;
23259 if (this_present_timestamp || that_present_timestamp) {
23260 if (!(this_present_timestamp && that_present_timestamp))
23261 return false;
23262 if (this.timestamp != that.timestamp)
23263 return false;
23264 }
23265
23266 return true;
23267 }
23268
23269 @Override
23270 public int hashCode() {
23271 HashCodeBuilder builder = new HashCodeBuilder();
23272
23273 boolean present_tableName = true && (isSetTableName());
23274 builder.append(present_tableName);
23275 if (present_tableName)
23276 builder.append(tableName);
23277
23278 boolean present_rowBatches = true && (isSetRowBatches());
23279 builder.append(present_rowBatches);
23280 if (present_rowBatches)
23281 builder.append(rowBatches);
23282
23283 boolean present_timestamp = true;
23284 builder.append(present_timestamp);
23285 if (present_timestamp)
23286 builder.append(timestamp);
23287
23288 return builder.toHashCode();
23289 }
23290
23291 public int compareTo(mutateRowsTs_args other) {
23292 if (!getClass().equals(other.getClass())) {
23293 return getClass().getName().compareTo(other.getClass().getName());
23294 }
23295
23296 int lastComparison = 0;
23297 mutateRowsTs_args typedOther = (mutateRowsTs_args)other;
23298
23299 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
23300 if (lastComparison != 0) {
23301 return lastComparison;
23302 }
23303 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
23304 if (lastComparison != 0) {
23305 return lastComparison;
23306 }
23307 lastComparison = Boolean.valueOf(isSetRowBatches()).compareTo(isSetRowBatches());
23308 if (lastComparison != 0) {
23309 return lastComparison;
23310 }
23311 lastComparison = TBaseHelper.compareTo(rowBatches, typedOther.rowBatches);
23312 if (lastComparison != 0) {
23313 return lastComparison;
23314 }
23315 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
23316 if (lastComparison != 0) {
23317 return lastComparison;
23318 }
23319 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
23320 if (lastComparison != 0) {
23321 return lastComparison;
23322 }
23323 return 0;
23324 }
23325
23326 public void read(TProtocol iprot) throws TException {
23327 TField field;
23328 iprot.readStructBegin();
23329 while (true)
23330 {
23331 field = iprot.readFieldBegin();
23332 if (field.type == TType.STOP) {
23333 break;
23334 }
23335 _Fields fieldId = _Fields.findByThriftId(field.id);
23336 if (fieldId == null) {
23337 TProtocolUtil.skip(iprot, field.type);
23338 } else {
23339 switch (fieldId) {
23340 case TABLE_NAME:
23341 if (field.type == TType.STRING) {
23342 this.tableName = iprot.readBinary();
23343 } else {
23344 TProtocolUtil.skip(iprot, field.type);
23345 }
23346 break;
23347 case ROW_BATCHES:
23348 if (field.type == TType.LIST) {
23349 {
23350 TList _list114 = iprot.readListBegin();
23351 this.rowBatches = new ArrayList<BatchMutation>(_list114.size);
23352 for (int _i115 = 0; _i115 < _list114.size; ++_i115)
23353 {
23354 BatchMutation _elem116;
23355 _elem116 = new BatchMutation();
23356 _elem116.read(iprot);
23357 this.rowBatches.add(_elem116);
23358 }
23359 iprot.readListEnd();
23360 }
23361 } else {
23362 TProtocolUtil.skip(iprot, field.type);
23363 }
23364 break;
23365 case TIMESTAMP:
23366 if (field.type == TType.I64) {
23367 this.timestamp = iprot.readI64();
23368 setTimestampIsSet(true);
23369 } else {
23370 TProtocolUtil.skip(iprot, field.type);
23371 }
23372 break;
23373 }
23374 iprot.readFieldEnd();
23375 }
23376 }
23377 iprot.readStructEnd();
23378
23379
23380 validate();
23381 }
23382
23383 public void write(TProtocol oprot) throws TException {
23384 validate();
23385
23386 oprot.writeStructBegin(STRUCT_DESC);
23387 if (this.tableName != null) {
23388 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
23389 oprot.writeBinary(this.tableName);
23390 oprot.writeFieldEnd();
23391 }
23392 if (this.rowBatches != null) {
23393 oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
23394 {
23395 oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size()));
23396 for (BatchMutation _iter117 : this.rowBatches)
23397 {
23398 _iter117.write(oprot);
23399 }
23400 oprot.writeListEnd();
23401 }
23402 oprot.writeFieldEnd();
23403 }
23404 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
23405 oprot.writeI64(this.timestamp);
23406 oprot.writeFieldEnd();
23407 oprot.writeFieldStop();
23408 oprot.writeStructEnd();
23409 }
23410
23411 @Override
23412 public String toString() {
23413 StringBuilder sb = new StringBuilder("mutateRowsTs_args(");
23414 boolean first = true;
23415
23416 sb.append("tableName:");
23417 if (this.tableName == null) {
23418 sb.append("null");
23419 } else {
23420 sb.append(this.tableName);
23421 }
23422 first = false;
23423 if (!first) sb.append(", ");
23424 sb.append("rowBatches:");
23425 if (this.rowBatches == null) {
23426 sb.append("null");
23427 } else {
23428 sb.append(this.rowBatches);
23429 }
23430 first = false;
23431 if (!first) sb.append(", ");
23432 sb.append("timestamp:");
23433 sb.append(this.timestamp);
23434 first = false;
23435 sb.append(")");
23436 return sb.toString();
23437 }
23438
23439 public void validate() throws TException {
23440
23441 }
23442
23443 }
23444
23445 public static class mutateRowsTs_result implements TBase<mutateRowsTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_result> {
23446 private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_result");
23447
23448 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
23449 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
23450
23451 public IOError io;
23452 public IllegalArgument ia;
23453
23454
23455 public enum _Fields implements TFieldIdEnum {
23456 IO((short)1, "io"),
23457 IA((short)2, "ia");
23458
23459 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23460 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23461
23462 static {
23463 for (_Fields field : EnumSet.allOf(_Fields.class)) {
23464 byId.put((int)field._thriftId, field);
23465 byName.put(field.getFieldName(), field);
23466 }
23467 }
23468
23469
23470
23471
23472 public static _Fields findByThriftId(int fieldId) {
23473 return byId.get(fieldId);
23474 }
23475
23476
23477
23478
23479
23480 public static _Fields findByThriftIdOrThrow(int fieldId) {
23481 _Fields fields = findByThriftId(fieldId);
23482 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
23483 return fields;
23484 }
23485
23486
23487
23488
23489 public static _Fields findByName(String name) {
23490 return byName.get(name);
23491 }
23492
23493 private final short _thriftId;
23494 private final String _fieldName;
23495
23496 _Fields(short thriftId, String fieldName) {
23497 _thriftId = thriftId;
23498 _fieldName = fieldName;
23499 }
23500
23501 public short getThriftFieldId() {
23502 return _thriftId;
23503 }
23504
23505 public String getFieldName() {
23506 return _fieldName;
23507 }
23508 }
23509
23510
23511
23512 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
23513 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
23514 new FieldValueMetaData(TType.STRUCT)));
23515 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
23516 new FieldValueMetaData(TType.STRUCT)));
23517 }});
23518
23519 static {
23520 FieldMetaData.addStructMetaDataMap(mutateRowsTs_result.class, metaDataMap);
23521 }
23522
23523 public mutateRowsTs_result() {
23524 }
23525
23526 public mutateRowsTs_result(
23527 IOError io,
23528 IllegalArgument ia)
23529 {
23530 this();
23531 this.io = io;
23532 this.ia = ia;
23533 }
23534
23535
23536
23537
23538 public mutateRowsTs_result(mutateRowsTs_result other) {
23539 if (other.isSetIo()) {
23540 this.io = new IOError(other.io);
23541 }
23542 if (other.isSetIa()) {
23543 this.ia = new IllegalArgument(other.ia);
23544 }
23545 }
23546
23547 public mutateRowsTs_result deepCopy() {
23548 return new mutateRowsTs_result(this);
23549 }
23550
23551 @Deprecated
23552 public mutateRowsTs_result clone() {
23553 return new mutateRowsTs_result(this);
23554 }
23555
23556 public IOError getIo() {
23557 return this.io;
23558 }
23559
23560 public mutateRowsTs_result setIo(IOError io) {
23561 this.io = io;
23562 return this;
23563 }
23564
23565 public void unsetIo() {
23566 this.io = null;
23567 }
23568
23569
23570 public boolean isSetIo() {
23571 return this.io != null;
23572 }
23573
23574 public void setIoIsSet(boolean value) {
23575 if (!value) {
23576 this.io = null;
23577 }
23578 }
23579
23580 public IllegalArgument getIa() {
23581 return this.ia;
23582 }
23583
23584 public mutateRowsTs_result setIa(IllegalArgument ia) {
23585 this.ia = ia;
23586 return this;
23587 }
23588
23589 public void unsetIa() {
23590 this.ia = null;
23591 }
23592
23593
23594 public boolean isSetIa() {
23595 return this.ia != null;
23596 }
23597
23598 public void setIaIsSet(boolean value) {
23599 if (!value) {
23600 this.ia = null;
23601 }
23602 }
23603
23604 public void setFieldValue(_Fields field, Object value) {
23605 switch (field) {
23606 case IO:
23607 if (value == null) {
23608 unsetIo();
23609 } else {
23610 setIo((IOError)value);
23611 }
23612 break;
23613
23614 case IA:
23615 if (value == null) {
23616 unsetIa();
23617 } else {
23618 setIa((IllegalArgument)value);
23619 }
23620 break;
23621
23622 }
23623 }
23624
23625 public void setFieldValue(int fieldID, Object value) {
23626 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23627 }
23628
23629 public Object getFieldValue(_Fields field) {
23630 switch (field) {
23631 case IO:
23632 return getIo();
23633
23634 case IA:
23635 return getIa();
23636
23637 }
23638 throw new IllegalStateException();
23639 }
23640
23641 public Object getFieldValue(int fieldId) {
23642 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23643 }
23644
23645
23646 public boolean isSet(_Fields field) {
23647 switch (field) {
23648 case IO:
23649 return isSetIo();
23650 case IA:
23651 return isSetIa();
23652 }
23653 throw new IllegalStateException();
23654 }
23655
23656 public boolean isSet(int fieldID) {
23657 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23658 }
23659
23660 @Override
23661 public boolean equals(Object that) {
23662 if (that == null)
23663 return false;
23664 if (that instanceof mutateRowsTs_result)
23665 return this.equals((mutateRowsTs_result)that);
23666 return false;
23667 }
23668
23669 public boolean equals(mutateRowsTs_result that) {
23670 if (that == null)
23671 return false;
23672
23673 boolean this_present_io = true && this.isSetIo();
23674 boolean that_present_io = true && that.isSetIo();
23675 if (this_present_io || that_present_io) {
23676 if (!(this_present_io && that_present_io))
23677 return false;
23678 if (!this.io.equals(that.io))
23679 return false;
23680 }
23681
23682 boolean this_present_ia = true && this.isSetIa();
23683 boolean that_present_ia = true && that.isSetIa();
23684 if (this_present_ia || that_present_ia) {
23685 if (!(this_present_ia && that_present_ia))
23686 return false;
23687 if (!this.ia.equals(that.ia))
23688 return false;
23689 }
23690
23691 return true;
23692 }
23693
23694 @Override
23695 public int hashCode() {
23696 HashCodeBuilder builder = new HashCodeBuilder();
23697
23698 boolean present_io = true && (isSetIo());
23699 builder.append(present_io);
23700 if (present_io)
23701 builder.append(io);
23702
23703 boolean present_ia = true && (isSetIa());
23704 builder.append(present_ia);
23705 if (present_ia)
23706 builder.append(ia);
23707
23708 return builder.toHashCode();
23709 }
23710
23711 public int compareTo(mutateRowsTs_result other) {
23712 if (!getClass().equals(other.getClass())) {
23713 return getClass().getName().compareTo(other.getClass().getName());
23714 }
23715
23716 int lastComparison = 0;
23717 mutateRowsTs_result typedOther = (mutateRowsTs_result)other;
23718
23719 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
23720 if (lastComparison != 0) {
23721 return lastComparison;
23722 }
23723 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
23724 if (lastComparison != 0) {
23725 return lastComparison;
23726 }
23727 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
23728 if (lastComparison != 0) {
23729 return lastComparison;
23730 }
23731 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
23732 if (lastComparison != 0) {
23733 return lastComparison;
23734 }
23735 return 0;
23736 }
23737
23738 public void read(TProtocol iprot) throws TException {
23739 TField field;
23740 iprot.readStructBegin();
23741 while (true)
23742 {
23743 field = iprot.readFieldBegin();
23744 if (field.type == TType.STOP) {
23745 break;
23746 }
23747 _Fields fieldId = _Fields.findByThriftId(field.id);
23748 if (fieldId == null) {
23749 TProtocolUtil.skip(iprot, field.type);
23750 } else {
23751 switch (fieldId) {
23752 case IO:
23753 if (field.type == TType.STRUCT) {
23754 this.io = new IOError();
23755 this.io.read(iprot);
23756 } else {
23757 TProtocolUtil.skip(iprot, field.type);
23758 }
23759 break;
23760 case IA:
23761 if (field.type == TType.STRUCT) {
23762 this.ia = new IllegalArgument();
23763 this.ia.read(iprot);
23764 } else {
23765 TProtocolUtil.skip(iprot, field.type);
23766 }
23767 break;
23768 }
23769 iprot.readFieldEnd();
23770 }
23771 }
23772 iprot.readStructEnd();
23773
23774
23775 validate();
23776 }
23777
23778 public void write(TProtocol oprot) throws TException {
23779 oprot.writeStructBegin(STRUCT_DESC);
23780
23781 if (this.isSetIo()) {
23782 oprot.writeFieldBegin(IO_FIELD_DESC);
23783 this.io.write(oprot);
23784 oprot.writeFieldEnd();
23785 } else if (this.isSetIa()) {
23786 oprot.writeFieldBegin(IA_FIELD_DESC);
23787 this.ia.write(oprot);
23788 oprot.writeFieldEnd();
23789 }
23790 oprot.writeFieldStop();
23791 oprot.writeStructEnd();
23792 }
23793
23794 @Override
23795 public String toString() {
23796 StringBuilder sb = new StringBuilder("mutateRowsTs_result(");
23797 boolean first = true;
23798
23799 sb.append("io:");
23800 if (this.io == null) {
23801 sb.append("null");
23802 } else {
23803 sb.append(this.io);
23804 }
23805 first = false;
23806 if (!first) sb.append(", ");
23807 sb.append("ia:");
23808 if (this.ia == null) {
23809 sb.append("null");
23810 } else {
23811 sb.append(this.ia);
23812 }
23813 first = false;
23814 sb.append(")");
23815 return sb.toString();
23816 }
23817
23818 public void validate() throws TException {
23819
23820 }
23821
23822 }
23823
23824 public static class atomicIncrement_args implements TBase<atomicIncrement_args._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_args> {
23825 private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_args");
23826
23827 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
23828 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
23829 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
23830 private static final TField VALUE_FIELD_DESC = new TField("value", TType.I64, (short)4);
23831
23832
23833
23834
23835 public byte[] tableName;
23836
23837
23838
23839 public byte[] row;
23840
23841
23842
23843 public byte[] column;
23844
23845
23846
23847 public long value;
23848
23849
23850 public enum _Fields implements TFieldIdEnum {
23851
23852
23853
23854 TABLE_NAME((short)1, "tableName"),
23855
23856
23857
23858 ROW((short)2, "row"),
23859
23860
23861
23862 COLUMN((short)3, "column"),
23863
23864
23865
23866 VALUE((short)4, "value");
23867
23868 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23869 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23870
23871 static {
23872 for (_Fields field : EnumSet.allOf(_Fields.class)) {
23873 byId.put((int)field._thriftId, field);
23874 byName.put(field.getFieldName(), field);
23875 }
23876 }
23877
23878
23879
23880
23881 public static _Fields findByThriftId(int fieldId) {
23882 return byId.get(fieldId);
23883 }
23884
23885
23886
23887
23888
23889 public static _Fields findByThriftIdOrThrow(int fieldId) {
23890 _Fields fields = findByThriftId(fieldId);
23891 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
23892 return fields;
23893 }
23894
23895
23896
23897
23898 public static _Fields findByName(String name) {
23899 return byName.get(name);
23900 }
23901
23902 private final short _thriftId;
23903 private final String _fieldName;
23904
23905 _Fields(short thriftId, String fieldName) {
23906 _thriftId = thriftId;
23907 _fieldName = fieldName;
23908 }
23909
23910 public short getThriftFieldId() {
23911 return _thriftId;
23912 }
23913
23914 public String getFieldName() {
23915 return _fieldName;
23916 }
23917 }
23918
23919
23920 private static final int __VALUE_ISSET_ID = 0;
23921 private BitSet __isset_bit_vector = new BitSet(1);
23922
23923 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
23924 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
23925 new FieldValueMetaData(TType.STRING)));
23926 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
23927 new FieldValueMetaData(TType.STRING)));
23928 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
23929 new FieldValueMetaData(TType.STRING)));
23930 put(_Fields.VALUE, new FieldMetaData("value", TFieldRequirementType.DEFAULT,
23931 new FieldValueMetaData(TType.I64)));
23932 }});
23933
23934 static {
23935 FieldMetaData.addStructMetaDataMap(atomicIncrement_args.class, metaDataMap);
23936 }
23937
23938 public atomicIncrement_args() {
23939 }
23940
23941 public atomicIncrement_args(
23942 byte[] tableName,
23943 byte[] row,
23944 byte[] column,
23945 long value)
23946 {
23947 this();
23948 this.tableName = tableName;
23949 this.row = row;
23950 this.column = column;
23951 this.value = value;
23952 setValueIsSet(true);
23953 }
23954
23955
23956
23957
23958 public atomicIncrement_args(atomicIncrement_args other) {
23959 __isset_bit_vector.clear();
23960 __isset_bit_vector.or(other.__isset_bit_vector);
23961 if (other.isSetTableName()) {
23962 this.tableName = other.tableName;
23963 }
23964 if (other.isSetRow()) {
23965 this.row = other.row;
23966 }
23967 if (other.isSetColumn()) {
23968 this.column = other.column;
23969 }
23970 this.value = other.value;
23971 }
23972
23973 public atomicIncrement_args deepCopy() {
23974 return new atomicIncrement_args(this);
23975 }
23976
23977 @Deprecated
23978 public atomicIncrement_args clone() {
23979 return new atomicIncrement_args(this);
23980 }
23981
23982
23983
23984
23985 public byte[] getTableName() {
23986 return this.tableName;
23987 }
23988
23989
23990
23991
23992 public atomicIncrement_args setTableName(byte[] tableName) {
23993 this.tableName = tableName;
23994 return this;
23995 }
23996
23997 public void unsetTableName() {
23998 this.tableName = null;
23999 }
24000
24001
24002 public boolean isSetTableName() {
24003 return this.tableName != null;
24004 }
24005
24006 public void setTableNameIsSet(boolean value) {
24007 if (!value) {
24008 this.tableName = null;
24009 }
24010 }
24011
24012
24013
24014
24015 public byte[] getRow() {
24016 return this.row;
24017 }
24018
24019
24020
24021
24022 public atomicIncrement_args setRow(byte[] row) {
24023 this.row = row;
24024 return this;
24025 }
24026
24027 public void unsetRow() {
24028 this.row = null;
24029 }
24030
24031
24032 public boolean isSetRow() {
24033 return this.row != null;
24034 }
24035
24036 public void setRowIsSet(boolean value) {
24037 if (!value) {
24038 this.row = null;
24039 }
24040 }
24041
24042
24043
24044
24045 public byte[] getColumn() {
24046 return this.column;
24047 }
24048
24049
24050
24051
24052 public atomicIncrement_args setColumn(byte[] column) {
24053 this.column = column;
24054 return this;
24055 }
24056
24057 public void unsetColumn() {
24058 this.column = null;
24059 }
24060
24061
24062 public boolean isSetColumn() {
24063 return this.column != null;
24064 }
24065
24066 public void setColumnIsSet(boolean value) {
24067 if (!value) {
24068 this.column = null;
24069 }
24070 }
24071
24072
24073
24074
24075 public long getValue() {
24076 return this.value;
24077 }
24078
24079
24080
24081
24082 public atomicIncrement_args setValue(long value) {
24083 this.value = value;
24084 setValueIsSet(true);
24085 return this;
24086 }
24087
24088 public void unsetValue() {
24089 __isset_bit_vector.clear(__VALUE_ISSET_ID);
24090 }
24091
24092
24093 public boolean isSetValue() {
24094 return __isset_bit_vector.get(__VALUE_ISSET_ID);
24095 }
24096
24097 public void setValueIsSet(boolean value) {
24098 __isset_bit_vector.set(__VALUE_ISSET_ID, value);
24099 }
24100
24101 public void setFieldValue(_Fields field, Object value) {
24102 switch (field) {
24103 case TABLE_NAME:
24104 if (value == null) {
24105 unsetTableName();
24106 } else {
24107 setTableName((byte[])value);
24108 }
24109 break;
24110
24111 case ROW:
24112 if (value == null) {
24113 unsetRow();
24114 } else {
24115 setRow((byte[])value);
24116 }
24117 break;
24118
24119 case COLUMN:
24120 if (value == null) {
24121 unsetColumn();
24122 } else {
24123 setColumn((byte[])value);
24124 }
24125 break;
24126
24127 case VALUE:
24128 if (value == null) {
24129 unsetValue();
24130 } else {
24131 setValue((Long)value);
24132 }
24133 break;
24134
24135 }
24136 }
24137
24138 public void setFieldValue(int fieldID, Object value) {
24139 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
24140 }
24141
24142 public Object getFieldValue(_Fields field) {
24143 switch (field) {
24144 case TABLE_NAME:
24145 return getTableName();
24146
24147 case ROW:
24148 return getRow();
24149
24150 case COLUMN:
24151 return getColumn();
24152
24153 case VALUE:
24154 return new Long(getValue());
24155
24156 }
24157 throw new IllegalStateException();
24158 }
24159
24160 public Object getFieldValue(int fieldId) {
24161 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
24162 }
24163
24164
24165 public boolean isSet(_Fields field) {
24166 switch (field) {
24167 case TABLE_NAME:
24168 return isSetTableName();
24169 case ROW:
24170 return isSetRow();
24171 case COLUMN:
24172 return isSetColumn();
24173 case VALUE:
24174 return isSetValue();
24175 }
24176 throw new IllegalStateException();
24177 }
24178
24179 public boolean isSet(int fieldID) {
24180 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
24181 }
24182
24183 @Override
24184 public boolean equals(Object that) {
24185 if (that == null)
24186 return false;
24187 if (that instanceof atomicIncrement_args)
24188 return this.equals((atomicIncrement_args)that);
24189 return false;
24190 }
24191
24192 public boolean equals(atomicIncrement_args that) {
24193 if (that == null)
24194 return false;
24195
24196 boolean this_present_tableName = true && this.isSetTableName();
24197 boolean that_present_tableName = true && that.isSetTableName();
24198 if (this_present_tableName || that_present_tableName) {
24199 if (!(this_present_tableName && that_present_tableName))
24200 return false;
24201 if (!java.util.Arrays.equals(this.tableName, that.tableName))
24202 return false;
24203 }
24204
24205 boolean this_present_row = true && this.isSetRow();
24206 boolean that_present_row = true && that.isSetRow();
24207 if (this_present_row || that_present_row) {
24208 if (!(this_present_row && that_present_row))
24209 return false;
24210 if (!java.util.Arrays.equals(this.row, that.row))
24211 return false;
24212 }
24213
24214 boolean this_present_column = true && this.isSetColumn();
24215 boolean that_present_column = true && that.isSetColumn();
24216 if (this_present_column || that_present_column) {
24217 if (!(this_present_column && that_present_column))
24218 return false;
24219 if (!java.util.Arrays.equals(this.column, that.column))
24220 return false;
24221 }
24222
24223 boolean this_present_value = true;
24224 boolean that_present_value = true;
24225 if (this_present_value || that_present_value) {
24226 if (!(this_present_value && that_present_value))
24227 return false;
24228 if (this.value != that.value)
24229 return false;
24230 }
24231
24232 return true;
24233 }
24234
24235 @Override
24236 public int hashCode() {
24237 HashCodeBuilder builder = new HashCodeBuilder();
24238
24239 boolean present_tableName = true && (isSetTableName());
24240 builder.append(present_tableName);
24241 if (present_tableName)
24242 builder.append(tableName);
24243
24244 boolean present_row = true && (isSetRow());
24245 builder.append(present_row);
24246 if (present_row)
24247 builder.append(row);
24248
24249 boolean present_column = true && (isSetColumn());
24250 builder.append(present_column);
24251 if (present_column)
24252 builder.append(column);
24253
24254 boolean present_value = true;
24255 builder.append(present_value);
24256 if (present_value)
24257 builder.append(value);
24258
24259 return builder.toHashCode();
24260 }
24261
24262 public int compareTo(atomicIncrement_args other) {
24263 if (!getClass().equals(other.getClass())) {
24264 return getClass().getName().compareTo(other.getClass().getName());
24265 }
24266
24267 int lastComparison = 0;
24268 atomicIncrement_args typedOther = (atomicIncrement_args)other;
24269
24270 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
24271 if (lastComparison != 0) {
24272 return lastComparison;
24273 }
24274 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
24275 if (lastComparison != 0) {
24276 return lastComparison;
24277 }
24278 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
24279 if (lastComparison != 0) {
24280 return lastComparison;
24281 }
24282 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
24283 if (lastComparison != 0) {
24284 return lastComparison;
24285 }
24286 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
24287 if (lastComparison != 0) {
24288 return lastComparison;
24289 }
24290 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
24291 if (lastComparison != 0) {
24292 return lastComparison;
24293 }
24294 lastComparison = Boolean.valueOf(isSetValue()).compareTo(isSetValue());
24295 if (lastComparison != 0) {
24296 return lastComparison;
24297 }
24298 lastComparison = TBaseHelper.compareTo(value, typedOther.value);
24299 if (lastComparison != 0) {
24300 return lastComparison;
24301 }
24302 return 0;
24303 }
24304
24305 public void read(TProtocol iprot) throws TException {
24306 TField field;
24307 iprot.readStructBegin();
24308 while (true)
24309 {
24310 field = iprot.readFieldBegin();
24311 if (field.type == TType.STOP) {
24312 break;
24313 }
24314 _Fields fieldId = _Fields.findByThriftId(field.id);
24315 if (fieldId == null) {
24316 TProtocolUtil.skip(iprot, field.type);
24317 } else {
24318 switch (fieldId) {
24319 case TABLE_NAME:
24320 if (field.type == TType.STRING) {
24321 this.tableName = iprot.readBinary();
24322 } else {
24323 TProtocolUtil.skip(iprot, field.type);
24324 }
24325 break;
24326 case ROW:
24327 if (field.type == TType.STRING) {
24328 this.row = iprot.readBinary();
24329 } else {
24330 TProtocolUtil.skip(iprot, field.type);
24331 }
24332 break;
24333 case COLUMN:
24334 if (field.type == TType.STRING) {
24335 this.column = iprot.readBinary();
24336 } else {
24337 TProtocolUtil.skip(iprot, field.type);
24338 }
24339 break;
24340 case VALUE:
24341 if (field.type == TType.I64) {
24342 this.value = iprot.readI64();
24343 setValueIsSet(true);
24344 } else {
24345 TProtocolUtil.skip(iprot, field.type);
24346 }
24347 break;
24348 }
24349 iprot.readFieldEnd();
24350 }
24351 }
24352 iprot.readStructEnd();
24353
24354
24355 validate();
24356 }
24357
24358 public void write(TProtocol oprot) throws TException {
24359 validate();
24360
24361 oprot.writeStructBegin(STRUCT_DESC);
24362 if (this.tableName != null) {
24363 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
24364 oprot.writeBinary(this.tableName);
24365 oprot.writeFieldEnd();
24366 }
24367 if (this.row != null) {
24368 oprot.writeFieldBegin(ROW_FIELD_DESC);
24369 oprot.writeBinary(this.row);
24370 oprot.writeFieldEnd();
24371 }
24372 if (this.column != null) {
24373 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
24374 oprot.writeBinary(this.column);
24375 oprot.writeFieldEnd();
24376 }
24377 oprot.writeFieldBegin(VALUE_FIELD_DESC);
24378 oprot.writeI64(this.value);
24379 oprot.writeFieldEnd();
24380 oprot.writeFieldStop();
24381 oprot.writeStructEnd();
24382 }
24383
24384 @Override
24385 public String toString() {
24386 StringBuilder sb = new StringBuilder("atomicIncrement_args(");
24387 boolean first = true;
24388
24389 sb.append("tableName:");
24390 if (this.tableName == null) {
24391 sb.append("null");
24392 } else {
24393 sb.append(this.tableName);
24394 }
24395 first = false;
24396 if (!first) sb.append(", ");
24397 sb.append("row:");
24398 if (this.row == null) {
24399 sb.append("null");
24400 } else {
24401 sb.append(this.row);
24402 }
24403 first = false;
24404 if (!first) sb.append(", ");
24405 sb.append("column:");
24406 if (this.column == null) {
24407 sb.append("null");
24408 } else {
24409 sb.append(this.column);
24410 }
24411 first = false;
24412 if (!first) sb.append(", ");
24413 sb.append("value:");
24414 sb.append(this.value);
24415 first = false;
24416 sb.append(")");
24417 return sb.toString();
24418 }
24419
24420 public void validate() throws TException {
24421
24422 }
24423
24424 }
24425
24426 public static class atomicIncrement_result implements TBase<atomicIncrement_result._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_result> {
24427 private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_result");
24428
24429 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short)0);
24430 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
24431 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
24432
24433 public long success;
24434 public IOError io;
24435 public IllegalArgument ia;
24436
24437
24438 public enum _Fields implements TFieldIdEnum {
24439 SUCCESS((short)0, "success"),
24440 IO((short)1, "io"),
24441 IA((short)2, "ia");
24442
24443 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
24444 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
24445
24446 static {
24447 for (_Fields field : EnumSet.allOf(_Fields.class)) {
24448 byId.put((int)field._thriftId, field);
24449 byName.put(field.getFieldName(), field);
24450 }
24451 }
24452
24453
24454
24455
24456 public static _Fields findByThriftId(int fieldId) {
24457 return byId.get(fieldId);
24458 }
24459
24460
24461
24462
24463
24464 public static _Fields findByThriftIdOrThrow(int fieldId) {
24465 _Fields fields = findByThriftId(fieldId);
24466 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24467 return fields;
24468 }
24469
24470
24471
24472
24473 public static _Fields findByName(String name) {
24474 return byName.get(name);
24475 }
24476
24477 private final short _thriftId;
24478 private final String _fieldName;
24479
24480 _Fields(short thriftId, String fieldName) {
24481 _thriftId = thriftId;
24482 _fieldName = fieldName;
24483 }
24484
24485 public short getThriftFieldId() {
24486 return _thriftId;
24487 }
24488
24489 public String getFieldName() {
24490 return _fieldName;
24491 }
24492 }
24493
24494
24495 private static final int __SUCCESS_ISSET_ID = 0;
24496 private BitSet __isset_bit_vector = new BitSet(1);
24497
24498 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24499 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
24500 new FieldValueMetaData(TType.I64)));
24501 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
24502 new FieldValueMetaData(TType.STRUCT)));
24503 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
24504 new FieldValueMetaData(TType.STRUCT)));
24505 }});
24506
24507 static {
24508 FieldMetaData.addStructMetaDataMap(atomicIncrement_result.class, metaDataMap);
24509 }
24510
24511 public atomicIncrement_result() {
24512 }
24513
24514 public atomicIncrement_result(
24515 long success,
24516 IOError io,
24517 IllegalArgument ia)
24518 {
24519 this();
24520 this.success = success;
24521 setSuccessIsSet(true);
24522 this.io = io;
24523 this.ia = ia;
24524 }
24525
24526
24527
24528
24529 public atomicIncrement_result(atomicIncrement_result other) {
24530 __isset_bit_vector.clear();
24531 __isset_bit_vector.or(other.__isset_bit_vector);
24532 this.success = other.success;
24533 if (other.isSetIo()) {
24534 this.io = new IOError(other.io);
24535 }
24536 if (other.isSetIa()) {
24537 this.ia = new IllegalArgument(other.ia);
24538 }
24539 }
24540
24541 public atomicIncrement_result deepCopy() {
24542 return new atomicIncrement_result(this);
24543 }
24544
24545 @Deprecated
24546 public atomicIncrement_result clone() {
24547 return new atomicIncrement_result(this);
24548 }
24549
24550 public long getSuccess() {
24551 return this.success;
24552 }
24553
24554 public atomicIncrement_result setSuccess(long success) {
24555 this.success = success;
24556 setSuccessIsSet(true);
24557 return this;
24558 }
24559
24560 public void unsetSuccess() {
24561 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
24562 }
24563
24564
24565 public boolean isSetSuccess() {
24566 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
24567 }
24568
24569 public void setSuccessIsSet(boolean value) {
24570 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
24571 }
24572
24573 public IOError getIo() {
24574 return this.io;
24575 }
24576
24577 public atomicIncrement_result setIo(IOError io) {
24578 this.io = io;
24579 return this;
24580 }
24581
24582 public void unsetIo() {
24583 this.io = null;
24584 }
24585
24586
24587 public boolean isSetIo() {
24588 return this.io != null;
24589 }
24590
24591 public void setIoIsSet(boolean value) {
24592 if (!value) {
24593 this.io = null;
24594 }
24595 }
24596
24597 public IllegalArgument getIa() {
24598 return this.ia;
24599 }
24600
24601 public atomicIncrement_result setIa(IllegalArgument ia) {
24602 this.ia = ia;
24603 return this;
24604 }
24605
24606 public void unsetIa() {
24607 this.ia = null;
24608 }
24609
24610
24611 public boolean isSetIa() {
24612 return this.ia != null;
24613 }
24614
24615 public void setIaIsSet(boolean value) {
24616 if (!value) {
24617 this.ia = null;
24618 }
24619 }
24620
24621 public void setFieldValue(_Fields field, Object value) {
24622 switch (field) {
24623 case SUCCESS:
24624 if (value == null) {
24625 unsetSuccess();
24626 } else {
24627 setSuccess((Long)value);
24628 }
24629 break;
24630
24631 case IO:
24632 if (value == null) {
24633 unsetIo();
24634 } else {
24635 setIo((IOError)value);
24636 }
24637 break;
24638
24639 case IA:
24640 if (value == null) {
24641 unsetIa();
24642 } else {
24643 setIa((IllegalArgument)value);
24644 }
24645 break;
24646
24647 }
24648 }
24649
24650 public void setFieldValue(int fieldID, Object value) {
24651 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
24652 }
24653
24654 public Object getFieldValue(_Fields field) {
24655 switch (field) {
24656 case SUCCESS:
24657 return new Long(getSuccess());
24658
24659 case IO:
24660 return getIo();
24661
24662 case IA:
24663 return getIa();
24664
24665 }
24666 throw new IllegalStateException();
24667 }
24668
24669 public Object getFieldValue(int fieldId) {
24670 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
24671 }
24672
24673
24674 public boolean isSet(_Fields field) {
24675 switch (field) {
24676 case SUCCESS:
24677 return isSetSuccess();
24678 case IO:
24679 return isSetIo();
24680 case IA:
24681 return isSetIa();
24682 }
24683 throw new IllegalStateException();
24684 }
24685
24686 public boolean isSet(int fieldID) {
24687 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
24688 }
24689
24690 @Override
24691 public boolean equals(Object that) {
24692 if (that == null)
24693 return false;
24694 if (that instanceof atomicIncrement_result)
24695 return this.equals((atomicIncrement_result)that);
24696 return false;
24697 }
24698
24699 public boolean equals(atomicIncrement_result that) {
24700 if (that == null)
24701 return false;
24702
24703 boolean this_present_success = true;
24704 boolean that_present_success = true;
24705 if (this_present_success || that_present_success) {
24706 if (!(this_present_success && that_present_success))
24707 return false;
24708 if (this.success != that.success)
24709 return false;
24710 }
24711
24712 boolean this_present_io = true && this.isSetIo();
24713 boolean that_present_io = true && that.isSetIo();
24714 if (this_present_io || that_present_io) {
24715 if (!(this_present_io && that_present_io))
24716 return false;
24717 if (!this.io.equals(that.io))
24718 return false;
24719 }
24720
24721 boolean this_present_ia = true && this.isSetIa();
24722 boolean that_present_ia = true && that.isSetIa();
24723 if (this_present_ia || that_present_ia) {
24724 if (!(this_present_ia && that_present_ia))
24725 return false;
24726 if (!this.ia.equals(that.ia))
24727 return false;
24728 }
24729
24730 return true;
24731 }
24732
24733 @Override
24734 public int hashCode() {
24735 HashCodeBuilder builder = new HashCodeBuilder();
24736
24737 boolean present_success = true;
24738 builder.append(present_success);
24739 if (present_success)
24740 builder.append(success);
24741
24742 boolean present_io = true && (isSetIo());
24743 builder.append(present_io);
24744 if (present_io)
24745 builder.append(io);
24746
24747 boolean present_ia = true && (isSetIa());
24748 builder.append(present_ia);
24749 if (present_ia)
24750 builder.append(ia);
24751
24752 return builder.toHashCode();
24753 }
24754
24755 public int compareTo(atomicIncrement_result other) {
24756 if (!getClass().equals(other.getClass())) {
24757 return getClass().getName().compareTo(other.getClass().getName());
24758 }
24759
24760 int lastComparison = 0;
24761 atomicIncrement_result typedOther = (atomicIncrement_result)other;
24762
24763 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
24764 if (lastComparison != 0) {
24765 return lastComparison;
24766 }
24767 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
24768 if (lastComparison != 0) {
24769 return lastComparison;
24770 }
24771 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
24772 if (lastComparison != 0) {
24773 return lastComparison;
24774 }
24775 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
24776 if (lastComparison != 0) {
24777 return lastComparison;
24778 }
24779 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
24780 if (lastComparison != 0) {
24781 return lastComparison;
24782 }
24783 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
24784 if (lastComparison != 0) {
24785 return lastComparison;
24786 }
24787 return 0;
24788 }
24789
24790 public void read(TProtocol iprot) throws TException {
24791 TField field;
24792 iprot.readStructBegin();
24793 while (true)
24794 {
24795 field = iprot.readFieldBegin();
24796 if (field.type == TType.STOP) {
24797 break;
24798 }
24799 _Fields fieldId = _Fields.findByThriftId(field.id);
24800 if (fieldId == null) {
24801 TProtocolUtil.skip(iprot, field.type);
24802 } else {
24803 switch (fieldId) {
24804 case SUCCESS:
24805 if (field.type == TType.I64) {
24806 this.success = iprot.readI64();
24807 setSuccessIsSet(true);
24808 } else {
24809 TProtocolUtil.skip(iprot, field.type);
24810 }
24811 break;
24812 case IO:
24813 if (field.type == TType.STRUCT) {
24814 this.io = new IOError();
24815 this.io.read(iprot);
24816 } else {
24817 TProtocolUtil.skip(iprot, field.type);
24818 }
24819 break;
24820 case IA:
24821 if (field.type == TType.STRUCT) {
24822 this.ia = new IllegalArgument();
24823 this.ia.read(iprot);
24824 } else {
24825 TProtocolUtil.skip(iprot, field.type);
24826 }
24827 break;
24828 }
24829 iprot.readFieldEnd();
24830 }
24831 }
24832 iprot.readStructEnd();
24833
24834
24835 validate();
24836 }
24837
24838 public void write(TProtocol oprot) throws TException {
24839 oprot.writeStructBegin(STRUCT_DESC);
24840
24841 if (this.isSetSuccess()) {
24842 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
24843 oprot.writeI64(this.success);
24844 oprot.writeFieldEnd();
24845 } else if (this.isSetIo()) {
24846 oprot.writeFieldBegin(IO_FIELD_DESC);
24847 this.io.write(oprot);
24848 oprot.writeFieldEnd();
24849 } else if (this.isSetIa()) {
24850 oprot.writeFieldBegin(IA_FIELD_DESC);
24851 this.ia.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("atomicIncrement_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 if (!first) sb.append(", ");
24875 sb.append("ia:");
24876 if (this.ia == null) {
24877 sb.append("null");
24878 } else {
24879 sb.append(this.ia);
24880 }
24881 first = false;
24882 sb.append(")");
24883 return sb.toString();
24884 }
24885
24886 public void validate() throws TException {
24887
24888 }
24889
24890 }
24891
24892 public static class deleteAll_args implements TBase<deleteAll_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_args> {
24893 private static final TStruct STRUCT_DESC = new TStruct("deleteAll_args");
24894
24895 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
24896 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
24897 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
24898
24899
24900
24901
24902 public byte[] tableName;
24903
24904
24905
24906 public byte[] row;
24907
24908
24909
24910 public byte[] column;
24911
24912
24913 public enum _Fields implements TFieldIdEnum {
24914
24915
24916
24917 TABLE_NAME((short)1, "tableName"),
24918
24919
24920
24921 ROW((short)2, "row"),
24922
24923
24924
24925 COLUMN((short)3, "column");
24926
24927 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
24928 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
24929
24930 static {
24931 for (_Fields field : EnumSet.allOf(_Fields.class)) {
24932 byId.put((int)field._thriftId, field);
24933 byName.put(field.getFieldName(), field);
24934 }
24935 }
24936
24937
24938
24939
24940 public static _Fields findByThriftId(int fieldId) {
24941 return byId.get(fieldId);
24942 }
24943
24944
24945
24946
24947
24948 public static _Fields findByThriftIdOrThrow(int fieldId) {
24949 _Fields fields = findByThriftId(fieldId);
24950 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24951 return fields;
24952 }
24953
24954
24955
24956
24957 public static _Fields findByName(String name) {
24958 return byName.get(name);
24959 }
24960
24961 private final short _thriftId;
24962 private final String _fieldName;
24963
24964 _Fields(short thriftId, String fieldName) {
24965 _thriftId = thriftId;
24966 _fieldName = fieldName;
24967 }
24968
24969 public short getThriftFieldId() {
24970 return _thriftId;
24971 }
24972
24973 public String getFieldName() {
24974 return _fieldName;
24975 }
24976 }
24977
24978
24979
24980 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24981 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
24982 new FieldValueMetaData(TType.STRING)));
24983 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
24984 new FieldValueMetaData(TType.STRING)));
24985 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
24986 new FieldValueMetaData(TType.STRING)));
24987 }});
24988
24989 static {
24990 FieldMetaData.addStructMetaDataMap(deleteAll_args.class, metaDataMap);
24991 }
24992
24993 public deleteAll_args() {
24994 }
24995
24996 public deleteAll_args(
24997 byte[] tableName,
24998 byte[] row,
24999 byte[] column)
25000 {
25001 this();
25002 this.tableName = tableName;
25003 this.row = row;
25004 this.column = column;
25005 }
25006
25007
25008
25009
25010 public deleteAll_args(deleteAll_args other) {
25011 if (other.isSetTableName()) {
25012 this.tableName = other.tableName;
25013 }
25014 if (other.isSetRow()) {
25015 this.row = other.row;
25016 }
25017 if (other.isSetColumn()) {
25018 this.column = other.column;
25019 }
25020 }
25021
25022 public deleteAll_args deepCopy() {
25023 return new deleteAll_args(this);
25024 }
25025
25026 @Deprecated
25027 public deleteAll_args clone() {
25028 return new deleteAll_args(this);
25029 }
25030
25031
25032
25033
25034 public byte[] getTableName() {
25035 return this.tableName;
25036 }
25037
25038
25039
25040
25041 public deleteAll_args setTableName(byte[] tableName) {
25042 this.tableName = tableName;
25043 return this;
25044 }
25045
25046 public void unsetTableName() {
25047 this.tableName = null;
25048 }
25049
25050
25051 public boolean isSetTableName() {
25052 return this.tableName != null;
25053 }
25054
25055 public void setTableNameIsSet(boolean value) {
25056 if (!value) {
25057 this.tableName = null;
25058 }
25059 }
25060
25061
25062
25063
25064 public byte[] getRow() {
25065 return this.row;
25066 }
25067
25068
25069
25070
25071 public deleteAll_args setRow(byte[] row) {
25072 this.row = row;
25073 return this;
25074 }
25075
25076 public void unsetRow() {
25077 this.row = null;
25078 }
25079
25080
25081 public boolean isSetRow() {
25082 return this.row != null;
25083 }
25084
25085 public void setRowIsSet(boolean value) {
25086 if (!value) {
25087 this.row = null;
25088 }
25089 }
25090
25091
25092
25093
25094 public byte[] getColumn() {
25095 return this.column;
25096 }
25097
25098
25099
25100
25101 public deleteAll_args setColumn(byte[] column) {
25102 this.column = column;
25103 return this;
25104 }
25105
25106 public void unsetColumn() {
25107 this.column = null;
25108 }
25109
25110
25111 public boolean isSetColumn() {
25112 return this.column != null;
25113 }
25114
25115 public void setColumnIsSet(boolean value) {
25116 if (!value) {
25117 this.column = null;
25118 }
25119 }
25120
25121 public void setFieldValue(_Fields field, Object value) {
25122 switch (field) {
25123 case TABLE_NAME:
25124 if (value == null) {
25125 unsetTableName();
25126 } else {
25127 setTableName((byte[])value);
25128 }
25129 break;
25130
25131 case ROW:
25132 if (value == null) {
25133 unsetRow();
25134 } else {
25135 setRow((byte[])value);
25136 }
25137 break;
25138
25139 case COLUMN:
25140 if (value == null) {
25141 unsetColumn();
25142 } else {
25143 setColumn((byte[])value);
25144 }
25145 break;
25146
25147 }
25148 }
25149
25150 public void setFieldValue(int fieldID, Object value) {
25151 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
25152 }
25153
25154 public Object getFieldValue(_Fields field) {
25155 switch (field) {
25156 case TABLE_NAME:
25157 return getTableName();
25158
25159 case ROW:
25160 return getRow();
25161
25162 case COLUMN:
25163 return getColumn();
25164
25165 }
25166 throw new IllegalStateException();
25167 }
25168
25169 public Object getFieldValue(int fieldId) {
25170 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
25171 }
25172
25173
25174 public boolean isSet(_Fields field) {
25175 switch (field) {
25176 case TABLE_NAME:
25177 return isSetTableName();
25178 case ROW:
25179 return isSetRow();
25180 case COLUMN:
25181 return isSetColumn();
25182 }
25183 throw new IllegalStateException();
25184 }
25185
25186 public boolean isSet(int fieldID) {
25187 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
25188 }
25189
25190 @Override
25191 public boolean equals(Object that) {
25192 if (that == null)
25193 return false;
25194 if (that instanceof deleteAll_args)
25195 return this.equals((deleteAll_args)that);
25196 return false;
25197 }
25198
25199 public boolean equals(deleteAll_args that) {
25200 if (that == null)
25201 return false;
25202
25203 boolean this_present_tableName = true && this.isSetTableName();
25204 boolean that_present_tableName = true && that.isSetTableName();
25205 if (this_present_tableName || that_present_tableName) {
25206 if (!(this_present_tableName && that_present_tableName))
25207 return false;
25208 if (!java.util.Arrays.equals(this.tableName, that.tableName))
25209 return false;
25210 }
25211
25212 boolean this_present_row = true && this.isSetRow();
25213 boolean that_present_row = true && that.isSetRow();
25214 if (this_present_row || that_present_row) {
25215 if (!(this_present_row && that_present_row))
25216 return false;
25217 if (!java.util.Arrays.equals(this.row, that.row))
25218 return false;
25219 }
25220
25221 boolean this_present_column = true && this.isSetColumn();
25222 boolean that_present_column = true && that.isSetColumn();
25223 if (this_present_column || that_present_column) {
25224 if (!(this_present_column && that_present_column))
25225 return false;
25226 if (!java.util.Arrays.equals(this.column, that.column))
25227 return false;
25228 }
25229
25230 return true;
25231 }
25232
25233 @Override
25234 public int hashCode() {
25235 HashCodeBuilder builder = new HashCodeBuilder();
25236
25237 boolean present_tableName = true && (isSetTableName());
25238 builder.append(present_tableName);
25239 if (present_tableName)
25240 builder.append(tableName);
25241
25242 boolean present_row = true && (isSetRow());
25243 builder.append(present_row);
25244 if (present_row)
25245 builder.append(row);
25246
25247 boolean present_column = true && (isSetColumn());
25248 builder.append(present_column);
25249 if (present_column)
25250 builder.append(column);
25251
25252 return builder.toHashCode();
25253 }
25254
25255 public int compareTo(deleteAll_args other) {
25256 if (!getClass().equals(other.getClass())) {
25257 return getClass().getName().compareTo(other.getClass().getName());
25258 }
25259
25260 int lastComparison = 0;
25261 deleteAll_args typedOther = (deleteAll_args)other;
25262
25263 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
25264 if (lastComparison != 0) {
25265 return lastComparison;
25266 }
25267 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
25268 if (lastComparison != 0) {
25269 return lastComparison;
25270 }
25271 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
25272 if (lastComparison != 0) {
25273 return lastComparison;
25274 }
25275 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
25276 if (lastComparison != 0) {
25277 return lastComparison;
25278 }
25279 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
25280 if (lastComparison != 0) {
25281 return lastComparison;
25282 }
25283 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
25284 if (lastComparison != 0) {
25285 return lastComparison;
25286 }
25287 return 0;
25288 }
25289
25290 public void read(TProtocol iprot) throws TException {
25291 TField field;
25292 iprot.readStructBegin();
25293 while (true)
25294 {
25295 field = iprot.readFieldBegin();
25296 if (field.type == TType.STOP) {
25297 break;
25298 }
25299 _Fields fieldId = _Fields.findByThriftId(field.id);
25300 if (fieldId == null) {
25301 TProtocolUtil.skip(iprot, field.type);
25302 } else {
25303 switch (fieldId) {
25304 case TABLE_NAME:
25305 if (field.type == TType.STRING) {
25306 this.tableName = iprot.readBinary();
25307 } else {
25308 TProtocolUtil.skip(iprot, field.type);
25309 }
25310 break;
25311 case ROW:
25312 if (field.type == TType.STRING) {
25313 this.row = iprot.readBinary();
25314 } else {
25315 TProtocolUtil.skip(iprot, field.type);
25316 }
25317 break;
25318 case COLUMN:
25319 if (field.type == TType.STRING) {
25320 this.column = iprot.readBinary();
25321 } else {
25322 TProtocolUtil.skip(iprot, field.type);
25323 }
25324 break;
25325 }
25326 iprot.readFieldEnd();
25327 }
25328 }
25329 iprot.readStructEnd();
25330
25331
25332 validate();
25333 }
25334
25335 public void write(TProtocol oprot) throws TException {
25336 validate();
25337
25338 oprot.writeStructBegin(STRUCT_DESC);
25339 if (this.tableName != null) {
25340 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
25341 oprot.writeBinary(this.tableName);
25342 oprot.writeFieldEnd();
25343 }
25344 if (this.row != null) {
25345 oprot.writeFieldBegin(ROW_FIELD_DESC);
25346 oprot.writeBinary(this.row);
25347 oprot.writeFieldEnd();
25348 }
25349 if (this.column != null) {
25350 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
25351 oprot.writeBinary(this.column);
25352 oprot.writeFieldEnd();
25353 }
25354 oprot.writeFieldStop();
25355 oprot.writeStructEnd();
25356 }
25357
25358 @Override
25359 public String toString() {
25360 StringBuilder sb = new StringBuilder("deleteAll_args(");
25361 boolean first = true;
25362
25363 sb.append("tableName:");
25364 if (this.tableName == null) {
25365 sb.append("null");
25366 } else {
25367 sb.append(this.tableName);
25368 }
25369 first = false;
25370 if (!first) sb.append(", ");
25371 sb.append("row:");
25372 if (this.row == null) {
25373 sb.append("null");
25374 } else {
25375 sb.append(this.row);
25376 }
25377 first = false;
25378 if (!first) sb.append(", ");
25379 sb.append("column:");
25380 if (this.column == null) {
25381 sb.append("null");
25382 } else {
25383 sb.append(this.column);
25384 }
25385 first = false;
25386 sb.append(")");
25387 return sb.toString();
25388 }
25389
25390 public void validate() throws TException {
25391
25392 }
25393
25394 }
25395
25396 public static class deleteAll_result implements TBase<deleteAll_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_result> {
25397 private static final TStruct STRUCT_DESC = new TStruct("deleteAll_result");
25398
25399 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
25400
25401 public IOError io;
25402
25403
25404 public enum _Fields implements TFieldIdEnum {
25405 IO((short)1, "io");
25406
25407 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
25408 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
25409
25410 static {
25411 for (_Fields field : EnumSet.allOf(_Fields.class)) {
25412 byId.put((int)field._thriftId, field);
25413 byName.put(field.getFieldName(), field);
25414 }
25415 }
25416
25417
25418
25419
25420 public static _Fields findByThriftId(int fieldId) {
25421 return byId.get(fieldId);
25422 }
25423
25424
25425
25426
25427
25428 public static _Fields findByThriftIdOrThrow(int fieldId) {
25429 _Fields fields = findByThriftId(fieldId);
25430 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
25431 return fields;
25432 }
25433
25434
25435
25436
25437 public static _Fields findByName(String name) {
25438 return byName.get(name);
25439 }
25440
25441 private final short _thriftId;
25442 private final String _fieldName;
25443
25444 _Fields(short thriftId, String fieldName) {
25445 _thriftId = thriftId;
25446 _fieldName = fieldName;
25447 }
25448
25449 public short getThriftFieldId() {
25450 return _thriftId;
25451 }
25452
25453 public String getFieldName() {
25454 return _fieldName;
25455 }
25456 }
25457
25458
25459
25460 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
25461 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
25462 new FieldValueMetaData(TType.STRUCT)));
25463 }});
25464
25465 static {
25466 FieldMetaData.addStructMetaDataMap(deleteAll_result.class, metaDataMap);
25467 }
25468
25469 public deleteAll_result() {
25470 }
25471
25472 public deleteAll_result(
25473 IOError io)
25474 {
25475 this();
25476 this.io = io;
25477 }
25478
25479
25480
25481
25482 public deleteAll_result(deleteAll_result other) {
25483 if (other.isSetIo()) {
25484 this.io = new IOError(other.io);
25485 }
25486 }
25487
25488 public deleteAll_result deepCopy() {
25489 return new deleteAll_result(this);
25490 }
25491
25492 @Deprecated
25493 public deleteAll_result clone() {
25494 return new deleteAll_result(this);
25495 }
25496
25497 public IOError getIo() {
25498 return this.io;
25499 }
25500
25501 public deleteAll_result setIo(IOError io) {
25502 this.io = io;
25503 return this;
25504 }
25505
25506 public void unsetIo() {
25507 this.io = null;
25508 }
25509
25510
25511 public boolean isSetIo() {
25512 return this.io != null;
25513 }
25514
25515 public void setIoIsSet(boolean value) {
25516 if (!value) {
25517 this.io = null;
25518 }
25519 }
25520
25521 public void setFieldValue(_Fields field, Object value) {
25522 switch (field) {
25523 case IO:
25524 if (value == null) {
25525 unsetIo();
25526 } else {
25527 setIo((IOError)value);
25528 }
25529 break;
25530
25531 }
25532 }
25533
25534 public void setFieldValue(int fieldID, Object value) {
25535 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
25536 }
25537
25538 public Object getFieldValue(_Fields field) {
25539 switch (field) {
25540 case IO:
25541 return getIo();
25542
25543 }
25544 throw new IllegalStateException();
25545 }
25546
25547 public Object getFieldValue(int fieldId) {
25548 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
25549 }
25550
25551
25552 public boolean isSet(_Fields field) {
25553 switch (field) {
25554 case IO:
25555 return isSetIo();
25556 }
25557 throw new IllegalStateException();
25558 }
25559
25560 public boolean isSet(int fieldID) {
25561 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
25562 }
25563
25564 @Override
25565 public boolean equals(Object that) {
25566 if (that == null)
25567 return false;
25568 if (that instanceof deleteAll_result)
25569 return this.equals((deleteAll_result)that);
25570 return false;
25571 }
25572
25573 public boolean equals(deleteAll_result that) {
25574 if (that == null)
25575 return false;
25576
25577 boolean this_present_io = true && this.isSetIo();
25578 boolean that_present_io = true && that.isSetIo();
25579 if (this_present_io || that_present_io) {
25580 if (!(this_present_io && that_present_io))
25581 return false;
25582 if (!this.io.equals(that.io))
25583 return false;
25584 }
25585
25586 return true;
25587 }
25588
25589 @Override
25590 public int hashCode() {
25591 HashCodeBuilder builder = new HashCodeBuilder();
25592
25593 boolean present_io = true && (isSetIo());
25594 builder.append(present_io);
25595 if (present_io)
25596 builder.append(io);
25597
25598 return builder.toHashCode();
25599 }
25600
25601 public int compareTo(deleteAll_result other) {
25602 if (!getClass().equals(other.getClass())) {
25603 return getClass().getName().compareTo(other.getClass().getName());
25604 }
25605
25606 int lastComparison = 0;
25607 deleteAll_result typedOther = (deleteAll_result)other;
25608
25609 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
25610 if (lastComparison != 0) {
25611 return lastComparison;
25612 }
25613 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
25614 if (lastComparison != 0) {
25615 return lastComparison;
25616 }
25617 return 0;
25618 }
25619
25620 public void read(TProtocol iprot) throws TException {
25621 TField field;
25622 iprot.readStructBegin();
25623 while (true)
25624 {
25625 field = iprot.readFieldBegin();
25626 if (field.type == TType.STOP) {
25627 break;
25628 }
25629 _Fields fieldId = _Fields.findByThriftId(field.id);
25630 if (fieldId == null) {
25631 TProtocolUtil.skip(iprot, field.type);
25632 } else {
25633 switch (fieldId) {
25634 case IO:
25635 if (field.type == TType.STRUCT) {
25636 this.io = new IOError();
25637 this.io.read(iprot);
25638 } else {
25639 TProtocolUtil.skip(iprot, field.type);
25640 }
25641 break;
25642 }
25643 iprot.readFieldEnd();
25644 }
25645 }
25646 iprot.readStructEnd();
25647
25648
25649 validate();
25650 }
25651
25652 public void write(TProtocol oprot) throws TException {
25653 oprot.writeStructBegin(STRUCT_DESC);
25654
25655 if (this.isSetIo()) {
25656 oprot.writeFieldBegin(IO_FIELD_DESC);
25657 this.io.write(oprot);
25658 oprot.writeFieldEnd();
25659 }
25660 oprot.writeFieldStop();
25661 oprot.writeStructEnd();
25662 }
25663
25664 @Override
25665 public String toString() {
25666 StringBuilder sb = new StringBuilder("deleteAll_result(");
25667 boolean first = true;
25668
25669 sb.append("io:");
25670 if (this.io == null) {
25671 sb.append("null");
25672 } else {
25673 sb.append(this.io);
25674 }
25675 first = false;
25676 sb.append(")");
25677 return sb.toString();
25678 }
25679
25680 public void validate() throws TException {
25681
25682 }
25683
25684 }
25685
25686 public static class deleteAllTs_args implements TBase<deleteAllTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_args> {
25687 private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_args");
25688
25689 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
25690 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
25691 private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
25692 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
25693
25694
25695
25696
25697 public byte[] tableName;
25698
25699
25700
25701 public byte[] row;
25702
25703
25704
25705 public byte[] column;
25706
25707
25708
25709 public long timestamp;
25710
25711
25712 public enum _Fields implements TFieldIdEnum {
25713
25714
25715
25716 TABLE_NAME((short)1, "tableName"),
25717
25718
25719
25720 ROW((short)2, "row"),
25721
25722
25723
25724 COLUMN((short)3, "column"),
25725
25726
25727
25728 TIMESTAMP((short)4, "timestamp");
25729
25730 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
25731 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
25732
25733 static {
25734 for (_Fields field : EnumSet.allOf(_Fields.class)) {
25735 byId.put((int)field._thriftId, field);
25736 byName.put(field.getFieldName(), field);
25737 }
25738 }
25739
25740
25741
25742
25743 public static _Fields findByThriftId(int fieldId) {
25744 return byId.get(fieldId);
25745 }
25746
25747
25748
25749
25750
25751 public static _Fields findByThriftIdOrThrow(int fieldId) {
25752 _Fields fields = findByThriftId(fieldId);
25753 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
25754 return fields;
25755 }
25756
25757
25758
25759
25760 public static _Fields findByName(String name) {
25761 return byName.get(name);
25762 }
25763
25764 private final short _thriftId;
25765 private final String _fieldName;
25766
25767 _Fields(short thriftId, String fieldName) {
25768 _thriftId = thriftId;
25769 _fieldName = fieldName;
25770 }
25771
25772 public short getThriftFieldId() {
25773 return _thriftId;
25774 }
25775
25776 public String getFieldName() {
25777 return _fieldName;
25778 }
25779 }
25780
25781
25782 private static final int __TIMESTAMP_ISSET_ID = 0;
25783 private BitSet __isset_bit_vector = new BitSet(1);
25784
25785 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
25786 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
25787 new FieldValueMetaData(TType.STRING)));
25788 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
25789 new FieldValueMetaData(TType.STRING)));
25790 put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
25791 new FieldValueMetaData(TType.STRING)));
25792 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
25793 new FieldValueMetaData(TType.I64)));
25794 }});
25795
25796 static {
25797 FieldMetaData.addStructMetaDataMap(deleteAllTs_args.class, metaDataMap);
25798 }
25799
25800 public deleteAllTs_args() {
25801 }
25802
25803 public deleteAllTs_args(
25804 byte[] tableName,
25805 byte[] row,
25806 byte[] column,
25807 long timestamp)
25808 {
25809 this();
25810 this.tableName = tableName;
25811 this.row = row;
25812 this.column = column;
25813 this.timestamp = timestamp;
25814 setTimestampIsSet(true);
25815 }
25816
25817
25818
25819
25820 public deleteAllTs_args(deleteAllTs_args other) {
25821 __isset_bit_vector.clear();
25822 __isset_bit_vector.or(other.__isset_bit_vector);
25823 if (other.isSetTableName()) {
25824 this.tableName = other.tableName;
25825 }
25826 if (other.isSetRow()) {
25827 this.row = other.row;
25828 }
25829 if (other.isSetColumn()) {
25830 this.column = other.column;
25831 }
25832 this.timestamp = other.timestamp;
25833 }
25834
25835 public deleteAllTs_args deepCopy() {
25836 return new deleteAllTs_args(this);
25837 }
25838
25839 @Deprecated
25840 public deleteAllTs_args clone() {
25841 return new deleteAllTs_args(this);
25842 }
25843
25844
25845
25846
25847 public byte[] getTableName() {
25848 return this.tableName;
25849 }
25850
25851
25852
25853
25854 public deleteAllTs_args setTableName(byte[] tableName) {
25855 this.tableName = tableName;
25856 return this;
25857 }
25858
25859 public void unsetTableName() {
25860 this.tableName = null;
25861 }
25862
25863
25864 public boolean isSetTableName() {
25865 return this.tableName != null;
25866 }
25867
25868 public void setTableNameIsSet(boolean value) {
25869 if (!value) {
25870 this.tableName = null;
25871 }
25872 }
25873
25874
25875
25876
25877 public byte[] getRow() {
25878 return this.row;
25879 }
25880
25881
25882
25883
25884 public deleteAllTs_args setRow(byte[] row) {
25885 this.row = row;
25886 return this;
25887 }
25888
25889 public void unsetRow() {
25890 this.row = null;
25891 }
25892
25893
25894 public boolean isSetRow() {
25895 return this.row != null;
25896 }
25897
25898 public void setRowIsSet(boolean value) {
25899 if (!value) {
25900 this.row = null;
25901 }
25902 }
25903
25904
25905
25906
25907 public byte[] getColumn() {
25908 return this.column;
25909 }
25910
25911
25912
25913
25914 public deleteAllTs_args setColumn(byte[] column) {
25915 this.column = column;
25916 return this;
25917 }
25918
25919 public void unsetColumn() {
25920 this.column = null;
25921 }
25922
25923
25924 public boolean isSetColumn() {
25925 return this.column != null;
25926 }
25927
25928 public void setColumnIsSet(boolean value) {
25929 if (!value) {
25930 this.column = null;
25931 }
25932 }
25933
25934
25935
25936
25937 public long getTimestamp() {
25938 return this.timestamp;
25939 }
25940
25941
25942
25943
25944 public deleteAllTs_args setTimestamp(long timestamp) {
25945 this.timestamp = timestamp;
25946 setTimestampIsSet(true);
25947 return this;
25948 }
25949
25950 public void unsetTimestamp() {
25951 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
25952 }
25953
25954
25955 public boolean isSetTimestamp() {
25956 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
25957 }
25958
25959 public void setTimestampIsSet(boolean value) {
25960 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
25961 }
25962
25963 public void setFieldValue(_Fields field, Object value) {
25964 switch (field) {
25965 case TABLE_NAME:
25966 if (value == null) {
25967 unsetTableName();
25968 } else {
25969 setTableName((byte[])value);
25970 }
25971 break;
25972
25973 case ROW:
25974 if (value == null) {
25975 unsetRow();
25976 } else {
25977 setRow((byte[])value);
25978 }
25979 break;
25980
25981 case COLUMN:
25982 if (value == null) {
25983 unsetColumn();
25984 } else {
25985 setColumn((byte[])value);
25986 }
25987 break;
25988
25989 case TIMESTAMP:
25990 if (value == null) {
25991 unsetTimestamp();
25992 } else {
25993 setTimestamp((Long)value);
25994 }
25995 break;
25996
25997 }
25998 }
25999
26000 public void setFieldValue(int fieldID, Object value) {
26001 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26002 }
26003
26004 public Object getFieldValue(_Fields field) {
26005 switch (field) {
26006 case TABLE_NAME:
26007 return getTableName();
26008
26009 case ROW:
26010 return getRow();
26011
26012 case COLUMN:
26013 return getColumn();
26014
26015 case TIMESTAMP:
26016 return new Long(getTimestamp());
26017
26018 }
26019 throw new IllegalStateException();
26020 }
26021
26022 public Object getFieldValue(int fieldId) {
26023 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26024 }
26025
26026
26027 public boolean isSet(_Fields field) {
26028 switch (field) {
26029 case TABLE_NAME:
26030 return isSetTableName();
26031 case ROW:
26032 return isSetRow();
26033 case COLUMN:
26034 return isSetColumn();
26035 case TIMESTAMP:
26036 return isSetTimestamp();
26037 }
26038 throw new IllegalStateException();
26039 }
26040
26041 public boolean isSet(int fieldID) {
26042 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26043 }
26044
26045 @Override
26046 public boolean equals(Object that) {
26047 if (that == null)
26048 return false;
26049 if (that instanceof deleteAllTs_args)
26050 return this.equals((deleteAllTs_args)that);
26051 return false;
26052 }
26053
26054 public boolean equals(deleteAllTs_args that) {
26055 if (that == null)
26056 return false;
26057
26058 boolean this_present_tableName = true && this.isSetTableName();
26059 boolean that_present_tableName = true && that.isSetTableName();
26060 if (this_present_tableName || that_present_tableName) {
26061 if (!(this_present_tableName && that_present_tableName))
26062 return false;
26063 if (!java.util.Arrays.equals(this.tableName, that.tableName))
26064 return false;
26065 }
26066
26067 boolean this_present_row = true && this.isSetRow();
26068 boolean that_present_row = true && that.isSetRow();
26069 if (this_present_row || that_present_row) {
26070 if (!(this_present_row && that_present_row))
26071 return false;
26072 if (!java.util.Arrays.equals(this.row, that.row))
26073 return false;
26074 }
26075
26076 boolean this_present_column = true && this.isSetColumn();
26077 boolean that_present_column = true && that.isSetColumn();
26078 if (this_present_column || that_present_column) {
26079 if (!(this_present_column && that_present_column))
26080 return false;
26081 if (!java.util.Arrays.equals(this.column, that.column))
26082 return false;
26083 }
26084
26085 boolean this_present_timestamp = true;
26086 boolean that_present_timestamp = true;
26087 if (this_present_timestamp || that_present_timestamp) {
26088 if (!(this_present_timestamp && that_present_timestamp))
26089 return false;
26090 if (this.timestamp != that.timestamp)
26091 return false;
26092 }
26093
26094 return true;
26095 }
26096
26097 @Override
26098 public int hashCode() {
26099 HashCodeBuilder builder = new HashCodeBuilder();
26100
26101 boolean present_tableName = true && (isSetTableName());
26102 builder.append(present_tableName);
26103 if (present_tableName)
26104 builder.append(tableName);
26105
26106 boolean present_row = true && (isSetRow());
26107 builder.append(present_row);
26108 if (present_row)
26109 builder.append(row);
26110
26111 boolean present_column = true && (isSetColumn());
26112 builder.append(present_column);
26113 if (present_column)
26114 builder.append(column);
26115
26116 boolean present_timestamp = true;
26117 builder.append(present_timestamp);
26118 if (present_timestamp)
26119 builder.append(timestamp);
26120
26121 return builder.toHashCode();
26122 }
26123
26124 public int compareTo(deleteAllTs_args other) {
26125 if (!getClass().equals(other.getClass())) {
26126 return getClass().getName().compareTo(other.getClass().getName());
26127 }
26128
26129 int lastComparison = 0;
26130 deleteAllTs_args typedOther = (deleteAllTs_args)other;
26131
26132 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
26133 if (lastComparison != 0) {
26134 return lastComparison;
26135 }
26136 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
26137 if (lastComparison != 0) {
26138 return lastComparison;
26139 }
26140 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
26141 if (lastComparison != 0) {
26142 return lastComparison;
26143 }
26144 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
26145 if (lastComparison != 0) {
26146 return lastComparison;
26147 }
26148 lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
26149 if (lastComparison != 0) {
26150 return lastComparison;
26151 }
26152 lastComparison = TBaseHelper.compareTo(column, typedOther.column);
26153 if (lastComparison != 0) {
26154 return lastComparison;
26155 }
26156 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
26157 if (lastComparison != 0) {
26158 return lastComparison;
26159 }
26160 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
26161 if (lastComparison != 0) {
26162 return lastComparison;
26163 }
26164 return 0;
26165 }
26166
26167 public void read(TProtocol iprot) throws TException {
26168 TField field;
26169 iprot.readStructBegin();
26170 while (true)
26171 {
26172 field = iprot.readFieldBegin();
26173 if (field.type == TType.STOP) {
26174 break;
26175 }
26176 _Fields fieldId = _Fields.findByThriftId(field.id);
26177 if (fieldId == null) {
26178 TProtocolUtil.skip(iprot, field.type);
26179 } else {
26180 switch (fieldId) {
26181 case TABLE_NAME:
26182 if (field.type == TType.STRING) {
26183 this.tableName = iprot.readBinary();
26184 } else {
26185 TProtocolUtil.skip(iprot, field.type);
26186 }
26187 break;
26188 case ROW:
26189 if (field.type == TType.STRING) {
26190 this.row = iprot.readBinary();
26191 } else {
26192 TProtocolUtil.skip(iprot, field.type);
26193 }
26194 break;
26195 case COLUMN:
26196 if (field.type == TType.STRING) {
26197 this.column = iprot.readBinary();
26198 } else {
26199 TProtocolUtil.skip(iprot, field.type);
26200 }
26201 break;
26202 case TIMESTAMP:
26203 if (field.type == TType.I64) {
26204 this.timestamp = iprot.readI64();
26205 setTimestampIsSet(true);
26206 } else {
26207 TProtocolUtil.skip(iprot, field.type);
26208 }
26209 break;
26210 }
26211 iprot.readFieldEnd();
26212 }
26213 }
26214 iprot.readStructEnd();
26215
26216
26217 validate();
26218 }
26219
26220 public void write(TProtocol oprot) throws TException {
26221 validate();
26222
26223 oprot.writeStructBegin(STRUCT_DESC);
26224 if (this.tableName != null) {
26225 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
26226 oprot.writeBinary(this.tableName);
26227 oprot.writeFieldEnd();
26228 }
26229 if (this.row != null) {
26230 oprot.writeFieldBegin(ROW_FIELD_DESC);
26231 oprot.writeBinary(this.row);
26232 oprot.writeFieldEnd();
26233 }
26234 if (this.column != null) {
26235 oprot.writeFieldBegin(COLUMN_FIELD_DESC);
26236 oprot.writeBinary(this.column);
26237 oprot.writeFieldEnd();
26238 }
26239 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
26240 oprot.writeI64(this.timestamp);
26241 oprot.writeFieldEnd();
26242 oprot.writeFieldStop();
26243 oprot.writeStructEnd();
26244 }
26245
26246 @Override
26247 public String toString() {
26248 StringBuilder sb = new StringBuilder("deleteAllTs_args(");
26249 boolean first = true;
26250
26251 sb.append("tableName:");
26252 if (this.tableName == null) {
26253 sb.append("null");
26254 } else {
26255 sb.append(this.tableName);
26256 }
26257 first = false;
26258 if (!first) sb.append(", ");
26259 sb.append("row:");
26260 if (this.row == null) {
26261 sb.append("null");
26262 } else {
26263 sb.append(this.row);
26264 }
26265 first = false;
26266 if (!first) sb.append(", ");
26267 sb.append("column:");
26268 if (this.column == null) {
26269 sb.append("null");
26270 } else {
26271 sb.append(this.column);
26272 }
26273 first = false;
26274 if (!first) sb.append(", ");
26275 sb.append("timestamp:");
26276 sb.append(this.timestamp);
26277 first = false;
26278 sb.append(")");
26279 return sb.toString();
26280 }
26281
26282 public void validate() throws TException {
26283
26284 }
26285
26286 }
26287
26288 public static class deleteAllTs_result implements TBase<deleteAllTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_result> {
26289 private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_result");
26290
26291 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
26292
26293 public IOError io;
26294
26295
26296 public enum _Fields implements TFieldIdEnum {
26297 IO((short)1, "io");
26298
26299 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26300 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26301
26302 static {
26303 for (_Fields field : EnumSet.allOf(_Fields.class)) {
26304 byId.put((int)field._thriftId, field);
26305 byName.put(field.getFieldName(), field);
26306 }
26307 }
26308
26309
26310
26311
26312 public static _Fields findByThriftId(int fieldId) {
26313 return byId.get(fieldId);
26314 }
26315
26316
26317
26318
26319
26320 public static _Fields findByThriftIdOrThrow(int fieldId) {
26321 _Fields fields = findByThriftId(fieldId);
26322 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
26323 return fields;
26324 }
26325
26326
26327
26328
26329 public static _Fields findByName(String name) {
26330 return byName.get(name);
26331 }
26332
26333 private final short _thriftId;
26334 private final String _fieldName;
26335
26336 _Fields(short thriftId, String fieldName) {
26337 _thriftId = thriftId;
26338 _fieldName = fieldName;
26339 }
26340
26341 public short getThriftFieldId() {
26342 return _thriftId;
26343 }
26344
26345 public String getFieldName() {
26346 return _fieldName;
26347 }
26348 }
26349
26350
26351
26352 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26353 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
26354 new FieldValueMetaData(TType.STRUCT)));
26355 }});
26356
26357 static {
26358 FieldMetaData.addStructMetaDataMap(deleteAllTs_result.class, metaDataMap);
26359 }
26360
26361 public deleteAllTs_result() {
26362 }
26363
26364 public deleteAllTs_result(
26365 IOError io)
26366 {
26367 this();
26368 this.io = io;
26369 }
26370
26371
26372
26373
26374 public deleteAllTs_result(deleteAllTs_result other) {
26375 if (other.isSetIo()) {
26376 this.io = new IOError(other.io);
26377 }
26378 }
26379
26380 public deleteAllTs_result deepCopy() {
26381 return new deleteAllTs_result(this);
26382 }
26383
26384 @Deprecated
26385 public deleteAllTs_result clone() {
26386 return new deleteAllTs_result(this);
26387 }
26388
26389 public IOError getIo() {
26390 return this.io;
26391 }
26392
26393 public deleteAllTs_result setIo(IOError io) {
26394 this.io = io;
26395 return this;
26396 }
26397
26398 public void unsetIo() {
26399 this.io = null;
26400 }
26401
26402
26403 public boolean isSetIo() {
26404 return this.io != null;
26405 }
26406
26407 public void setIoIsSet(boolean value) {
26408 if (!value) {
26409 this.io = null;
26410 }
26411 }
26412
26413 public void setFieldValue(_Fields field, Object value) {
26414 switch (field) {
26415 case IO:
26416 if (value == null) {
26417 unsetIo();
26418 } else {
26419 setIo((IOError)value);
26420 }
26421 break;
26422
26423 }
26424 }
26425
26426 public void setFieldValue(int fieldID, Object value) {
26427 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26428 }
26429
26430 public Object getFieldValue(_Fields field) {
26431 switch (field) {
26432 case IO:
26433 return getIo();
26434
26435 }
26436 throw new IllegalStateException();
26437 }
26438
26439 public Object getFieldValue(int fieldId) {
26440 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26441 }
26442
26443
26444 public boolean isSet(_Fields field) {
26445 switch (field) {
26446 case IO:
26447 return isSetIo();
26448 }
26449 throw new IllegalStateException();
26450 }
26451
26452 public boolean isSet(int fieldID) {
26453 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26454 }
26455
26456 @Override
26457 public boolean equals(Object that) {
26458 if (that == null)
26459 return false;
26460 if (that instanceof deleteAllTs_result)
26461 return this.equals((deleteAllTs_result)that);
26462 return false;
26463 }
26464
26465 public boolean equals(deleteAllTs_result that) {
26466 if (that == null)
26467 return false;
26468
26469 boolean this_present_io = true && this.isSetIo();
26470 boolean that_present_io = true && that.isSetIo();
26471 if (this_present_io || that_present_io) {
26472 if (!(this_present_io && that_present_io))
26473 return false;
26474 if (!this.io.equals(that.io))
26475 return false;
26476 }
26477
26478 return true;
26479 }
26480
26481 @Override
26482 public int hashCode() {
26483 HashCodeBuilder builder = new HashCodeBuilder();
26484
26485 boolean present_io = true && (isSetIo());
26486 builder.append(present_io);
26487 if (present_io)
26488 builder.append(io);
26489
26490 return builder.toHashCode();
26491 }
26492
26493 public int compareTo(deleteAllTs_result other) {
26494 if (!getClass().equals(other.getClass())) {
26495 return getClass().getName().compareTo(other.getClass().getName());
26496 }
26497
26498 int lastComparison = 0;
26499 deleteAllTs_result typedOther = (deleteAllTs_result)other;
26500
26501 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
26502 if (lastComparison != 0) {
26503 return lastComparison;
26504 }
26505 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
26506 if (lastComparison != 0) {
26507 return lastComparison;
26508 }
26509 return 0;
26510 }
26511
26512 public void read(TProtocol iprot) throws TException {
26513 TField field;
26514 iprot.readStructBegin();
26515 while (true)
26516 {
26517 field = iprot.readFieldBegin();
26518 if (field.type == TType.STOP) {
26519 break;
26520 }
26521 _Fields fieldId = _Fields.findByThriftId(field.id);
26522 if (fieldId == null) {
26523 TProtocolUtil.skip(iprot, field.type);
26524 } else {
26525 switch (fieldId) {
26526 case IO:
26527 if (field.type == TType.STRUCT) {
26528 this.io = new IOError();
26529 this.io.read(iprot);
26530 } else {
26531 TProtocolUtil.skip(iprot, field.type);
26532 }
26533 break;
26534 }
26535 iprot.readFieldEnd();
26536 }
26537 }
26538 iprot.readStructEnd();
26539
26540
26541 validate();
26542 }
26543
26544 public void write(TProtocol oprot) throws TException {
26545 oprot.writeStructBegin(STRUCT_DESC);
26546
26547 if (this.isSetIo()) {
26548 oprot.writeFieldBegin(IO_FIELD_DESC);
26549 this.io.write(oprot);
26550 oprot.writeFieldEnd();
26551 }
26552 oprot.writeFieldStop();
26553 oprot.writeStructEnd();
26554 }
26555
26556 @Override
26557 public String toString() {
26558 StringBuilder sb = new StringBuilder("deleteAllTs_result(");
26559 boolean first = true;
26560
26561 sb.append("io:");
26562 if (this.io == null) {
26563 sb.append("null");
26564 } else {
26565 sb.append(this.io);
26566 }
26567 first = false;
26568 sb.append(")");
26569 return sb.toString();
26570 }
26571
26572 public void validate() throws TException {
26573
26574 }
26575
26576 }
26577
26578 public static class deleteAllRow_args implements TBase<deleteAllRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_args> {
26579 private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_args");
26580
26581 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
26582 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
26583
26584
26585
26586
26587 public byte[] tableName;
26588
26589
26590
26591 public byte[] row;
26592
26593
26594 public enum _Fields implements TFieldIdEnum {
26595
26596
26597
26598 TABLE_NAME((short)1, "tableName"),
26599
26600
26601
26602 ROW((short)2, "row");
26603
26604 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26605 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26606
26607 static {
26608 for (_Fields field : EnumSet.allOf(_Fields.class)) {
26609 byId.put((int)field._thriftId, field);
26610 byName.put(field.getFieldName(), field);
26611 }
26612 }
26613
26614
26615
26616
26617 public static _Fields findByThriftId(int fieldId) {
26618 return byId.get(fieldId);
26619 }
26620
26621
26622
26623
26624
26625 public static _Fields findByThriftIdOrThrow(int fieldId) {
26626 _Fields fields = findByThriftId(fieldId);
26627 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
26628 return fields;
26629 }
26630
26631
26632
26633
26634 public static _Fields findByName(String name) {
26635 return byName.get(name);
26636 }
26637
26638 private final short _thriftId;
26639 private final String _fieldName;
26640
26641 _Fields(short thriftId, String fieldName) {
26642 _thriftId = thriftId;
26643 _fieldName = fieldName;
26644 }
26645
26646 public short getThriftFieldId() {
26647 return _thriftId;
26648 }
26649
26650 public String getFieldName() {
26651 return _fieldName;
26652 }
26653 }
26654
26655
26656
26657 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26658 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
26659 new FieldValueMetaData(TType.STRING)));
26660 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
26661 new FieldValueMetaData(TType.STRING)));
26662 }});
26663
26664 static {
26665 FieldMetaData.addStructMetaDataMap(deleteAllRow_args.class, metaDataMap);
26666 }
26667
26668 public deleteAllRow_args() {
26669 }
26670
26671 public deleteAllRow_args(
26672 byte[] tableName,
26673 byte[] row)
26674 {
26675 this();
26676 this.tableName = tableName;
26677 this.row = row;
26678 }
26679
26680
26681
26682
26683 public deleteAllRow_args(deleteAllRow_args other) {
26684 if (other.isSetTableName()) {
26685 this.tableName = other.tableName;
26686 }
26687 if (other.isSetRow()) {
26688 this.row = other.row;
26689 }
26690 }
26691
26692 public deleteAllRow_args deepCopy() {
26693 return new deleteAllRow_args(this);
26694 }
26695
26696 @Deprecated
26697 public deleteAllRow_args clone() {
26698 return new deleteAllRow_args(this);
26699 }
26700
26701
26702
26703
26704 public byte[] getTableName() {
26705 return this.tableName;
26706 }
26707
26708
26709
26710
26711 public deleteAllRow_args setTableName(byte[] tableName) {
26712 this.tableName = tableName;
26713 return this;
26714 }
26715
26716 public void unsetTableName() {
26717 this.tableName = null;
26718 }
26719
26720
26721 public boolean isSetTableName() {
26722 return this.tableName != null;
26723 }
26724
26725 public void setTableNameIsSet(boolean value) {
26726 if (!value) {
26727 this.tableName = null;
26728 }
26729 }
26730
26731
26732
26733
26734 public byte[] getRow() {
26735 return this.row;
26736 }
26737
26738
26739
26740
26741 public deleteAllRow_args setRow(byte[] row) {
26742 this.row = row;
26743 return this;
26744 }
26745
26746 public void unsetRow() {
26747 this.row = null;
26748 }
26749
26750
26751 public boolean isSetRow() {
26752 return this.row != null;
26753 }
26754
26755 public void setRowIsSet(boolean value) {
26756 if (!value) {
26757 this.row = null;
26758 }
26759 }
26760
26761 public void setFieldValue(_Fields field, Object value) {
26762 switch (field) {
26763 case TABLE_NAME:
26764 if (value == null) {
26765 unsetTableName();
26766 } else {
26767 setTableName((byte[])value);
26768 }
26769 break;
26770
26771 case ROW:
26772 if (value == null) {
26773 unsetRow();
26774 } else {
26775 setRow((byte[])value);
26776 }
26777 break;
26778
26779 }
26780 }
26781
26782 public void setFieldValue(int fieldID, Object value) {
26783 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26784 }
26785
26786 public Object getFieldValue(_Fields field) {
26787 switch (field) {
26788 case TABLE_NAME:
26789 return getTableName();
26790
26791 case ROW:
26792 return getRow();
26793
26794 }
26795 throw new IllegalStateException();
26796 }
26797
26798 public Object getFieldValue(int fieldId) {
26799 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26800 }
26801
26802
26803 public boolean isSet(_Fields field) {
26804 switch (field) {
26805 case TABLE_NAME:
26806 return isSetTableName();
26807 case ROW:
26808 return isSetRow();
26809 }
26810 throw new IllegalStateException();
26811 }
26812
26813 public boolean isSet(int fieldID) {
26814 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26815 }
26816
26817 @Override
26818 public boolean equals(Object that) {
26819 if (that == null)
26820 return false;
26821 if (that instanceof deleteAllRow_args)
26822 return this.equals((deleteAllRow_args)that);
26823 return false;
26824 }
26825
26826 public boolean equals(deleteAllRow_args that) {
26827 if (that == null)
26828 return false;
26829
26830 boolean this_present_tableName = true && this.isSetTableName();
26831 boolean that_present_tableName = true && that.isSetTableName();
26832 if (this_present_tableName || that_present_tableName) {
26833 if (!(this_present_tableName && that_present_tableName))
26834 return false;
26835 if (!java.util.Arrays.equals(this.tableName, that.tableName))
26836 return false;
26837 }
26838
26839 boolean this_present_row = true && this.isSetRow();
26840 boolean that_present_row = true && that.isSetRow();
26841 if (this_present_row || that_present_row) {
26842 if (!(this_present_row && that_present_row))
26843 return false;
26844 if (!java.util.Arrays.equals(this.row, that.row))
26845 return false;
26846 }
26847
26848 return true;
26849 }
26850
26851 @Override
26852 public int hashCode() {
26853 HashCodeBuilder builder = new HashCodeBuilder();
26854
26855 boolean present_tableName = true && (isSetTableName());
26856 builder.append(present_tableName);
26857 if (present_tableName)
26858 builder.append(tableName);
26859
26860 boolean present_row = true && (isSetRow());
26861 builder.append(present_row);
26862 if (present_row)
26863 builder.append(row);
26864
26865 return builder.toHashCode();
26866 }
26867
26868 public int compareTo(deleteAllRow_args other) {
26869 if (!getClass().equals(other.getClass())) {
26870 return getClass().getName().compareTo(other.getClass().getName());
26871 }
26872
26873 int lastComparison = 0;
26874 deleteAllRow_args typedOther = (deleteAllRow_args)other;
26875
26876 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
26877 if (lastComparison != 0) {
26878 return lastComparison;
26879 }
26880 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
26881 if (lastComparison != 0) {
26882 return lastComparison;
26883 }
26884 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
26885 if (lastComparison != 0) {
26886 return lastComparison;
26887 }
26888 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
26889 if (lastComparison != 0) {
26890 return lastComparison;
26891 }
26892 return 0;
26893 }
26894
26895 public void read(TProtocol iprot) throws TException {
26896 TField field;
26897 iprot.readStructBegin();
26898 while (true)
26899 {
26900 field = iprot.readFieldBegin();
26901 if (field.type == TType.STOP) {
26902 break;
26903 }
26904 _Fields fieldId = _Fields.findByThriftId(field.id);
26905 if (fieldId == null) {
26906 TProtocolUtil.skip(iprot, field.type);
26907 } else {
26908 switch (fieldId) {
26909 case TABLE_NAME:
26910 if (field.type == TType.STRING) {
26911 this.tableName = iprot.readBinary();
26912 } else {
26913 TProtocolUtil.skip(iprot, field.type);
26914 }
26915 break;
26916 case ROW:
26917 if (field.type == TType.STRING) {
26918 this.row = iprot.readBinary();
26919 } else {
26920 TProtocolUtil.skip(iprot, field.type);
26921 }
26922 break;
26923 }
26924 iprot.readFieldEnd();
26925 }
26926 }
26927 iprot.readStructEnd();
26928
26929
26930 validate();
26931 }
26932
26933 public void write(TProtocol oprot) throws TException {
26934 validate();
26935
26936 oprot.writeStructBegin(STRUCT_DESC);
26937 if (this.tableName != null) {
26938 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
26939 oprot.writeBinary(this.tableName);
26940 oprot.writeFieldEnd();
26941 }
26942 if (this.row != null) {
26943 oprot.writeFieldBegin(ROW_FIELD_DESC);
26944 oprot.writeBinary(this.row);
26945 oprot.writeFieldEnd();
26946 }
26947 oprot.writeFieldStop();
26948 oprot.writeStructEnd();
26949 }
26950
26951 @Override
26952 public String toString() {
26953 StringBuilder sb = new StringBuilder("deleteAllRow_args(");
26954 boolean first = true;
26955
26956 sb.append("tableName:");
26957 if (this.tableName == null) {
26958 sb.append("null");
26959 } else {
26960 sb.append(this.tableName);
26961 }
26962 first = false;
26963 if (!first) sb.append(", ");
26964 sb.append("row:");
26965 if (this.row == null) {
26966 sb.append("null");
26967 } else {
26968 sb.append(this.row);
26969 }
26970 first = false;
26971 sb.append(")");
26972 return sb.toString();
26973 }
26974
26975 public void validate() throws TException {
26976
26977 }
26978
26979 }
26980
26981 public static class deleteAllRow_result implements TBase<deleteAllRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_result> {
26982 private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_result");
26983
26984 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
26985
26986 public IOError io;
26987
26988
26989 public enum _Fields implements TFieldIdEnum {
26990 IO((short)1, "io");
26991
26992 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26993 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26994
26995 static {
26996 for (_Fields field : EnumSet.allOf(_Fields.class)) {
26997 byId.put((int)field._thriftId, field);
26998 byName.put(field.getFieldName(), field);
26999 }
27000 }
27001
27002
27003
27004
27005 public static _Fields findByThriftId(int fieldId) {
27006 return byId.get(fieldId);
27007 }
27008
27009
27010
27011
27012
27013 public static _Fields findByThriftIdOrThrow(int fieldId) {
27014 _Fields fields = findByThriftId(fieldId);
27015 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27016 return fields;
27017 }
27018
27019
27020
27021
27022 public static _Fields findByName(String name) {
27023 return byName.get(name);
27024 }
27025
27026 private final short _thriftId;
27027 private final String _fieldName;
27028
27029 _Fields(short thriftId, String fieldName) {
27030 _thriftId = thriftId;
27031 _fieldName = fieldName;
27032 }
27033
27034 public short getThriftFieldId() {
27035 return _thriftId;
27036 }
27037
27038 public String getFieldName() {
27039 return _fieldName;
27040 }
27041 }
27042
27043
27044
27045 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27046 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
27047 new FieldValueMetaData(TType.STRUCT)));
27048 }});
27049
27050 static {
27051 FieldMetaData.addStructMetaDataMap(deleteAllRow_result.class, metaDataMap);
27052 }
27053
27054 public deleteAllRow_result() {
27055 }
27056
27057 public deleteAllRow_result(
27058 IOError io)
27059 {
27060 this();
27061 this.io = io;
27062 }
27063
27064
27065
27066
27067 public deleteAllRow_result(deleteAllRow_result other) {
27068 if (other.isSetIo()) {
27069 this.io = new IOError(other.io);
27070 }
27071 }
27072
27073 public deleteAllRow_result deepCopy() {
27074 return new deleteAllRow_result(this);
27075 }
27076
27077 @Deprecated
27078 public deleteAllRow_result clone() {
27079 return new deleteAllRow_result(this);
27080 }
27081
27082 public IOError getIo() {
27083 return this.io;
27084 }
27085
27086 public deleteAllRow_result setIo(IOError io) {
27087 this.io = io;
27088 return this;
27089 }
27090
27091 public void unsetIo() {
27092 this.io = null;
27093 }
27094
27095
27096 public boolean isSetIo() {
27097 return this.io != null;
27098 }
27099
27100 public void setIoIsSet(boolean value) {
27101 if (!value) {
27102 this.io = null;
27103 }
27104 }
27105
27106 public void setFieldValue(_Fields field, Object value) {
27107 switch (field) {
27108 case IO:
27109 if (value == null) {
27110 unsetIo();
27111 } else {
27112 setIo((IOError)value);
27113 }
27114 break;
27115
27116 }
27117 }
27118
27119 public void setFieldValue(int fieldID, Object value) {
27120 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27121 }
27122
27123 public Object getFieldValue(_Fields field) {
27124 switch (field) {
27125 case IO:
27126 return getIo();
27127
27128 }
27129 throw new IllegalStateException();
27130 }
27131
27132 public Object getFieldValue(int fieldId) {
27133 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27134 }
27135
27136
27137 public boolean isSet(_Fields field) {
27138 switch (field) {
27139 case IO:
27140 return isSetIo();
27141 }
27142 throw new IllegalStateException();
27143 }
27144
27145 public boolean isSet(int fieldID) {
27146 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27147 }
27148
27149 @Override
27150 public boolean equals(Object that) {
27151 if (that == null)
27152 return false;
27153 if (that instanceof deleteAllRow_result)
27154 return this.equals((deleteAllRow_result)that);
27155 return false;
27156 }
27157
27158 public boolean equals(deleteAllRow_result that) {
27159 if (that == null)
27160 return false;
27161
27162 boolean this_present_io = true && this.isSetIo();
27163 boolean that_present_io = true && that.isSetIo();
27164 if (this_present_io || that_present_io) {
27165 if (!(this_present_io && that_present_io))
27166 return false;
27167 if (!this.io.equals(that.io))
27168 return false;
27169 }
27170
27171 return true;
27172 }
27173
27174 @Override
27175 public int hashCode() {
27176 HashCodeBuilder builder = new HashCodeBuilder();
27177
27178 boolean present_io = true && (isSetIo());
27179 builder.append(present_io);
27180 if (present_io)
27181 builder.append(io);
27182
27183 return builder.toHashCode();
27184 }
27185
27186 public int compareTo(deleteAllRow_result other) {
27187 if (!getClass().equals(other.getClass())) {
27188 return getClass().getName().compareTo(other.getClass().getName());
27189 }
27190
27191 int lastComparison = 0;
27192 deleteAllRow_result typedOther = (deleteAllRow_result)other;
27193
27194 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
27195 if (lastComparison != 0) {
27196 return lastComparison;
27197 }
27198 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
27199 if (lastComparison != 0) {
27200 return lastComparison;
27201 }
27202 return 0;
27203 }
27204
27205 public void read(TProtocol iprot) throws TException {
27206 TField field;
27207 iprot.readStructBegin();
27208 while (true)
27209 {
27210 field = iprot.readFieldBegin();
27211 if (field.type == TType.STOP) {
27212 break;
27213 }
27214 _Fields fieldId = _Fields.findByThriftId(field.id);
27215 if (fieldId == null) {
27216 TProtocolUtil.skip(iprot, field.type);
27217 } else {
27218 switch (fieldId) {
27219 case IO:
27220 if (field.type == TType.STRUCT) {
27221 this.io = new IOError();
27222 this.io.read(iprot);
27223 } else {
27224 TProtocolUtil.skip(iprot, field.type);
27225 }
27226 break;
27227 }
27228 iprot.readFieldEnd();
27229 }
27230 }
27231 iprot.readStructEnd();
27232
27233
27234 validate();
27235 }
27236
27237 public void write(TProtocol oprot) throws TException {
27238 oprot.writeStructBegin(STRUCT_DESC);
27239
27240 if (this.isSetIo()) {
27241 oprot.writeFieldBegin(IO_FIELD_DESC);
27242 this.io.write(oprot);
27243 oprot.writeFieldEnd();
27244 }
27245 oprot.writeFieldStop();
27246 oprot.writeStructEnd();
27247 }
27248
27249 @Override
27250 public String toString() {
27251 StringBuilder sb = new StringBuilder("deleteAllRow_result(");
27252 boolean first = true;
27253
27254 sb.append("io:");
27255 if (this.io == null) {
27256 sb.append("null");
27257 } else {
27258 sb.append(this.io);
27259 }
27260 first = false;
27261 sb.append(")");
27262 return sb.toString();
27263 }
27264
27265 public void validate() throws TException {
27266
27267 }
27268
27269 }
27270
27271 public static class deleteAllRowTs_args implements TBase<deleteAllRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_args> {
27272 private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_args");
27273
27274 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
27275 private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
27276 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
27277
27278
27279
27280
27281 public byte[] tableName;
27282
27283
27284
27285 public byte[] row;
27286
27287
27288
27289 public long timestamp;
27290
27291
27292 public enum _Fields implements TFieldIdEnum {
27293
27294
27295
27296 TABLE_NAME((short)1, "tableName"),
27297
27298
27299
27300 ROW((short)2, "row"),
27301
27302
27303
27304 TIMESTAMP((short)3, "timestamp");
27305
27306 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
27307 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
27308
27309 static {
27310 for (_Fields field : EnumSet.allOf(_Fields.class)) {
27311 byId.put((int)field._thriftId, field);
27312 byName.put(field.getFieldName(), field);
27313 }
27314 }
27315
27316
27317
27318
27319 public static _Fields findByThriftId(int fieldId) {
27320 return byId.get(fieldId);
27321 }
27322
27323
27324
27325
27326
27327 public static _Fields findByThriftIdOrThrow(int fieldId) {
27328 _Fields fields = findByThriftId(fieldId);
27329 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27330 return fields;
27331 }
27332
27333
27334
27335
27336 public static _Fields findByName(String name) {
27337 return byName.get(name);
27338 }
27339
27340 private final short _thriftId;
27341 private final String _fieldName;
27342
27343 _Fields(short thriftId, String fieldName) {
27344 _thriftId = thriftId;
27345 _fieldName = fieldName;
27346 }
27347
27348 public short getThriftFieldId() {
27349 return _thriftId;
27350 }
27351
27352 public String getFieldName() {
27353 return _fieldName;
27354 }
27355 }
27356
27357
27358 private static final int __TIMESTAMP_ISSET_ID = 0;
27359 private BitSet __isset_bit_vector = new BitSet(1);
27360
27361 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27362 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
27363 new FieldValueMetaData(TType.STRING)));
27364 put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
27365 new FieldValueMetaData(TType.STRING)));
27366 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
27367 new FieldValueMetaData(TType.I64)));
27368 }});
27369
27370 static {
27371 FieldMetaData.addStructMetaDataMap(deleteAllRowTs_args.class, metaDataMap);
27372 }
27373
27374 public deleteAllRowTs_args() {
27375 }
27376
27377 public deleteAllRowTs_args(
27378 byte[] tableName,
27379 byte[] row,
27380 long timestamp)
27381 {
27382 this();
27383 this.tableName = tableName;
27384 this.row = row;
27385 this.timestamp = timestamp;
27386 setTimestampIsSet(true);
27387 }
27388
27389
27390
27391
27392 public deleteAllRowTs_args(deleteAllRowTs_args other) {
27393 __isset_bit_vector.clear();
27394 __isset_bit_vector.or(other.__isset_bit_vector);
27395 if (other.isSetTableName()) {
27396 this.tableName = other.tableName;
27397 }
27398 if (other.isSetRow()) {
27399 this.row = other.row;
27400 }
27401 this.timestamp = other.timestamp;
27402 }
27403
27404 public deleteAllRowTs_args deepCopy() {
27405 return new deleteAllRowTs_args(this);
27406 }
27407
27408 @Deprecated
27409 public deleteAllRowTs_args clone() {
27410 return new deleteAllRowTs_args(this);
27411 }
27412
27413
27414
27415
27416 public byte[] getTableName() {
27417 return this.tableName;
27418 }
27419
27420
27421
27422
27423 public deleteAllRowTs_args setTableName(byte[] tableName) {
27424 this.tableName = tableName;
27425 return this;
27426 }
27427
27428 public void unsetTableName() {
27429 this.tableName = null;
27430 }
27431
27432
27433 public boolean isSetTableName() {
27434 return this.tableName != null;
27435 }
27436
27437 public void setTableNameIsSet(boolean value) {
27438 if (!value) {
27439 this.tableName = null;
27440 }
27441 }
27442
27443
27444
27445
27446 public byte[] getRow() {
27447 return this.row;
27448 }
27449
27450
27451
27452
27453 public deleteAllRowTs_args setRow(byte[] row) {
27454 this.row = row;
27455 return this;
27456 }
27457
27458 public void unsetRow() {
27459 this.row = null;
27460 }
27461
27462
27463 public boolean isSetRow() {
27464 return this.row != null;
27465 }
27466
27467 public void setRowIsSet(boolean value) {
27468 if (!value) {
27469 this.row = null;
27470 }
27471 }
27472
27473
27474
27475
27476 public long getTimestamp() {
27477 return this.timestamp;
27478 }
27479
27480
27481
27482
27483 public deleteAllRowTs_args setTimestamp(long timestamp) {
27484 this.timestamp = timestamp;
27485 setTimestampIsSet(true);
27486 return this;
27487 }
27488
27489 public void unsetTimestamp() {
27490 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
27491 }
27492
27493
27494 public boolean isSetTimestamp() {
27495 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
27496 }
27497
27498 public void setTimestampIsSet(boolean value) {
27499 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
27500 }
27501
27502 public void setFieldValue(_Fields field, Object value) {
27503 switch (field) {
27504 case TABLE_NAME:
27505 if (value == null) {
27506 unsetTableName();
27507 } else {
27508 setTableName((byte[])value);
27509 }
27510 break;
27511
27512 case ROW:
27513 if (value == null) {
27514 unsetRow();
27515 } else {
27516 setRow((byte[])value);
27517 }
27518 break;
27519
27520 case TIMESTAMP:
27521 if (value == null) {
27522 unsetTimestamp();
27523 } else {
27524 setTimestamp((Long)value);
27525 }
27526 break;
27527
27528 }
27529 }
27530
27531 public void setFieldValue(int fieldID, Object value) {
27532 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27533 }
27534
27535 public Object getFieldValue(_Fields field) {
27536 switch (field) {
27537 case TABLE_NAME:
27538 return getTableName();
27539
27540 case ROW:
27541 return getRow();
27542
27543 case TIMESTAMP:
27544 return new Long(getTimestamp());
27545
27546 }
27547 throw new IllegalStateException();
27548 }
27549
27550 public Object getFieldValue(int fieldId) {
27551 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27552 }
27553
27554
27555 public boolean isSet(_Fields field) {
27556 switch (field) {
27557 case TABLE_NAME:
27558 return isSetTableName();
27559 case ROW:
27560 return isSetRow();
27561 case TIMESTAMP:
27562 return isSetTimestamp();
27563 }
27564 throw new IllegalStateException();
27565 }
27566
27567 public boolean isSet(int fieldID) {
27568 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27569 }
27570
27571 @Override
27572 public boolean equals(Object that) {
27573 if (that == null)
27574 return false;
27575 if (that instanceof deleteAllRowTs_args)
27576 return this.equals((deleteAllRowTs_args)that);
27577 return false;
27578 }
27579
27580 public boolean equals(deleteAllRowTs_args that) {
27581 if (that == null)
27582 return false;
27583
27584 boolean this_present_tableName = true && this.isSetTableName();
27585 boolean that_present_tableName = true && that.isSetTableName();
27586 if (this_present_tableName || that_present_tableName) {
27587 if (!(this_present_tableName && that_present_tableName))
27588 return false;
27589 if (!java.util.Arrays.equals(this.tableName, that.tableName))
27590 return false;
27591 }
27592
27593 boolean this_present_row = true && this.isSetRow();
27594 boolean that_present_row = true && that.isSetRow();
27595 if (this_present_row || that_present_row) {
27596 if (!(this_present_row && that_present_row))
27597 return false;
27598 if (!java.util.Arrays.equals(this.row, that.row))
27599 return false;
27600 }
27601
27602 boolean this_present_timestamp = true;
27603 boolean that_present_timestamp = true;
27604 if (this_present_timestamp || that_present_timestamp) {
27605 if (!(this_present_timestamp && that_present_timestamp))
27606 return false;
27607 if (this.timestamp != that.timestamp)
27608 return false;
27609 }
27610
27611 return true;
27612 }
27613
27614 @Override
27615 public int hashCode() {
27616 HashCodeBuilder builder = new HashCodeBuilder();
27617
27618 boolean present_tableName = true && (isSetTableName());
27619 builder.append(present_tableName);
27620 if (present_tableName)
27621 builder.append(tableName);
27622
27623 boolean present_row = true && (isSetRow());
27624 builder.append(present_row);
27625 if (present_row)
27626 builder.append(row);
27627
27628 boolean present_timestamp = true;
27629 builder.append(present_timestamp);
27630 if (present_timestamp)
27631 builder.append(timestamp);
27632
27633 return builder.toHashCode();
27634 }
27635
27636 public int compareTo(deleteAllRowTs_args other) {
27637 if (!getClass().equals(other.getClass())) {
27638 return getClass().getName().compareTo(other.getClass().getName());
27639 }
27640
27641 int lastComparison = 0;
27642 deleteAllRowTs_args typedOther = (deleteAllRowTs_args)other;
27643
27644 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
27645 if (lastComparison != 0) {
27646 return lastComparison;
27647 }
27648 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
27649 if (lastComparison != 0) {
27650 return lastComparison;
27651 }
27652 lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
27653 if (lastComparison != 0) {
27654 return lastComparison;
27655 }
27656 lastComparison = TBaseHelper.compareTo(row, typedOther.row);
27657 if (lastComparison != 0) {
27658 return lastComparison;
27659 }
27660 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
27661 if (lastComparison != 0) {
27662 return lastComparison;
27663 }
27664 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
27665 if (lastComparison != 0) {
27666 return lastComparison;
27667 }
27668 return 0;
27669 }
27670
27671 public void read(TProtocol iprot) throws TException {
27672 TField field;
27673 iprot.readStructBegin();
27674 while (true)
27675 {
27676 field = iprot.readFieldBegin();
27677 if (field.type == TType.STOP) {
27678 break;
27679 }
27680 _Fields fieldId = _Fields.findByThriftId(field.id);
27681 if (fieldId == null) {
27682 TProtocolUtil.skip(iprot, field.type);
27683 } else {
27684 switch (fieldId) {
27685 case TABLE_NAME:
27686 if (field.type == TType.STRING) {
27687 this.tableName = iprot.readBinary();
27688 } else {
27689 TProtocolUtil.skip(iprot, field.type);
27690 }
27691 break;
27692 case ROW:
27693 if (field.type == TType.STRING) {
27694 this.row = iprot.readBinary();
27695 } else {
27696 TProtocolUtil.skip(iprot, field.type);
27697 }
27698 break;
27699 case TIMESTAMP:
27700 if (field.type == TType.I64) {
27701 this.timestamp = iprot.readI64();
27702 setTimestampIsSet(true);
27703 } else {
27704 TProtocolUtil.skip(iprot, field.type);
27705 }
27706 break;
27707 }
27708 iprot.readFieldEnd();
27709 }
27710 }
27711 iprot.readStructEnd();
27712
27713
27714 validate();
27715 }
27716
27717 public void write(TProtocol oprot) throws TException {
27718 validate();
27719
27720 oprot.writeStructBegin(STRUCT_DESC);
27721 if (this.tableName != null) {
27722 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
27723 oprot.writeBinary(this.tableName);
27724 oprot.writeFieldEnd();
27725 }
27726 if (this.row != null) {
27727 oprot.writeFieldBegin(ROW_FIELD_DESC);
27728 oprot.writeBinary(this.row);
27729 oprot.writeFieldEnd();
27730 }
27731 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
27732 oprot.writeI64(this.timestamp);
27733 oprot.writeFieldEnd();
27734 oprot.writeFieldStop();
27735 oprot.writeStructEnd();
27736 }
27737
27738 @Override
27739 public String toString() {
27740 StringBuilder sb = new StringBuilder("deleteAllRowTs_args(");
27741 boolean first = true;
27742
27743 sb.append("tableName:");
27744 if (this.tableName == null) {
27745 sb.append("null");
27746 } else {
27747 sb.append(this.tableName);
27748 }
27749 first = false;
27750 if (!first) sb.append(", ");
27751 sb.append("row:");
27752 if (this.row == null) {
27753 sb.append("null");
27754 } else {
27755 sb.append(this.row);
27756 }
27757 first = false;
27758 if (!first) sb.append(", ");
27759 sb.append("timestamp:");
27760 sb.append(this.timestamp);
27761 first = false;
27762 sb.append(")");
27763 return sb.toString();
27764 }
27765
27766 public void validate() throws TException {
27767
27768 }
27769
27770 }
27771
27772 public static class deleteAllRowTs_result implements TBase<deleteAllRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_result> {
27773 private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_result");
27774
27775 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
27776
27777 public IOError io;
27778
27779
27780 public enum _Fields implements TFieldIdEnum {
27781 IO((short)1, "io");
27782
27783 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
27784 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
27785
27786 static {
27787 for (_Fields field : EnumSet.allOf(_Fields.class)) {
27788 byId.put((int)field._thriftId, field);
27789 byName.put(field.getFieldName(), field);
27790 }
27791 }
27792
27793
27794
27795
27796 public static _Fields findByThriftId(int fieldId) {
27797 return byId.get(fieldId);
27798 }
27799
27800
27801
27802
27803
27804 public static _Fields findByThriftIdOrThrow(int fieldId) {
27805 _Fields fields = findByThriftId(fieldId);
27806 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27807 return fields;
27808 }
27809
27810
27811
27812
27813 public static _Fields findByName(String name) {
27814 return byName.get(name);
27815 }
27816
27817 private final short _thriftId;
27818 private final String _fieldName;
27819
27820 _Fields(short thriftId, String fieldName) {
27821 _thriftId = thriftId;
27822 _fieldName = fieldName;
27823 }
27824
27825 public short getThriftFieldId() {
27826 return _thriftId;
27827 }
27828
27829 public String getFieldName() {
27830 return _fieldName;
27831 }
27832 }
27833
27834
27835
27836 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27837 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
27838 new FieldValueMetaData(TType.STRUCT)));
27839 }});
27840
27841 static {
27842 FieldMetaData.addStructMetaDataMap(deleteAllRowTs_result.class, metaDataMap);
27843 }
27844
27845 public deleteAllRowTs_result() {
27846 }
27847
27848 public deleteAllRowTs_result(
27849 IOError io)
27850 {
27851 this();
27852 this.io = io;
27853 }
27854
27855
27856
27857
27858 public deleteAllRowTs_result(deleteAllRowTs_result other) {
27859 if (other.isSetIo()) {
27860 this.io = new IOError(other.io);
27861 }
27862 }
27863
27864 public deleteAllRowTs_result deepCopy() {
27865 return new deleteAllRowTs_result(this);
27866 }
27867
27868 @Deprecated
27869 public deleteAllRowTs_result clone() {
27870 return new deleteAllRowTs_result(this);
27871 }
27872
27873 public IOError getIo() {
27874 return this.io;
27875 }
27876
27877 public deleteAllRowTs_result setIo(IOError io) {
27878 this.io = io;
27879 return this;
27880 }
27881
27882 public void unsetIo() {
27883 this.io = null;
27884 }
27885
27886
27887 public boolean isSetIo() {
27888 return this.io != null;
27889 }
27890
27891 public void setIoIsSet(boolean value) {
27892 if (!value) {
27893 this.io = null;
27894 }
27895 }
27896
27897 public void setFieldValue(_Fields field, Object value) {
27898 switch (field) {
27899 case IO:
27900 if (value == null) {
27901 unsetIo();
27902 } else {
27903 setIo((IOError)value);
27904 }
27905 break;
27906
27907 }
27908 }
27909
27910 public void setFieldValue(int fieldID, Object value) {
27911 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27912 }
27913
27914 public Object getFieldValue(_Fields field) {
27915 switch (field) {
27916 case IO:
27917 return getIo();
27918
27919 }
27920 throw new IllegalStateException();
27921 }
27922
27923 public Object getFieldValue(int fieldId) {
27924 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27925 }
27926
27927
27928 public boolean isSet(_Fields field) {
27929 switch (field) {
27930 case IO:
27931 return isSetIo();
27932 }
27933 throw new IllegalStateException();
27934 }
27935
27936 public boolean isSet(int fieldID) {
27937 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27938 }
27939
27940 @Override
27941 public boolean equals(Object that) {
27942 if (that == null)
27943 return false;
27944 if (that instanceof deleteAllRowTs_result)
27945 return this.equals((deleteAllRowTs_result)that);
27946 return false;
27947 }
27948
27949 public boolean equals(deleteAllRowTs_result that) {
27950 if (that == null)
27951 return false;
27952
27953 boolean this_present_io = true && this.isSetIo();
27954 boolean that_present_io = true && that.isSetIo();
27955 if (this_present_io || that_present_io) {
27956 if (!(this_present_io && that_present_io))
27957 return false;
27958 if (!this.io.equals(that.io))
27959 return false;
27960 }
27961
27962 return true;
27963 }
27964
27965 @Override
27966 public int hashCode() {
27967 HashCodeBuilder builder = new HashCodeBuilder();
27968
27969 boolean present_io = true && (isSetIo());
27970 builder.append(present_io);
27971 if (present_io)
27972 builder.append(io);
27973
27974 return builder.toHashCode();
27975 }
27976
27977 public int compareTo(deleteAllRowTs_result other) {
27978 if (!getClass().equals(other.getClass())) {
27979 return getClass().getName().compareTo(other.getClass().getName());
27980 }
27981
27982 int lastComparison = 0;
27983 deleteAllRowTs_result typedOther = (deleteAllRowTs_result)other;
27984
27985 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
27986 if (lastComparison != 0) {
27987 return lastComparison;
27988 }
27989 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
27990 if (lastComparison != 0) {
27991 return lastComparison;
27992 }
27993 return 0;
27994 }
27995
27996 public void read(TProtocol iprot) throws TException {
27997 TField field;
27998 iprot.readStructBegin();
27999 while (true)
28000 {
28001 field = iprot.readFieldBegin();
28002 if (field.type == TType.STOP) {
28003 break;
28004 }
28005 _Fields fieldId = _Fields.findByThriftId(field.id);
28006 if (fieldId == null) {
28007 TProtocolUtil.skip(iprot, field.type);
28008 } else {
28009 switch (fieldId) {
28010 case IO:
28011 if (field.type == TType.STRUCT) {
28012 this.io = new IOError();
28013 this.io.read(iprot);
28014 } else {
28015 TProtocolUtil.skip(iprot, field.type);
28016 }
28017 break;
28018 }
28019 iprot.readFieldEnd();
28020 }
28021 }
28022 iprot.readStructEnd();
28023
28024
28025 validate();
28026 }
28027
28028 public void write(TProtocol oprot) throws TException {
28029 oprot.writeStructBegin(STRUCT_DESC);
28030
28031 if (this.isSetIo()) {
28032 oprot.writeFieldBegin(IO_FIELD_DESC);
28033 this.io.write(oprot);
28034 oprot.writeFieldEnd();
28035 }
28036 oprot.writeFieldStop();
28037 oprot.writeStructEnd();
28038 }
28039
28040 @Override
28041 public String toString() {
28042 StringBuilder sb = new StringBuilder("deleteAllRowTs_result(");
28043 boolean first = true;
28044
28045 sb.append("io:");
28046 if (this.io == null) {
28047 sb.append("null");
28048 } else {
28049 sb.append(this.io);
28050 }
28051 first = false;
28052 sb.append(")");
28053 return sb.toString();
28054 }
28055
28056 public void validate() throws TException {
28057
28058 }
28059
28060 }
28061
28062 public static class scannerOpen_args implements TBase<scannerOpen_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_args> {
28063 private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_args");
28064
28065 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
28066 private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
28067 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
28068
28069
28070
28071
28072 public byte[] tableName;
28073
28074
28075
28076
28077 public byte[] startRow;
28078
28079
28080
28081
28082
28083 public List<byte[]> columns;
28084
28085
28086 public enum _Fields implements TFieldIdEnum {
28087
28088
28089
28090 TABLE_NAME((short)1, "tableName"),
28091
28092
28093
28094
28095 START_ROW((short)2, "startRow"),
28096
28097
28098
28099
28100
28101 COLUMNS((short)3, "columns");
28102
28103 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
28104 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
28105
28106 static {
28107 for (_Fields field : EnumSet.allOf(_Fields.class)) {
28108 byId.put((int)field._thriftId, field);
28109 byName.put(field.getFieldName(), field);
28110 }
28111 }
28112
28113
28114
28115
28116 public static _Fields findByThriftId(int fieldId) {
28117 return byId.get(fieldId);
28118 }
28119
28120
28121
28122
28123
28124 public static _Fields findByThriftIdOrThrow(int fieldId) {
28125 _Fields fields = findByThriftId(fieldId);
28126 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
28127 return fields;
28128 }
28129
28130
28131
28132
28133 public static _Fields findByName(String name) {
28134 return byName.get(name);
28135 }
28136
28137 private final short _thriftId;
28138 private final String _fieldName;
28139
28140 _Fields(short thriftId, String fieldName) {
28141 _thriftId = thriftId;
28142 _fieldName = fieldName;
28143 }
28144
28145 public short getThriftFieldId() {
28146 return _thriftId;
28147 }
28148
28149 public String getFieldName() {
28150 return _fieldName;
28151 }
28152 }
28153
28154
28155
28156 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
28157 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
28158 new FieldValueMetaData(TType.STRING)));
28159 put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
28160 new FieldValueMetaData(TType.STRING)));
28161 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
28162 new ListMetaData(TType.LIST,
28163 new FieldValueMetaData(TType.STRING))));
28164 }});
28165
28166 static {
28167 FieldMetaData.addStructMetaDataMap(scannerOpen_args.class, metaDataMap);
28168 }
28169
28170 public scannerOpen_args() {
28171 }
28172
28173 public scannerOpen_args(
28174 byte[] tableName,
28175 byte[] startRow,
28176 List<byte[]> columns)
28177 {
28178 this();
28179 this.tableName = tableName;
28180 this.startRow = startRow;
28181 this.columns = columns;
28182 }
28183
28184
28185
28186
28187 public scannerOpen_args(scannerOpen_args other) {
28188 if (other.isSetTableName()) {
28189 this.tableName = other.tableName;
28190 }
28191 if (other.isSetStartRow()) {
28192 this.startRow = other.startRow;
28193 }
28194 if (other.isSetColumns()) {
28195 List<byte[]> __this__columns = new ArrayList<byte[]>();
28196 for (byte[] other_element : other.columns) {
28197 __this__columns.add(other_element);
28198 }
28199 this.columns = __this__columns;
28200 }
28201 }
28202
28203 public scannerOpen_args deepCopy() {
28204 return new scannerOpen_args(this);
28205 }
28206
28207 @Deprecated
28208 public scannerOpen_args clone() {
28209 return new scannerOpen_args(this);
28210 }
28211
28212
28213
28214
28215 public byte[] getTableName() {
28216 return this.tableName;
28217 }
28218
28219
28220
28221
28222 public scannerOpen_args setTableName(byte[] tableName) {
28223 this.tableName = tableName;
28224 return this;
28225 }
28226
28227 public void unsetTableName() {
28228 this.tableName = null;
28229 }
28230
28231
28232 public boolean isSetTableName() {
28233 return this.tableName != null;
28234 }
28235
28236 public void setTableNameIsSet(boolean value) {
28237 if (!value) {
28238 this.tableName = null;
28239 }
28240 }
28241
28242
28243
28244
28245
28246 public byte[] getStartRow() {
28247 return this.startRow;
28248 }
28249
28250
28251
28252
28253
28254 public scannerOpen_args setStartRow(byte[] startRow) {
28255 this.startRow = startRow;
28256 return this;
28257 }
28258
28259 public void unsetStartRow() {
28260 this.startRow = null;
28261 }
28262
28263
28264 public boolean isSetStartRow() {
28265 return this.startRow != null;
28266 }
28267
28268 public void setStartRowIsSet(boolean value) {
28269 if (!value) {
28270 this.startRow = null;
28271 }
28272 }
28273
28274 public int getColumnsSize() {
28275 return (this.columns == null) ? 0 : this.columns.size();
28276 }
28277
28278 public java.util.Iterator<byte[]> getColumnsIterator() {
28279 return (this.columns == null) ? null : this.columns.iterator();
28280 }
28281
28282 public void addToColumns(byte[] elem) {
28283 if (this.columns == null) {
28284 this.columns = new ArrayList<byte[]>();
28285 }
28286 this.columns.add(elem);
28287 }
28288
28289
28290
28291
28292
28293
28294 public List<byte[]> getColumns() {
28295 return this.columns;
28296 }
28297
28298
28299
28300
28301
28302
28303 public scannerOpen_args setColumns(List<byte[]> columns) {
28304 this.columns = columns;
28305 return this;
28306 }
28307
28308 public void unsetColumns() {
28309 this.columns = null;
28310 }
28311
28312
28313 public boolean isSetColumns() {
28314 return this.columns != null;
28315 }
28316
28317 public void setColumnsIsSet(boolean value) {
28318 if (!value) {
28319 this.columns = null;
28320 }
28321 }
28322
28323 public void setFieldValue(_Fields field, Object value) {
28324 switch (field) {
28325 case TABLE_NAME:
28326 if (value == null) {
28327 unsetTableName();
28328 } else {
28329 setTableName((byte[])value);
28330 }
28331 break;
28332
28333 case START_ROW:
28334 if (value == null) {
28335 unsetStartRow();
28336 } else {
28337 setStartRow((byte[])value);
28338 }
28339 break;
28340
28341 case COLUMNS:
28342 if (value == null) {
28343 unsetColumns();
28344 } else {
28345 setColumns((List<byte[]>)value);
28346 }
28347 break;
28348
28349 }
28350 }
28351
28352 public void setFieldValue(int fieldID, Object value) {
28353 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
28354 }
28355
28356 public Object getFieldValue(_Fields field) {
28357 switch (field) {
28358 case TABLE_NAME:
28359 return getTableName();
28360
28361 case START_ROW:
28362 return getStartRow();
28363
28364 case COLUMNS:
28365 return getColumns();
28366
28367 }
28368 throw new IllegalStateException();
28369 }
28370
28371 public Object getFieldValue(int fieldId) {
28372 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
28373 }
28374
28375
28376 public boolean isSet(_Fields field) {
28377 switch (field) {
28378 case TABLE_NAME:
28379 return isSetTableName();
28380 case START_ROW:
28381 return isSetStartRow();
28382 case COLUMNS:
28383 return isSetColumns();
28384 }
28385 throw new IllegalStateException();
28386 }
28387
28388 public boolean isSet(int fieldID) {
28389 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
28390 }
28391
28392 @Override
28393 public boolean equals(Object that) {
28394 if (that == null)
28395 return false;
28396 if (that instanceof scannerOpen_args)
28397 return this.equals((scannerOpen_args)that);
28398 return false;
28399 }
28400
28401 public boolean equals(scannerOpen_args that) {
28402 if (that == null)
28403 return false;
28404
28405 boolean this_present_tableName = true && this.isSetTableName();
28406 boolean that_present_tableName = true && that.isSetTableName();
28407 if (this_present_tableName || that_present_tableName) {
28408 if (!(this_present_tableName && that_present_tableName))
28409 return false;
28410 if (!java.util.Arrays.equals(this.tableName, that.tableName))
28411 return false;
28412 }
28413
28414 boolean this_present_startRow = true && this.isSetStartRow();
28415 boolean that_present_startRow = true && that.isSetStartRow();
28416 if (this_present_startRow || that_present_startRow) {
28417 if (!(this_present_startRow && that_present_startRow))
28418 return false;
28419 if (!java.util.Arrays.equals(this.startRow, that.startRow))
28420 return false;
28421 }
28422
28423 boolean this_present_columns = true && this.isSetColumns();
28424 boolean that_present_columns = true && that.isSetColumns();
28425 if (this_present_columns || that_present_columns) {
28426 if (!(this_present_columns && that_present_columns))
28427 return false;
28428 if (!this.columns.equals(that.columns))
28429 return false;
28430 }
28431
28432 return true;
28433 }
28434
28435 @Override
28436 public int hashCode() {
28437 HashCodeBuilder builder = new HashCodeBuilder();
28438
28439 boolean present_tableName = true && (isSetTableName());
28440 builder.append(present_tableName);
28441 if (present_tableName)
28442 builder.append(tableName);
28443
28444 boolean present_startRow = true && (isSetStartRow());
28445 builder.append(present_startRow);
28446 if (present_startRow)
28447 builder.append(startRow);
28448
28449 boolean present_columns = true && (isSetColumns());
28450 builder.append(present_columns);
28451 if (present_columns)
28452 builder.append(columns);
28453
28454 return builder.toHashCode();
28455 }
28456
28457 public int compareTo(scannerOpen_args other) {
28458 if (!getClass().equals(other.getClass())) {
28459 return getClass().getName().compareTo(other.getClass().getName());
28460 }
28461
28462 int lastComparison = 0;
28463 scannerOpen_args typedOther = (scannerOpen_args)other;
28464
28465 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
28466 if (lastComparison != 0) {
28467 return lastComparison;
28468 }
28469 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
28470 if (lastComparison != 0) {
28471 return lastComparison;
28472 }
28473 lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
28474 if (lastComparison != 0) {
28475 return lastComparison;
28476 }
28477 lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
28478 if (lastComparison != 0) {
28479 return lastComparison;
28480 }
28481 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
28482 if (lastComparison != 0) {
28483 return lastComparison;
28484 }
28485 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
28486 if (lastComparison != 0) {
28487 return lastComparison;
28488 }
28489 return 0;
28490 }
28491
28492 public void read(TProtocol iprot) throws TException {
28493 TField field;
28494 iprot.readStructBegin();
28495 while (true)
28496 {
28497 field = iprot.readFieldBegin();
28498 if (field.type == TType.STOP) {
28499 break;
28500 }
28501 _Fields fieldId = _Fields.findByThriftId(field.id);
28502 if (fieldId == null) {
28503 TProtocolUtil.skip(iprot, field.type);
28504 } else {
28505 switch (fieldId) {
28506 case TABLE_NAME:
28507 if (field.type == TType.STRING) {
28508 this.tableName = iprot.readBinary();
28509 } else {
28510 TProtocolUtil.skip(iprot, field.type);
28511 }
28512 break;
28513 case START_ROW:
28514 if (field.type == TType.STRING) {
28515 this.startRow = iprot.readBinary();
28516 } else {
28517 TProtocolUtil.skip(iprot, field.type);
28518 }
28519 break;
28520 case COLUMNS:
28521 if (field.type == TType.LIST) {
28522 {
28523 TList _list118 = iprot.readListBegin();
28524 this.columns = new ArrayList<byte[]>(_list118.size);
28525 for (int _i119 = 0; _i119 < _list118.size; ++_i119)
28526 {
28527 byte[] _elem120;
28528 _elem120 = iprot.readBinary();
28529 this.columns.add(_elem120);
28530 }
28531 iprot.readListEnd();
28532 }
28533 } else {
28534 TProtocolUtil.skip(iprot, field.type);
28535 }
28536 break;
28537 }
28538 iprot.readFieldEnd();
28539 }
28540 }
28541 iprot.readStructEnd();
28542
28543
28544 validate();
28545 }
28546
28547 public void write(TProtocol oprot) throws TException {
28548 validate();
28549
28550 oprot.writeStructBegin(STRUCT_DESC);
28551 if (this.tableName != null) {
28552 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
28553 oprot.writeBinary(this.tableName);
28554 oprot.writeFieldEnd();
28555 }
28556 if (this.startRow != null) {
28557 oprot.writeFieldBegin(START_ROW_FIELD_DESC);
28558 oprot.writeBinary(this.startRow);
28559 oprot.writeFieldEnd();
28560 }
28561 if (this.columns != null) {
28562 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
28563 {
28564 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
28565 for (byte[] _iter121 : this.columns)
28566 {
28567 oprot.writeBinary(_iter121);
28568 }
28569 oprot.writeListEnd();
28570 }
28571 oprot.writeFieldEnd();
28572 }
28573 oprot.writeFieldStop();
28574 oprot.writeStructEnd();
28575 }
28576
28577 @Override
28578 public String toString() {
28579 StringBuilder sb = new StringBuilder("scannerOpen_args(");
28580 boolean first = true;
28581
28582 sb.append("tableName:");
28583 if (this.tableName == null) {
28584 sb.append("null");
28585 } else {
28586 sb.append(this.tableName);
28587 }
28588 first = false;
28589 if (!first) sb.append(", ");
28590 sb.append("startRow:");
28591 if (this.startRow == null) {
28592 sb.append("null");
28593 } else {
28594 sb.append(this.startRow);
28595 }
28596 first = false;
28597 if (!first) sb.append(", ");
28598 sb.append("columns:");
28599 if (this.columns == null) {
28600 sb.append("null");
28601 } else {
28602 sb.append(this.columns);
28603 }
28604 first = false;
28605 sb.append(")");
28606 return sb.toString();
28607 }
28608
28609 public void validate() throws TException {
28610
28611 }
28612
28613 }
28614
28615 public static class scannerOpen_result implements TBase<scannerOpen_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_result> {
28616 private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_result");
28617
28618 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
28619 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
28620
28621 public int success;
28622 public IOError io;
28623
28624
28625 public enum _Fields implements TFieldIdEnum {
28626 SUCCESS((short)0, "success"),
28627 IO((short)1, "io");
28628
28629 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
28630 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
28631
28632 static {
28633 for (_Fields field : EnumSet.allOf(_Fields.class)) {
28634 byId.put((int)field._thriftId, field);
28635 byName.put(field.getFieldName(), field);
28636 }
28637 }
28638
28639
28640
28641
28642 public static _Fields findByThriftId(int fieldId) {
28643 return byId.get(fieldId);
28644 }
28645
28646
28647
28648
28649
28650 public static _Fields findByThriftIdOrThrow(int fieldId) {
28651 _Fields fields = findByThriftId(fieldId);
28652 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
28653 return fields;
28654 }
28655
28656
28657
28658
28659 public static _Fields findByName(String name) {
28660 return byName.get(name);
28661 }
28662
28663 private final short _thriftId;
28664 private final String _fieldName;
28665
28666 _Fields(short thriftId, String fieldName) {
28667 _thriftId = thriftId;
28668 _fieldName = fieldName;
28669 }
28670
28671 public short getThriftFieldId() {
28672 return _thriftId;
28673 }
28674
28675 public String getFieldName() {
28676 return _fieldName;
28677 }
28678 }
28679
28680
28681 private static final int __SUCCESS_ISSET_ID = 0;
28682 private BitSet __isset_bit_vector = new BitSet(1);
28683
28684 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
28685 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
28686 new FieldValueMetaData(TType.I32)));
28687 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
28688 new FieldValueMetaData(TType.STRUCT)));
28689 }});
28690
28691 static {
28692 FieldMetaData.addStructMetaDataMap(scannerOpen_result.class, metaDataMap);
28693 }
28694
28695 public scannerOpen_result() {
28696 }
28697
28698 public scannerOpen_result(
28699 int success,
28700 IOError io)
28701 {
28702 this();
28703 this.success = success;
28704 setSuccessIsSet(true);
28705 this.io = io;
28706 }
28707
28708
28709
28710
28711 public scannerOpen_result(scannerOpen_result other) {
28712 __isset_bit_vector.clear();
28713 __isset_bit_vector.or(other.__isset_bit_vector);
28714 this.success = other.success;
28715 if (other.isSetIo()) {
28716 this.io = new IOError(other.io);
28717 }
28718 }
28719
28720 public scannerOpen_result deepCopy() {
28721 return new scannerOpen_result(this);
28722 }
28723
28724 @Deprecated
28725 public scannerOpen_result clone() {
28726 return new scannerOpen_result(this);
28727 }
28728
28729 public int getSuccess() {
28730 return this.success;
28731 }
28732
28733 public scannerOpen_result setSuccess(int success) {
28734 this.success = success;
28735 setSuccessIsSet(true);
28736 return this;
28737 }
28738
28739 public void unsetSuccess() {
28740 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
28741 }
28742
28743
28744 public boolean isSetSuccess() {
28745 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
28746 }
28747
28748 public void setSuccessIsSet(boolean value) {
28749 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
28750 }
28751
28752 public IOError getIo() {
28753 return this.io;
28754 }
28755
28756 public scannerOpen_result setIo(IOError io) {
28757 this.io = io;
28758 return this;
28759 }
28760
28761 public void unsetIo() {
28762 this.io = null;
28763 }
28764
28765
28766 public boolean isSetIo() {
28767 return this.io != null;
28768 }
28769
28770 public void setIoIsSet(boolean value) {
28771 if (!value) {
28772 this.io = null;
28773 }
28774 }
28775
28776 public void setFieldValue(_Fields field, Object value) {
28777 switch (field) {
28778 case SUCCESS:
28779 if (value == null) {
28780 unsetSuccess();
28781 } else {
28782 setSuccess((Integer)value);
28783 }
28784 break;
28785
28786 case IO:
28787 if (value == null) {
28788 unsetIo();
28789 } else {
28790 setIo((IOError)value);
28791 }
28792 break;
28793
28794 }
28795 }
28796
28797 public void setFieldValue(int fieldID, Object value) {
28798 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
28799 }
28800
28801 public Object getFieldValue(_Fields field) {
28802 switch (field) {
28803 case SUCCESS:
28804 return new Integer(getSuccess());
28805
28806 case IO:
28807 return getIo();
28808
28809 }
28810 throw new IllegalStateException();
28811 }
28812
28813 public Object getFieldValue(int fieldId) {
28814 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
28815 }
28816
28817
28818 public boolean isSet(_Fields field) {
28819 switch (field) {
28820 case SUCCESS:
28821 return isSetSuccess();
28822 case IO:
28823 return isSetIo();
28824 }
28825 throw new IllegalStateException();
28826 }
28827
28828 public boolean isSet(int fieldID) {
28829 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
28830 }
28831
28832 @Override
28833 public boolean equals(Object that) {
28834 if (that == null)
28835 return false;
28836 if (that instanceof scannerOpen_result)
28837 return this.equals((scannerOpen_result)that);
28838 return false;
28839 }
28840
28841 public boolean equals(scannerOpen_result that) {
28842 if (that == null)
28843 return false;
28844
28845 boolean this_present_success = true;
28846 boolean that_present_success = true;
28847 if (this_present_success || that_present_success) {
28848 if (!(this_present_success && that_present_success))
28849 return false;
28850 if (this.success != that.success)
28851 return false;
28852 }
28853
28854 boolean this_present_io = true && this.isSetIo();
28855 boolean that_present_io = true && that.isSetIo();
28856 if (this_present_io || that_present_io) {
28857 if (!(this_present_io && that_present_io))
28858 return false;
28859 if (!this.io.equals(that.io))
28860 return false;
28861 }
28862
28863 return true;
28864 }
28865
28866 @Override
28867 public int hashCode() {
28868 HashCodeBuilder builder = new HashCodeBuilder();
28869
28870 boolean present_success = true;
28871 builder.append(present_success);
28872 if (present_success)
28873 builder.append(success);
28874
28875 boolean present_io = true && (isSetIo());
28876 builder.append(present_io);
28877 if (present_io)
28878 builder.append(io);
28879
28880 return builder.toHashCode();
28881 }
28882
28883 public int compareTo(scannerOpen_result other) {
28884 if (!getClass().equals(other.getClass())) {
28885 return getClass().getName().compareTo(other.getClass().getName());
28886 }
28887
28888 int lastComparison = 0;
28889 scannerOpen_result typedOther = (scannerOpen_result)other;
28890
28891 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
28892 if (lastComparison != 0) {
28893 return lastComparison;
28894 }
28895 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
28896 if (lastComparison != 0) {
28897 return lastComparison;
28898 }
28899 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
28900 if (lastComparison != 0) {
28901 return lastComparison;
28902 }
28903 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
28904 if (lastComparison != 0) {
28905 return lastComparison;
28906 }
28907 return 0;
28908 }
28909
28910 public void read(TProtocol iprot) throws TException {
28911 TField field;
28912 iprot.readStructBegin();
28913 while (true)
28914 {
28915 field = iprot.readFieldBegin();
28916 if (field.type == TType.STOP) {
28917 break;
28918 }
28919 _Fields fieldId = _Fields.findByThriftId(field.id);
28920 if (fieldId == null) {
28921 TProtocolUtil.skip(iprot, field.type);
28922 } else {
28923 switch (fieldId) {
28924 case SUCCESS:
28925 if (field.type == TType.I32) {
28926 this.success = iprot.readI32();
28927 setSuccessIsSet(true);
28928 } else {
28929 TProtocolUtil.skip(iprot, field.type);
28930 }
28931 break;
28932 case IO:
28933 if (field.type == TType.STRUCT) {
28934 this.io = new IOError();
28935 this.io.read(iprot);
28936 } else {
28937 TProtocolUtil.skip(iprot, field.type);
28938 }
28939 break;
28940 }
28941 iprot.readFieldEnd();
28942 }
28943 }
28944 iprot.readStructEnd();
28945
28946
28947 validate();
28948 }
28949
28950 public void write(TProtocol oprot) throws TException {
28951 oprot.writeStructBegin(STRUCT_DESC);
28952
28953 if (this.isSetSuccess()) {
28954 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28955 oprot.writeI32(this.success);
28956 oprot.writeFieldEnd();
28957 } else if (this.isSetIo()) {
28958 oprot.writeFieldBegin(IO_FIELD_DESC);
28959 this.io.write(oprot);
28960 oprot.writeFieldEnd();
28961 }
28962 oprot.writeFieldStop();
28963 oprot.writeStructEnd();
28964 }
28965
28966 @Override
28967 public String toString() {
28968 StringBuilder sb = new StringBuilder("scannerOpen_result(");
28969 boolean first = true;
28970
28971 sb.append("success:");
28972 sb.append(this.success);
28973 first = false;
28974 if (!first) sb.append(", ");
28975 sb.append("io:");
28976 if (this.io == null) {
28977 sb.append("null");
28978 } else {
28979 sb.append(this.io);
28980 }
28981 first = false;
28982 sb.append(")");
28983 return sb.toString();
28984 }
28985
28986 public void validate() throws TException {
28987
28988 }
28989
28990 }
28991
28992 public static class scannerOpenWithStop_args implements TBase<scannerOpenWithStop_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_args> {
28993 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_args");
28994
28995 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
28996 private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
28997 private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3);
28998 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4);
28999
29000
29001
29002
29003 public byte[] tableName;
29004
29005
29006
29007
29008 public byte[] startRow;
29009
29010
29011
29012
29013 public byte[] stopRow;
29014
29015
29016
29017
29018
29019 public List<byte[]> columns;
29020
29021
29022 public enum _Fields implements TFieldIdEnum {
29023
29024
29025
29026 TABLE_NAME((short)1, "tableName"),
29027
29028
29029
29030
29031 START_ROW((short)2, "startRow"),
29032
29033
29034
29035
29036 STOP_ROW((short)3, "stopRow"),
29037
29038
29039
29040
29041
29042 COLUMNS((short)4, "columns");
29043
29044 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29045 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29046
29047 static {
29048 for (_Fields field : EnumSet.allOf(_Fields.class)) {
29049 byId.put((int)field._thriftId, field);
29050 byName.put(field.getFieldName(), field);
29051 }
29052 }
29053
29054
29055
29056
29057 public static _Fields findByThriftId(int fieldId) {
29058 return byId.get(fieldId);
29059 }
29060
29061
29062
29063
29064
29065 public static _Fields findByThriftIdOrThrow(int fieldId) {
29066 _Fields fields = findByThriftId(fieldId);
29067 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29068 return fields;
29069 }
29070
29071
29072
29073
29074 public static _Fields findByName(String name) {
29075 return byName.get(name);
29076 }
29077
29078 private final short _thriftId;
29079 private final String _fieldName;
29080
29081 _Fields(short thriftId, String fieldName) {
29082 _thriftId = thriftId;
29083 _fieldName = fieldName;
29084 }
29085
29086 public short getThriftFieldId() {
29087 return _thriftId;
29088 }
29089
29090 public String getFieldName() {
29091 return _fieldName;
29092 }
29093 }
29094
29095
29096
29097 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29098 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
29099 new FieldValueMetaData(TType.STRING)));
29100 put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
29101 new FieldValueMetaData(TType.STRING)));
29102 put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT,
29103 new FieldValueMetaData(TType.STRING)));
29104 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
29105 new ListMetaData(TType.LIST,
29106 new FieldValueMetaData(TType.STRING))));
29107 }});
29108
29109 static {
29110 FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_args.class, metaDataMap);
29111 }
29112
29113 public scannerOpenWithStop_args() {
29114 }
29115
29116 public scannerOpenWithStop_args(
29117 byte[] tableName,
29118 byte[] startRow,
29119 byte[] stopRow,
29120 List<byte[]> columns)
29121 {
29122 this();
29123 this.tableName = tableName;
29124 this.startRow = startRow;
29125 this.stopRow = stopRow;
29126 this.columns = columns;
29127 }
29128
29129
29130
29131
29132 public scannerOpenWithStop_args(scannerOpenWithStop_args other) {
29133 if (other.isSetTableName()) {
29134 this.tableName = other.tableName;
29135 }
29136 if (other.isSetStartRow()) {
29137 this.startRow = other.startRow;
29138 }
29139 if (other.isSetStopRow()) {
29140 this.stopRow = other.stopRow;
29141 }
29142 if (other.isSetColumns()) {
29143 List<byte[]> __this__columns = new ArrayList<byte[]>();
29144 for (byte[] other_element : other.columns) {
29145 __this__columns.add(other_element);
29146 }
29147 this.columns = __this__columns;
29148 }
29149 }
29150
29151 public scannerOpenWithStop_args deepCopy() {
29152 return new scannerOpenWithStop_args(this);
29153 }
29154
29155 @Deprecated
29156 public scannerOpenWithStop_args clone() {
29157 return new scannerOpenWithStop_args(this);
29158 }
29159
29160
29161
29162
29163 public byte[] getTableName() {
29164 return this.tableName;
29165 }
29166
29167
29168
29169
29170 public scannerOpenWithStop_args setTableName(byte[] tableName) {
29171 this.tableName = tableName;
29172 return this;
29173 }
29174
29175 public void unsetTableName() {
29176 this.tableName = null;
29177 }
29178
29179
29180 public boolean isSetTableName() {
29181 return this.tableName != null;
29182 }
29183
29184 public void setTableNameIsSet(boolean value) {
29185 if (!value) {
29186 this.tableName = null;
29187 }
29188 }
29189
29190
29191
29192
29193
29194 public byte[] getStartRow() {
29195 return this.startRow;
29196 }
29197
29198
29199
29200
29201
29202 public scannerOpenWithStop_args setStartRow(byte[] startRow) {
29203 this.startRow = startRow;
29204 return this;
29205 }
29206
29207 public void unsetStartRow() {
29208 this.startRow = null;
29209 }
29210
29211
29212 public boolean isSetStartRow() {
29213 return this.startRow != null;
29214 }
29215
29216 public void setStartRowIsSet(boolean value) {
29217 if (!value) {
29218 this.startRow = null;
29219 }
29220 }
29221
29222
29223
29224
29225
29226 public byte[] getStopRow() {
29227 return this.stopRow;
29228 }
29229
29230
29231
29232
29233
29234 public scannerOpenWithStop_args setStopRow(byte[] stopRow) {
29235 this.stopRow = stopRow;
29236 return this;
29237 }
29238
29239 public void unsetStopRow() {
29240 this.stopRow = null;
29241 }
29242
29243
29244 public boolean isSetStopRow() {
29245 return this.stopRow != null;
29246 }
29247
29248 public void setStopRowIsSet(boolean value) {
29249 if (!value) {
29250 this.stopRow = null;
29251 }
29252 }
29253
29254 public int getColumnsSize() {
29255 return (this.columns == null) ? 0 : this.columns.size();
29256 }
29257
29258 public java.util.Iterator<byte[]> getColumnsIterator() {
29259 return (this.columns == null) ? null : this.columns.iterator();
29260 }
29261
29262 public void addToColumns(byte[] elem) {
29263 if (this.columns == null) {
29264 this.columns = new ArrayList<byte[]>();
29265 }
29266 this.columns.add(elem);
29267 }
29268
29269
29270
29271
29272
29273
29274 public List<byte[]> getColumns() {
29275 return this.columns;
29276 }
29277
29278
29279
29280
29281
29282
29283 public scannerOpenWithStop_args setColumns(List<byte[]> columns) {
29284 this.columns = columns;
29285 return this;
29286 }
29287
29288 public void unsetColumns() {
29289 this.columns = null;
29290 }
29291
29292
29293 public boolean isSetColumns() {
29294 return this.columns != null;
29295 }
29296
29297 public void setColumnsIsSet(boolean value) {
29298 if (!value) {
29299 this.columns = null;
29300 }
29301 }
29302
29303 public void setFieldValue(_Fields field, Object value) {
29304 switch (field) {
29305 case TABLE_NAME:
29306 if (value == null) {
29307 unsetTableName();
29308 } else {
29309 setTableName((byte[])value);
29310 }
29311 break;
29312
29313 case START_ROW:
29314 if (value == null) {
29315 unsetStartRow();
29316 } else {
29317 setStartRow((byte[])value);
29318 }
29319 break;
29320
29321 case STOP_ROW:
29322 if (value == null) {
29323 unsetStopRow();
29324 } else {
29325 setStopRow((byte[])value);
29326 }
29327 break;
29328
29329 case COLUMNS:
29330 if (value == null) {
29331 unsetColumns();
29332 } else {
29333 setColumns((List<byte[]>)value);
29334 }
29335 break;
29336
29337 }
29338 }
29339
29340 public void setFieldValue(int fieldID, Object value) {
29341 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29342 }
29343
29344 public Object getFieldValue(_Fields field) {
29345 switch (field) {
29346 case TABLE_NAME:
29347 return getTableName();
29348
29349 case START_ROW:
29350 return getStartRow();
29351
29352 case STOP_ROW:
29353 return getStopRow();
29354
29355 case COLUMNS:
29356 return getColumns();
29357
29358 }
29359 throw new IllegalStateException();
29360 }
29361
29362 public Object getFieldValue(int fieldId) {
29363 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29364 }
29365
29366
29367 public boolean isSet(_Fields field) {
29368 switch (field) {
29369 case TABLE_NAME:
29370 return isSetTableName();
29371 case START_ROW:
29372 return isSetStartRow();
29373 case STOP_ROW:
29374 return isSetStopRow();
29375 case COLUMNS:
29376 return isSetColumns();
29377 }
29378 throw new IllegalStateException();
29379 }
29380
29381 public boolean isSet(int fieldID) {
29382 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
29383 }
29384
29385 @Override
29386 public boolean equals(Object that) {
29387 if (that == null)
29388 return false;
29389 if (that instanceof scannerOpenWithStop_args)
29390 return this.equals((scannerOpenWithStop_args)that);
29391 return false;
29392 }
29393
29394 public boolean equals(scannerOpenWithStop_args that) {
29395 if (that == null)
29396 return false;
29397
29398 boolean this_present_tableName = true && this.isSetTableName();
29399 boolean that_present_tableName = true && that.isSetTableName();
29400 if (this_present_tableName || that_present_tableName) {
29401 if (!(this_present_tableName && that_present_tableName))
29402 return false;
29403 if (!java.util.Arrays.equals(this.tableName, that.tableName))
29404 return false;
29405 }
29406
29407 boolean this_present_startRow = true && this.isSetStartRow();
29408 boolean that_present_startRow = true && that.isSetStartRow();
29409 if (this_present_startRow || that_present_startRow) {
29410 if (!(this_present_startRow && that_present_startRow))
29411 return false;
29412 if (!java.util.Arrays.equals(this.startRow, that.startRow))
29413 return false;
29414 }
29415
29416 boolean this_present_stopRow = true && this.isSetStopRow();
29417 boolean that_present_stopRow = true && that.isSetStopRow();
29418 if (this_present_stopRow || that_present_stopRow) {
29419 if (!(this_present_stopRow && that_present_stopRow))
29420 return false;
29421 if (!java.util.Arrays.equals(this.stopRow, that.stopRow))
29422 return false;
29423 }
29424
29425 boolean this_present_columns = true && this.isSetColumns();
29426 boolean that_present_columns = true && that.isSetColumns();
29427 if (this_present_columns || that_present_columns) {
29428 if (!(this_present_columns && that_present_columns))
29429 return false;
29430 if (!this.columns.equals(that.columns))
29431 return false;
29432 }
29433
29434 return true;
29435 }
29436
29437 @Override
29438 public int hashCode() {
29439 HashCodeBuilder builder = new HashCodeBuilder();
29440
29441 boolean present_tableName = true && (isSetTableName());
29442 builder.append(present_tableName);
29443 if (present_tableName)
29444 builder.append(tableName);
29445
29446 boolean present_startRow = true && (isSetStartRow());
29447 builder.append(present_startRow);
29448 if (present_startRow)
29449 builder.append(startRow);
29450
29451 boolean present_stopRow = true && (isSetStopRow());
29452 builder.append(present_stopRow);
29453 if (present_stopRow)
29454 builder.append(stopRow);
29455
29456 boolean present_columns = true && (isSetColumns());
29457 builder.append(present_columns);
29458 if (present_columns)
29459 builder.append(columns);
29460
29461 return builder.toHashCode();
29462 }
29463
29464 public int compareTo(scannerOpenWithStop_args other) {
29465 if (!getClass().equals(other.getClass())) {
29466 return getClass().getName().compareTo(other.getClass().getName());
29467 }
29468
29469 int lastComparison = 0;
29470 scannerOpenWithStop_args typedOther = (scannerOpenWithStop_args)other;
29471
29472 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
29473 if (lastComparison != 0) {
29474 return lastComparison;
29475 }
29476 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
29477 if (lastComparison != 0) {
29478 return lastComparison;
29479 }
29480 lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
29481 if (lastComparison != 0) {
29482 return lastComparison;
29483 }
29484 lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
29485 if (lastComparison != 0) {
29486 return lastComparison;
29487 }
29488 lastComparison = Boolean.valueOf(isSetStopRow()).compareTo(isSetStopRow());
29489 if (lastComparison != 0) {
29490 return lastComparison;
29491 }
29492 lastComparison = TBaseHelper.compareTo(stopRow, typedOther.stopRow);
29493 if (lastComparison != 0) {
29494 return lastComparison;
29495 }
29496 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
29497 if (lastComparison != 0) {
29498 return lastComparison;
29499 }
29500 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
29501 if (lastComparison != 0) {
29502 return lastComparison;
29503 }
29504 return 0;
29505 }
29506
29507 public void read(TProtocol iprot) throws TException {
29508 TField field;
29509 iprot.readStructBegin();
29510 while (true)
29511 {
29512 field = iprot.readFieldBegin();
29513 if (field.type == TType.STOP) {
29514 break;
29515 }
29516 _Fields fieldId = _Fields.findByThriftId(field.id);
29517 if (fieldId == null) {
29518 TProtocolUtil.skip(iprot, field.type);
29519 } else {
29520 switch (fieldId) {
29521 case TABLE_NAME:
29522 if (field.type == TType.STRING) {
29523 this.tableName = iprot.readBinary();
29524 } else {
29525 TProtocolUtil.skip(iprot, field.type);
29526 }
29527 break;
29528 case START_ROW:
29529 if (field.type == TType.STRING) {
29530 this.startRow = iprot.readBinary();
29531 } else {
29532 TProtocolUtil.skip(iprot, field.type);
29533 }
29534 break;
29535 case STOP_ROW:
29536 if (field.type == TType.STRING) {
29537 this.stopRow = iprot.readBinary();
29538 } else {
29539 TProtocolUtil.skip(iprot, field.type);
29540 }
29541 break;
29542 case COLUMNS:
29543 if (field.type == TType.LIST) {
29544 {
29545 TList _list122 = iprot.readListBegin();
29546 this.columns = new ArrayList<byte[]>(_list122.size);
29547 for (int _i123 = 0; _i123 < _list122.size; ++_i123)
29548 {
29549 byte[] _elem124;
29550 _elem124 = iprot.readBinary();
29551 this.columns.add(_elem124);
29552 }
29553 iprot.readListEnd();
29554 }
29555 } else {
29556 TProtocolUtil.skip(iprot, field.type);
29557 }
29558 break;
29559 }
29560 iprot.readFieldEnd();
29561 }
29562 }
29563 iprot.readStructEnd();
29564
29565
29566 validate();
29567 }
29568
29569 public void write(TProtocol oprot) throws TException {
29570 validate();
29571
29572 oprot.writeStructBegin(STRUCT_DESC);
29573 if (this.tableName != null) {
29574 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
29575 oprot.writeBinary(this.tableName);
29576 oprot.writeFieldEnd();
29577 }
29578 if (this.startRow != null) {
29579 oprot.writeFieldBegin(START_ROW_FIELD_DESC);
29580 oprot.writeBinary(this.startRow);
29581 oprot.writeFieldEnd();
29582 }
29583 if (this.stopRow != null) {
29584 oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
29585 oprot.writeBinary(this.stopRow);
29586 oprot.writeFieldEnd();
29587 }
29588 if (this.columns != null) {
29589 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
29590 {
29591 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
29592 for (byte[] _iter125 : this.columns)
29593 {
29594 oprot.writeBinary(_iter125);
29595 }
29596 oprot.writeListEnd();
29597 }
29598 oprot.writeFieldEnd();
29599 }
29600 oprot.writeFieldStop();
29601 oprot.writeStructEnd();
29602 }
29603
29604 @Override
29605 public String toString() {
29606 StringBuilder sb = new StringBuilder("scannerOpenWithStop_args(");
29607 boolean first = true;
29608
29609 sb.append("tableName:");
29610 if (this.tableName == null) {
29611 sb.append("null");
29612 } else {
29613 sb.append(this.tableName);
29614 }
29615 first = false;
29616 if (!first) sb.append(", ");
29617 sb.append("startRow:");
29618 if (this.startRow == null) {
29619 sb.append("null");
29620 } else {
29621 sb.append(this.startRow);
29622 }
29623 first = false;
29624 if (!first) sb.append(", ");
29625 sb.append("stopRow:");
29626 if (this.stopRow == null) {
29627 sb.append("null");
29628 } else {
29629 sb.append(this.stopRow);
29630 }
29631 first = false;
29632 if (!first) sb.append(", ");
29633 sb.append("columns:");
29634 if (this.columns == null) {
29635 sb.append("null");
29636 } else {
29637 sb.append(this.columns);
29638 }
29639 first = false;
29640 sb.append(")");
29641 return sb.toString();
29642 }
29643
29644 public void validate() throws TException {
29645
29646 }
29647
29648 }
29649
29650 public static class scannerOpenWithStop_result implements TBase<scannerOpenWithStop_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_result> {
29651 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_result");
29652
29653 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
29654 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
29655
29656 public int success;
29657 public IOError io;
29658
29659
29660 public enum _Fields implements TFieldIdEnum {
29661 SUCCESS((short)0, "success"),
29662 IO((short)1, "io");
29663
29664 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29665 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29666
29667 static {
29668 for (_Fields field : EnumSet.allOf(_Fields.class)) {
29669 byId.put((int)field._thriftId, field);
29670 byName.put(field.getFieldName(), field);
29671 }
29672 }
29673
29674
29675
29676
29677 public static _Fields findByThriftId(int fieldId) {
29678 return byId.get(fieldId);
29679 }
29680
29681
29682
29683
29684
29685 public static _Fields findByThriftIdOrThrow(int fieldId) {
29686 _Fields fields = findByThriftId(fieldId);
29687 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29688 return fields;
29689 }
29690
29691
29692
29693
29694 public static _Fields findByName(String name) {
29695 return byName.get(name);
29696 }
29697
29698 private final short _thriftId;
29699 private final String _fieldName;
29700
29701 _Fields(short thriftId, String fieldName) {
29702 _thriftId = thriftId;
29703 _fieldName = fieldName;
29704 }
29705
29706 public short getThriftFieldId() {
29707 return _thriftId;
29708 }
29709
29710 public String getFieldName() {
29711 return _fieldName;
29712 }
29713 }
29714
29715
29716 private static final int __SUCCESS_ISSET_ID = 0;
29717 private BitSet __isset_bit_vector = new BitSet(1);
29718
29719 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29720 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
29721 new FieldValueMetaData(TType.I32)));
29722 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
29723 new FieldValueMetaData(TType.STRUCT)));
29724 }});
29725
29726 static {
29727 FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_result.class, metaDataMap);
29728 }
29729
29730 public scannerOpenWithStop_result() {
29731 }
29732
29733 public scannerOpenWithStop_result(
29734 int success,
29735 IOError io)
29736 {
29737 this();
29738 this.success = success;
29739 setSuccessIsSet(true);
29740 this.io = io;
29741 }
29742
29743
29744
29745
29746 public scannerOpenWithStop_result(scannerOpenWithStop_result other) {
29747 __isset_bit_vector.clear();
29748 __isset_bit_vector.or(other.__isset_bit_vector);
29749 this.success = other.success;
29750 if (other.isSetIo()) {
29751 this.io = new IOError(other.io);
29752 }
29753 }
29754
29755 public scannerOpenWithStop_result deepCopy() {
29756 return new scannerOpenWithStop_result(this);
29757 }
29758
29759 @Deprecated
29760 public scannerOpenWithStop_result clone() {
29761 return new scannerOpenWithStop_result(this);
29762 }
29763
29764 public int getSuccess() {
29765 return this.success;
29766 }
29767
29768 public scannerOpenWithStop_result setSuccess(int success) {
29769 this.success = success;
29770 setSuccessIsSet(true);
29771 return this;
29772 }
29773
29774 public void unsetSuccess() {
29775 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
29776 }
29777
29778
29779 public boolean isSetSuccess() {
29780 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
29781 }
29782
29783 public void setSuccessIsSet(boolean value) {
29784 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
29785 }
29786
29787 public IOError getIo() {
29788 return this.io;
29789 }
29790
29791 public scannerOpenWithStop_result setIo(IOError io) {
29792 this.io = io;
29793 return this;
29794 }
29795
29796 public void unsetIo() {
29797 this.io = null;
29798 }
29799
29800
29801 public boolean isSetIo() {
29802 return this.io != null;
29803 }
29804
29805 public void setIoIsSet(boolean value) {
29806 if (!value) {
29807 this.io = null;
29808 }
29809 }
29810
29811 public void setFieldValue(_Fields field, Object value) {
29812 switch (field) {
29813 case SUCCESS:
29814 if (value == null) {
29815 unsetSuccess();
29816 } else {
29817 setSuccess((Integer)value);
29818 }
29819 break;
29820
29821 case IO:
29822 if (value == null) {
29823 unsetIo();
29824 } else {
29825 setIo((IOError)value);
29826 }
29827 break;
29828
29829 }
29830 }
29831
29832 public void setFieldValue(int fieldID, Object value) {
29833 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29834 }
29835
29836 public Object getFieldValue(_Fields field) {
29837 switch (field) {
29838 case SUCCESS:
29839 return new Integer(getSuccess());
29840
29841 case IO:
29842 return getIo();
29843
29844 }
29845 throw new IllegalStateException();
29846 }
29847
29848 public Object getFieldValue(int fieldId) {
29849 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29850 }
29851
29852
29853 public boolean isSet(_Fields field) {
29854 switch (field) {
29855 case SUCCESS:
29856 return isSetSuccess();
29857 case IO:
29858 return isSetIo();
29859 }
29860 throw new IllegalStateException();
29861 }
29862
29863 public boolean isSet(int fieldID) {
29864 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
29865 }
29866
29867 @Override
29868 public boolean equals(Object that) {
29869 if (that == null)
29870 return false;
29871 if (that instanceof scannerOpenWithStop_result)
29872 return this.equals((scannerOpenWithStop_result)that);
29873 return false;
29874 }
29875
29876 public boolean equals(scannerOpenWithStop_result that) {
29877 if (that == null)
29878 return false;
29879
29880 boolean this_present_success = true;
29881 boolean that_present_success = true;
29882 if (this_present_success || that_present_success) {
29883 if (!(this_present_success && that_present_success))
29884 return false;
29885 if (this.success != that.success)
29886 return false;
29887 }
29888
29889 boolean this_present_io = true && this.isSetIo();
29890 boolean that_present_io = true && that.isSetIo();
29891 if (this_present_io || that_present_io) {
29892 if (!(this_present_io && that_present_io))
29893 return false;
29894 if (!this.io.equals(that.io))
29895 return false;
29896 }
29897
29898 return true;
29899 }
29900
29901 @Override
29902 public int hashCode() {
29903 HashCodeBuilder builder = new HashCodeBuilder();
29904
29905 boolean present_success = true;
29906 builder.append(present_success);
29907 if (present_success)
29908 builder.append(success);
29909
29910 boolean present_io = true && (isSetIo());
29911 builder.append(present_io);
29912 if (present_io)
29913 builder.append(io);
29914
29915 return builder.toHashCode();
29916 }
29917
29918 public int compareTo(scannerOpenWithStop_result other) {
29919 if (!getClass().equals(other.getClass())) {
29920 return getClass().getName().compareTo(other.getClass().getName());
29921 }
29922
29923 int lastComparison = 0;
29924 scannerOpenWithStop_result typedOther = (scannerOpenWithStop_result)other;
29925
29926 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
29927 if (lastComparison != 0) {
29928 return lastComparison;
29929 }
29930 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
29931 if (lastComparison != 0) {
29932 return lastComparison;
29933 }
29934 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
29935 if (lastComparison != 0) {
29936 return lastComparison;
29937 }
29938 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
29939 if (lastComparison != 0) {
29940 return lastComparison;
29941 }
29942 return 0;
29943 }
29944
29945 public void read(TProtocol iprot) throws TException {
29946 TField field;
29947 iprot.readStructBegin();
29948 while (true)
29949 {
29950 field = iprot.readFieldBegin();
29951 if (field.type == TType.STOP) {
29952 break;
29953 }
29954 _Fields fieldId = _Fields.findByThriftId(field.id);
29955 if (fieldId == null) {
29956 TProtocolUtil.skip(iprot, field.type);
29957 } else {
29958 switch (fieldId) {
29959 case SUCCESS:
29960 if (field.type == TType.I32) {
29961 this.success = iprot.readI32();
29962 setSuccessIsSet(true);
29963 } else {
29964 TProtocolUtil.skip(iprot, field.type);
29965 }
29966 break;
29967 case IO:
29968 if (field.type == TType.STRUCT) {
29969 this.io = new IOError();
29970 this.io.read(iprot);
29971 } else {
29972 TProtocolUtil.skip(iprot, field.type);
29973 }
29974 break;
29975 }
29976 iprot.readFieldEnd();
29977 }
29978 }
29979 iprot.readStructEnd();
29980
29981
29982 validate();
29983 }
29984
29985 public void write(TProtocol oprot) throws TException {
29986 oprot.writeStructBegin(STRUCT_DESC);
29987
29988 if (this.isSetSuccess()) {
29989 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29990 oprot.writeI32(this.success);
29991 oprot.writeFieldEnd();
29992 } else if (this.isSetIo()) {
29993 oprot.writeFieldBegin(IO_FIELD_DESC);
29994 this.io.write(oprot);
29995 oprot.writeFieldEnd();
29996 }
29997 oprot.writeFieldStop();
29998 oprot.writeStructEnd();
29999 }
30000
30001 @Override
30002 public String toString() {
30003 StringBuilder sb = new StringBuilder("scannerOpenWithStop_result(");
30004 boolean first = true;
30005
30006 sb.append("success:");
30007 sb.append(this.success);
30008 first = false;
30009 if (!first) sb.append(", ");
30010 sb.append("io:");
30011 if (this.io == null) {
30012 sb.append("null");
30013 } else {
30014 sb.append(this.io);
30015 }
30016 first = false;
30017 sb.append(")");
30018 return sb.toString();
30019 }
30020
30021 public void validate() throws TException {
30022
30023 }
30024
30025 }
30026
30027 public static class scannerOpenWithPrefix_args implements TBase<scannerOpenWithPrefix_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_args> {
30028 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_args");
30029
30030 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
30031 private static final TField START_AND_PREFIX_FIELD_DESC = new TField("startAndPrefix", TType.STRING, (short)2);
30032 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
30033
30034
30035
30036
30037 public byte[] tableName;
30038
30039
30040
30041 public byte[] startAndPrefix;
30042
30043
30044
30045 public List<byte[]> columns;
30046
30047
30048 public enum _Fields implements TFieldIdEnum {
30049
30050
30051
30052 TABLE_NAME((short)1, "tableName"),
30053
30054
30055
30056 START_AND_PREFIX((short)2, "startAndPrefix"),
30057
30058
30059
30060 COLUMNS((short)3, "columns");
30061
30062 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30063 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30064
30065 static {
30066 for (_Fields field : EnumSet.allOf(_Fields.class)) {
30067 byId.put((int)field._thriftId, field);
30068 byName.put(field.getFieldName(), field);
30069 }
30070 }
30071
30072
30073
30074
30075 public static _Fields findByThriftId(int fieldId) {
30076 return byId.get(fieldId);
30077 }
30078
30079
30080
30081
30082
30083 public static _Fields findByThriftIdOrThrow(int fieldId) {
30084 _Fields fields = findByThriftId(fieldId);
30085 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30086 return fields;
30087 }
30088
30089
30090
30091
30092 public static _Fields findByName(String name) {
30093 return byName.get(name);
30094 }
30095
30096 private final short _thriftId;
30097 private final String _fieldName;
30098
30099 _Fields(short thriftId, String fieldName) {
30100 _thriftId = thriftId;
30101 _fieldName = fieldName;
30102 }
30103
30104 public short getThriftFieldId() {
30105 return _thriftId;
30106 }
30107
30108 public String getFieldName() {
30109 return _fieldName;
30110 }
30111 }
30112
30113
30114
30115 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30116 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
30117 new FieldValueMetaData(TType.STRING)));
30118 put(_Fields.START_AND_PREFIX, new FieldMetaData("startAndPrefix", TFieldRequirementType.DEFAULT,
30119 new FieldValueMetaData(TType.STRING)));
30120 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
30121 new ListMetaData(TType.LIST,
30122 new FieldValueMetaData(TType.STRING))));
30123 }});
30124
30125 static {
30126 FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_args.class, metaDataMap);
30127 }
30128
30129 public scannerOpenWithPrefix_args() {
30130 }
30131
30132 public scannerOpenWithPrefix_args(
30133 byte[] tableName,
30134 byte[] startAndPrefix,
30135 List<byte[]> columns)
30136 {
30137 this();
30138 this.tableName = tableName;
30139 this.startAndPrefix = startAndPrefix;
30140 this.columns = columns;
30141 }
30142
30143
30144
30145
30146 public scannerOpenWithPrefix_args(scannerOpenWithPrefix_args other) {
30147 if (other.isSetTableName()) {
30148 this.tableName = other.tableName;
30149 }
30150 if (other.isSetStartAndPrefix()) {
30151 this.startAndPrefix = other.startAndPrefix;
30152 }
30153 if (other.isSetColumns()) {
30154 List<byte[]> __this__columns = new ArrayList<byte[]>();
30155 for (byte[] other_element : other.columns) {
30156 __this__columns.add(other_element);
30157 }
30158 this.columns = __this__columns;
30159 }
30160 }
30161
30162 public scannerOpenWithPrefix_args deepCopy() {
30163 return new scannerOpenWithPrefix_args(this);
30164 }
30165
30166 @Deprecated
30167 public scannerOpenWithPrefix_args clone() {
30168 return new scannerOpenWithPrefix_args(this);
30169 }
30170
30171
30172
30173
30174 public byte[] getTableName() {
30175 return this.tableName;
30176 }
30177
30178
30179
30180
30181 public scannerOpenWithPrefix_args setTableName(byte[] tableName) {
30182 this.tableName = tableName;
30183 return this;
30184 }
30185
30186 public void unsetTableName() {
30187 this.tableName = null;
30188 }
30189
30190
30191 public boolean isSetTableName() {
30192 return this.tableName != null;
30193 }
30194
30195 public void setTableNameIsSet(boolean value) {
30196 if (!value) {
30197 this.tableName = null;
30198 }
30199 }
30200
30201
30202
30203
30204 public byte[] getStartAndPrefix() {
30205 return this.startAndPrefix;
30206 }
30207
30208
30209
30210
30211 public scannerOpenWithPrefix_args setStartAndPrefix(byte[] startAndPrefix) {
30212 this.startAndPrefix = startAndPrefix;
30213 return this;
30214 }
30215
30216 public void unsetStartAndPrefix() {
30217 this.startAndPrefix = null;
30218 }
30219
30220
30221 public boolean isSetStartAndPrefix() {
30222 return this.startAndPrefix != null;
30223 }
30224
30225 public void setStartAndPrefixIsSet(boolean value) {
30226 if (!value) {
30227 this.startAndPrefix = null;
30228 }
30229 }
30230
30231 public int getColumnsSize() {
30232 return (this.columns == null) ? 0 : this.columns.size();
30233 }
30234
30235 public java.util.Iterator<byte[]> getColumnsIterator() {
30236 return (this.columns == null) ? null : this.columns.iterator();
30237 }
30238
30239 public void addToColumns(byte[] elem) {
30240 if (this.columns == null) {
30241 this.columns = new ArrayList<byte[]>();
30242 }
30243 this.columns.add(elem);
30244 }
30245
30246
30247
30248
30249 public List<byte[]> getColumns() {
30250 return this.columns;
30251 }
30252
30253
30254
30255
30256 public scannerOpenWithPrefix_args setColumns(List<byte[]> columns) {
30257 this.columns = columns;
30258 return this;
30259 }
30260
30261 public void unsetColumns() {
30262 this.columns = null;
30263 }
30264
30265
30266 public boolean isSetColumns() {
30267 return this.columns != null;
30268 }
30269
30270 public void setColumnsIsSet(boolean value) {
30271 if (!value) {
30272 this.columns = null;
30273 }
30274 }
30275
30276 public void setFieldValue(_Fields field, Object value) {
30277 switch (field) {
30278 case TABLE_NAME:
30279 if (value == null) {
30280 unsetTableName();
30281 } else {
30282 setTableName((byte[])value);
30283 }
30284 break;
30285
30286 case START_AND_PREFIX:
30287 if (value == null) {
30288 unsetStartAndPrefix();
30289 } else {
30290 setStartAndPrefix((byte[])value);
30291 }
30292 break;
30293
30294 case COLUMNS:
30295 if (value == null) {
30296 unsetColumns();
30297 } else {
30298 setColumns((List<byte[]>)value);
30299 }
30300 break;
30301
30302 }
30303 }
30304
30305 public void setFieldValue(int fieldID, Object value) {
30306 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
30307 }
30308
30309 public Object getFieldValue(_Fields field) {
30310 switch (field) {
30311 case TABLE_NAME:
30312 return getTableName();
30313
30314 case START_AND_PREFIX:
30315 return getStartAndPrefix();
30316
30317 case COLUMNS:
30318 return getColumns();
30319
30320 }
30321 throw new IllegalStateException();
30322 }
30323
30324 public Object getFieldValue(int fieldId) {
30325 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
30326 }
30327
30328
30329 public boolean isSet(_Fields field) {
30330 switch (field) {
30331 case TABLE_NAME:
30332 return isSetTableName();
30333 case START_AND_PREFIX:
30334 return isSetStartAndPrefix();
30335 case COLUMNS:
30336 return isSetColumns();
30337 }
30338 throw new IllegalStateException();
30339 }
30340
30341 public boolean isSet(int fieldID) {
30342 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30343 }
30344
30345 @Override
30346 public boolean equals(Object that) {
30347 if (that == null)
30348 return false;
30349 if (that instanceof scannerOpenWithPrefix_args)
30350 return this.equals((scannerOpenWithPrefix_args)that);
30351 return false;
30352 }
30353
30354 public boolean equals(scannerOpenWithPrefix_args that) {
30355 if (that == null)
30356 return false;
30357
30358 boolean this_present_tableName = true && this.isSetTableName();
30359 boolean that_present_tableName = true && that.isSetTableName();
30360 if (this_present_tableName || that_present_tableName) {
30361 if (!(this_present_tableName && that_present_tableName))
30362 return false;
30363 if (!java.util.Arrays.equals(this.tableName, that.tableName))
30364 return false;
30365 }
30366
30367 boolean this_present_startAndPrefix = true && this.isSetStartAndPrefix();
30368 boolean that_present_startAndPrefix = true && that.isSetStartAndPrefix();
30369 if (this_present_startAndPrefix || that_present_startAndPrefix) {
30370 if (!(this_present_startAndPrefix && that_present_startAndPrefix))
30371 return false;
30372 if (!java.util.Arrays.equals(this.startAndPrefix, that.startAndPrefix))
30373 return false;
30374 }
30375
30376 boolean this_present_columns = true && this.isSetColumns();
30377 boolean that_present_columns = true && that.isSetColumns();
30378 if (this_present_columns || that_present_columns) {
30379 if (!(this_present_columns && that_present_columns))
30380 return false;
30381 if (!this.columns.equals(that.columns))
30382 return false;
30383 }
30384
30385 return true;
30386 }
30387
30388 @Override
30389 public int hashCode() {
30390 HashCodeBuilder builder = new HashCodeBuilder();
30391
30392 boolean present_tableName = true && (isSetTableName());
30393 builder.append(present_tableName);
30394 if (present_tableName)
30395 builder.append(tableName);
30396
30397 boolean present_startAndPrefix = true && (isSetStartAndPrefix());
30398 builder.append(present_startAndPrefix);
30399 if (present_startAndPrefix)
30400 builder.append(startAndPrefix);
30401
30402 boolean present_columns = true && (isSetColumns());
30403 builder.append(present_columns);
30404 if (present_columns)
30405 builder.append(columns);
30406
30407 return builder.toHashCode();
30408 }
30409
30410 public int compareTo(scannerOpenWithPrefix_args other) {
30411 if (!getClass().equals(other.getClass())) {
30412 return getClass().getName().compareTo(other.getClass().getName());
30413 }
30414
30415 int lastComparison = 0;
30416 scannerOpenWithPrefix_args typedOther = (scannerOpenWithPrefix_args)other;
30417
30418 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
30419 if (lastComparison != 0) {
30420 return lastComparison;
30421 }
30422 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
30423 if (lastComparison != 0) {
30424 return lastComparison;
30425 }
30426 lastComparison = Boolean.valueOf(isSetStartAndPrefix()).compareTo(isSetStartAndPrefix());
30427 if (lastComparison != 0) {
30428 return lastComparison;
30429 }
30430 lastComparison = TBaseHelper.compareTo(startAndPrefix, typedOther.startAndPrefix);
30431 if (lastComparison != 0) {
30432 return lastComparison;
30433 }
30434 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
30435 if (lastComparison != 0) {
30436 return lastComparison;
30437 }
30438 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
30439 if (lastComparison != 0) {
30440 return lastComparison;
30441 }
30442 return 0;
30443 }
30444
30445 public void read(TProtocol iprot) throws TException {
30446 TField field;
30447 iprot.readStructBegin();
30448 while (true)
30449 {
30450 field = iprot.readFieldBegin();
30451 if (field.type == TType.STOP) {
30452 break;
30453 }
30454 _Fields fieldId = _Fields.findByThriftId(field.id);
30455 if (fieldId == null) {
30456 TProtocolUtil.skip(iprot, field.type);
30457 } else {
30458 switch (fieldId) {
30459 case TABLE_NAME:
30460 if (field.type == TType.STRING) {
30461 this.tableName = iprot.readBinary();
30462 } else {
30463 TProtocolUtil.skip(iprot, field.type);
30464 }
30465 break;
30466 case START_AND_PREFIX:
30467 if (field.type == TType.STRING) {
30468 this.startAndPrefix = iprot.readBinary();
30469 } else {
30470 TProtocolUtil.skip(iprot, field.type);
30471 }
30472 break;
30473 case COLUMNS:
30474 if (field.type == TType.LIST) {
30475 {
30476 TList _list126 = iprot.readListBegin();
30477 this.columns = new ArrayList<byte[]>(_list126.size);
30478 for (int _i127 = 0; _i127 < _list126.size; ++_i127)
30479 {
30480 byte[] _elem128;
30481 _elem128 = iprot.readBinary();
30482 this.columns.add(_elem128);
30483 }
30484 iprot.readListEnd();
30485 }
30486 } else {
30487 TProtocolUtil.skip(iprot, field.type);
30488 }
30489 break;
30490 }
30491 iprot.readFieldEnd();
30492 }
30493 }
30494 iprot.readStructEnd();
30495
30496
30497 validate();
30498 }
30499
30500 public void write(TProtocol oprot) throws TException {
30501 validate();
30502
30503 oprot.writeStructBegin(STRUCT_DESC);
30504 if (this.tableName != null) {
30505 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
30506 oprot.writeBinary(this.tableName);
30507 oprot.writeFieldEnd();
30508 }
30509 if (this.startAndPrefix != null) {
30510 oprot.writeFieldBegin(START_AND_PREFIX_FIELD_DESC);
30511 oprot.writeBinary(this.startAndPrefix);
30512 oprot.writeFieldEnd();
30513 }
30514 if (this.columns != null) {
30515 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
30516 {
30517 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
30518 for (byte[] _iter129 : this.columns)
30519 {
30520 oprot.writeBinary(_iter129);
30521 }
30522 oprot.writeListEnd();
30523 }
30524 oprot.writeFieldEnd();
30525 }
30526 oprot.writeFieldStop();
30527 oprot.writeStructEnd();
30528 }
30529
30530 @Override
30531 public String toString() {
30532 StringBuilder sb = new StringBuilder("scannerOpenWithPrefix_args(");
30533 boolean first = true;
30534
30535 sb.append("tableName:");
30536 if (this.tableName == null) {
30537 sb.append("null");
30538 } else {
30539 sb.append(this.tableName);
30540 }
30541 first = false;
30542 if (!first) sb.append(", ");
30543 sb.append("startAndPrefix:");
30544 if (this.startAndPrefix == null) {
30545 sb.append("null");
30546 } else {
30547 sb.append(this.startAndPrefix);
30548 }
30549 first = false;
30550 if (!first) sb.append(", ");
30551 sb.append("columns:");
30552 if (this.columns == null) {
30553 sb.append("null");
30554 } else {
30555 sb.append(this.columns);
30556 }
30557 first = false;
30558 sb.append(")");
30559 return sb.toString();
30560 }
30561
30562 public void validate() throws TException {
30563
30564 }
30565
30566 }
30567
30568 public static class scannerOpenWithPrefix_result implements TBase<scannerOpenWithPrefix_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_result> {
30569 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_result");
30570
30571 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
30572 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
30573
30574 public int success;
30575 public IOError io;
30576
30577
30578 public enum _Fields implements TFieldIdEnum {
30579 SUCCESS((short)0, "success"),
30580 IO((short)1, "io");
30581
30582 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30583 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30584
30585 static {
30586 for (_Fields field : EnumSet.allOf(_Fields.class)) {
30587 byId.put((int)field._thriftId, field);
30588 byName.put(field.getFieldName(), field);
30589 }
30590 }
30591
30592
30593
30594
30595 public static _Fields findByThriftId(int fieldId) {
30596 return byId.get(fieldId);
30597 }
30598
30599
30600
30601
30602
30603 public static _Fields findByThriftIdOrThrow(int fieldId) {
30604 _Fields fields = findByThriftId(fieldId);
30605 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30606 return fields;
30607 }
30608
30609
30610
30611
30612 public static _Fields findByName(String name) {
30613 return byName.get(name);
30614 }
30615
30616 private final short _thriftId;
30617 private final String _fieldName;
30618
30619 _Fields(short thriftId, String fieldName) {
30620 _thriftId = thriftId;
30621 _fieldName = fieldName;
30622 }
30623
30624 public short getThriftFieldId() {
30625 return _thriftId;
30626 }
30627
30628 public String getFieldName() {
30629 return _fieldName;
30630 }
30631 }
30632
30633
30634 private static final int __SUCCESS_ISSET_ID = 0;
30635 private BitSet __isset_bit_vector = new BitSet(1);
30636
30637 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30638 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
30639 new FieldValueMetaData(TType.I32)));
30640 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
30641 new FieldValueMetaData(TType.STRUCT)));
30642 }});
30643
30644 static {
30645 FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_result.class, metaDataMap);
30646 }
30647
30648 public scannerOpenWithPrefix_result() {
30649 }
30650
30651 public scannerOpenWithPrefix_result(
30652 int success,
30653 IOError io)
30654 {
30655 this();
30656 this.success = success;
30657 setSuccessIsSet(true);
30658 this.io = io;
30659 }
30660
30661
30662
30663
30664 public scannerOpenWithPrefix_result(scannerOpenWithPrefix_result other) {
30665 __isset_bit_vector.clear();
30666 __isset_bit_vector.or(other.__isset_bit_vector);
30667 this.success = other.success;
30668 if (other.isSetIo()) {
30669 this.io = new IOError(other.io);
30670 }
30671 }
30672
30673 public scannerOpenWithPrefix_result deepCopy() {
30674 return new scannerOpenWithPrefix_result(this);
30675 }
30676
30677 @Deprecated
30678 public scannerOpenWithPrefix_result clone() {
30679 return new scannerOpenWithPrefix_result(this);
30680 }
30681
30682 public int getSuccess() {
30683 return this.success;
30684 }
30685
30686 public scannerOpenWithPrefix_result setSuccess(int success) {
30687 this.success = success;
30688 setSuccessIsSet(true);
30689 return this;
30690 }
30691
30692 public void unsetSuccess() {
30693 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
30694 }
30695
30696
30697 public boolean isSetSuccess() {
30698 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
30699 }
30700
30701 public void setSuccessIsSet(boolean value) {
30702 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
30703 }
30704
30705 public IOError getIo() {
30706 return this.io;
30707 }
30708
30709 public scannerOpenWithPrefix_result setIo(IOError io) {
30710 this.io = io;
30711 return this;
30712 }
30713
30714 public void unsetIo() {
30715 this.io = null;
30716 }
30717
30718
30719 public boolean isSetIo() {
30720 return this.io != null;
30721 }
30722
30723 public void setIoIsSet(boolean value) {
30724 if (!value) {
30725 this.io = null;
30726 }
30727 }
30728
30729 public void setFieldValue(_Fields field, Object value) {
30730 switch (field) {
30731 case SUCCESS:
30732 if (value == null) {
30733 unsetSuccess();
30734 } else {
30735 setSuccess((Integer)value);
30736 }
30737 break;
30738
30739 case IO:
30740 if (value == null) {
30741 unsetIo();
30742 } else {
30743 setIo((IOError)value);
30744 }
30745 break;
30746
30747 }
30748 }
30749
30750 public void setFieldValue(int fieldID, Object value) {
30751 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
30752 }
30753
30754 public Object getFieldValue(_Fields field) {
30755 switch (field) {
30756 case SUCCESS:
30757 return new Integer(getSuccess());
30758
30759 case IO:
30760 return getIo();
30761
30762 }
30763 throw new IllegalStateException();
30764 }
30765
30766 public Object getFieldValue(int fieldId) {
30767 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
30768 }
30769
30770
30771 public boolean isSet(_Fields field) {
30772 switch (field) {
30773 case SUCCESS:
30774 return isSetSuccess();
30775 case IO:
30776 return isSetIo();
30777 }
30778 throw new IllegalStateException();
30779 }
30780
30781 public boolean isSet(int fieldID) {
30782 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30783 }
30784
30785 @Override
30786 public boolean equals(Object that) {
30787 if (that == null)
30788 return false;
30789 if (that instanceof scannerOpenWithPrefix_result)
30790 return this.equals((scannerOpenWithPrefix_result)that);
30791 return false;
30792 }
30793
30794 public boolean equals(scannerOpenWithPrefix_result that) {
30795 if (that == null)
30796 return false;
30797
30798 boolean this_present_success = true;
30799 boolean that_present_success = true;
30800 if (this_present_success || that_present_success) {
30801 if (!(this_present_success && that_present_success))
30802 return false;
30803 if (this.success != that.success)
30804 return false;
30805 }
30806
30807 boolean this_present_io = true && this.isSetIo();
30808 boolean that_present_io = true && that.isSetIo();
30809 if (this_present_io || that_present_io) {
30810 if (!(this_present_io && that_present_io))
30811 return false;
30812 if (!this.io.equals(that.io))
30813 return false;
30814 }
30815
30816 return true;
30817 }
30818
30819 @Override
30820 public int hashCode() {
30821 HashCodeBuilder builder = new HashCodeBuilder();
30822
30823 boolean present_success = true;
30824 builder.append(present_success);
30825 if (present_success)
30826 builder.append(success);
30827
30828 boolean present_io = true && (isSetIo());
30829 builder.append(present_io);
30830 if (present_io)
30831 builder.append(io);
30832
30833 return builder.toHashCode();
30834 }
30835
30836 public int compareTo(scannerOpenWithPrefix_result other) {
30837 if (!getClass().equals(other.getClass())) {
30838 return getClass().getName().compareTo(other.getClass().getName());
30839 }
30840
30841 int lastComparison = 0;
30842 scannerOpenWithPrefix_result typedOther = (scannerOpenWithPrefix_result)other;
30843
30844 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
30845 if (lastComparison != 0) {
30846 return lastComparison;
30847 }
30848 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
30849 if (lastComparison != 0) {
30850 return lastComparison;
30851 }
30852 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
30853 if (lastComparison != 0) {
30854 return lastComparison;
30855 }
30856 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
30857 if (lastComparison != 0) {
30858 return lastComparison;
30859 }
30860 return 0;
30861 }
30862
30863 public void read(TProtocol iprot) throws TException {
30864 TField field;
30865 iprot.readStructBegin();
30866 while (true)
30867 {
30868 field = iprot.readFieldBegin();
30869 if (field.type == TType.STOP) {
30870 break;
30871 }
30872 _Fields fieldId = _Fields.findByThriftId(field.id);
30873 if (fieldId == null) {
30874 TProtocolUtil.skip(iprot, field.type);
30875 } else {
30876 switch (fieldId) {
30877 case SUCCESS:
30878 if (field.type == TType.I32) {
30879 this.success = iprot.readI32();
30880 setSuccessIsSet(true);
30881 } else {
30882 TProtocolUtil.skip(iprot, field.type);
30883 }
30884 break;
30885 case IO:
30886 if (field.type == TType.STRUCT) {
30887 this.io = new IOError();
30888 this.io.read(iprot);
30889 } else {
30890 TProtocolUtil.skip(iprot, field.type);
30891 }
30892 break;
30893 }
30894 iprot.readFieldEnd();
30895 }
30896 }
30897 iprot.readStructEnd();
30898
30899
30900 validate();
30901 }
30902
30903 public void write(TProtocol oprot) throws TException {
30904 oprot.writeStructBegin(STRUCT_DESC);
30905
30906 if (this.isSetSuccess()) {
30907 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30908 oprot.writeI32(this.success);
30909 oprot.writeFieldEnd();
30910 } else if (this.isSetIo()) {
30911 oprot.writeFieldBegin(IO_FIELD_DESC);
30912 this.io.write(oprot);
30913 oprot.writeFieldEnd();
30914 }
30915 oprot.writeFieldStop();
30916 oprot.writeStructEnd();
30917 }
30918
30919 @Override
30920 public String toString() {
30921 StringBuilder sb = new StringBuilder("scannerOpenWithPrefix_result(");
30922 boolean first = true;
30923
30924 sb.append("success:");
30925 sb.append(this.success);
30926 first = false;
30927 if (!first) sb.append(", ");
30928 sb.append("io:");
30929 if (this.io == null) {
30930 sb.append("null");
30931 } else {
30932 sb.append(this.io);
30933 }
30934 first = false;
30935 sb.append(")");
30936 return sb.toString();
30937 }
30938
30939 public void validate() throws TException {
30940
30941 }
30942
30943 }
30944
30945 public static class scannerOpenTs_args implements TBase<scannerOpenTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_args> {
30946 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_args");
30947
30948 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
30949 private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
30950 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
30951 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
30952
30953
30954
30955
30956 public byte[] tableName;
30957
30958
30959
30960
30961 public byte[] startRow;
30962
30963
30964
30965
30966
30967 public List<byte[]> columns;
30968
30969
30970
30971 public long timestamp;
30972
30973
30974 public enum _Fields implements TFieldIdEnum {
30975
30976
30977
30978 TABLE_NAME((short)1, "tableName"),
30979
30980
30981
30982
30983 START_ROW((short)2, "startRow"),
30984
30985
30986
30987
30988
30989 COLUMNS((short)3, "columns"),
30990
30991
30992
30993 TIMESTAMP((short)4, "timestamp");
30994
30995 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30996 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30997
30998 static {
30999 for (_Fields field : EnumSet.allOf(_Fields.class)) {
31000 byId.put((int)field._thriftId, field);
31001 byName.put(field.getFieldName(), field);
31002 }
31003 }
31004
31005
31006
31007
31008 public static _Fields findByThriftId(int fieldId) {
31009 return byId.get(fieldId);
31010 }
31011
31012
31013
31014
31015
31016 public static _Fields findByThriftIdOrThrow(int fieldId) {
31017 _Fields fields = findByThriftId(fieldId);
31018 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
31019 return fields;
31020 }
31021
31022
31023
31024
31025 public static _Fields findByName(String name) {
31026 return byName.get(name);
31027 }
31028
31029 private final short _thriftId;
31030 private final String _fieldName;
31031
31032 _Fields(short thriftId, String fieldName) {
31033 _thriftId = thriftId;
31034 _fieldName = fieldName;
31035 }
31036
31037 public short getThriftFieldId() {
31038 return _thriftId;
31039 }
31040
31041 public String getFieldName() {
31042 return _fieldName;
31043 }
31044 }
31045
31046
31047 private static final int __TIMESTAMP_ISSET_ID = 0;
31048 private BitSet __isset_bit_vector = new BitSet(1);
31049
31050 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
31051 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
31052 new FieldValueMetaData(TType.STRING)));
31053 put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
31054 new FieldValueMetaData(TType.STRING)));
31055 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
31056 new ListMetaData(TType.LIST,
31057 new FieldValueMetaData(TType.STRING))));
31058 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
31059 new FieldValueMetaData(TType.I64)));
31060 }});
31061
31062 static {
31063 FieldMetaData.addStructMetaDataMap(scannerOpenTs_args.class, metaDataMap);
31064 }
31065
31066 public scannerOpenTs_args() {
31067 }
31068
31069 public scannerOpenTs_args(
31070 byte[] tableName,
31071 byte[] startRow,
31072 List<byte[]> columns,
31073 long timestamp)
31074 {
31075 this();
31076 this.tableName = tableName;
31077 this.startRow = startRow;
31078 this.columns = columns;
31079 this.timestamp = timestamp;
31080 setTimestampIsSet(true);
31081 }
31082
31083
31084
31085
31086 public scannerOpenTs_args(scannerOpenTs_args other) {
31087 __isset_bit_vector.clear();
31088 __isset_bit_vector.or(other.__isset_bit_vector);
31089 if (other.isSetTableName()) {
31090 this.tableName = other.tableName;
31091 }
31092 if (other.isSetStartRow()) {
31093 this.startRow = other.startRow;
31094 }
31095 if (other.isSetColumns()) {
31096 List<byte[]> __this__columns = new ArrayList<byte[]>();
31097 for (byte[] other_element : other.columns) {
31098 __this__columns.add(other_element);
31099 }
31100 this.columns = __this__columns;
31101 }
31102 this.timestamp = other.timestamp;
31103 }
31104
31105 public scannerOpenTs_args deepCopy() {
31106 return new scannerOpenTs_args(this);
31107 }
31108
31109 @Deprecated
31110 public scannerOpenTs_args clone() {
31111 return new scannerOpenTs_args(this);
31112 }
31113
31114
31115
31116
31117 public byte[] getTableName() {
31118 return this.tableName;
31119 }
31120
31121
31122
31123
31124 public scannerOpenTs_args setTableName(byte[] tableName) {
31125 this.tableName = tableName;
31126 return this;
31127 }
31128
31129 public void unsetTableName() {
31130 this.tableName = null;
31131 }
31132
31133
31134 public boolean isSetTableName() {
31135 return this.tableName != null;
31136 }
31137
31138 public void setTableNameIsSet(boolean value) {
31139 if (!value) {
31140 this.tableName = null;
31141 }
31142 }
31143
31144
31145
31146
31147
31148 public byte[] getStartRow() {
31149 return this.startRow;
31150 }
31151
31152
31153
31154
31155
31156 public scannerOpenTs_args setStartRow(byte[] startRow) {
31157 this.startRow = startRow;
31158 return this;
31159 }
31160
31161 public void unsetStartRow() {
31162 this.startRow = null;
31163 }
31164
31165
31166 public boolean isSetStartRow() {
31167 return this.startRow != null;
31168 }
31169
31170 public void setStartRowIsSet(boolean value) {
31171 if (!value) {
31172 this.startRow = null;
31173 }
31174 }
31175
31176 public int getColumnsSize() {
31177 return (this.columns == null) ? 0 : this.columns.size();
31178 }
31179
31180 public java.util.Iterator<byte[]> getColumnsIterator() {
31181 return (this.columns == null) ? null : this.columns.iterator();
31182 }
31183
31184 public void addToColumns(byte[] elem) {
31185 if (this.columns == null) {
31186 this.columns = new ArrayList<byte[]>();
31187 }
31188 this.columns.add(elem);
31189 }
31190
31191
31192
31193
31194
31195
31196 public List<byte[]> getColumns() {
31197 return this.columns;
31198 }
31199
31200
31201
31202
31203
31204
31205 public scannerOpenTs_args setColumns(List<byte[]> columns) {
31206 this.columns = columns;
31207 return this;
31208 }
31209
31210 public void unsetColumns() {
31211 this.columns = null;
31212 }
31213
31214
31215 public boolean isSetColumns() {
31216 return this.columns != null;
31217 }
31218
31219 public void setColumnsIsSet(boolean value) {
31220 if (!value) {
31221 this.columns = null;
31222 }
31223 }
31224
31225
31226
31227
31228 public long getTimestamp() {
31229 return this.timestamp;
31230 }
31231
31232
31233
31234
31235 public scannerOpenTs_args setTimestamp(long timestamp) {
31236 this.timestamp = timestamp;
31237 setTimestampIsSet(true);
31238 return this;
31239 }
31240
31241 public void unsetTimestamp() {
31242 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
31243 }
31244
31245
31246 public boolean isSetTimestamp() {
31247 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
31248 }
31249
31250 public void setTimestampIsSet(boolean value) {
31251 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
31252 }
31253
31254 public void setFieldValue(_Fields field, Object value) {
31255 switch (field) {
31256 case TABLE_NAME:
31257 if (value == null) {
31258 unsetTableName();
31259 } else {
31260 setTableName((byte[])value);
31261 }
31262 break;
31263
31264 case START_ROW:
31265 if (value == null) {
31266 unsetStartRow();
31267 } else {
31268 setStartRow((byte[])value);
31269 }
31270 break;
31271
31272 case COLUMNS:
31273 if (value == null) {
31274 unsetColumns();
31275 } else {
31276 setColumns((List<byte[]>)value);
31277 }
31278 break;
31279
31280 case TIMESTAMP:
31281 if (value == null) {
31282 unsetTimestamp();
31283 } else {
31284 setTimestamp((Long)value);
31285 }
31286 break;
31287
31288 }
31289 }
31290
31291 public void setFieldValue(int fieldID, Object value) {
31292 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
31293 }
31294
31295 public Object getFieldValue(_Fields field) {
31296 switch (field) {
31297 case TABLE_NAME:
31298 return getTableName();
31299
31300 case START_ROW:
31301 return getStartRow();
31302
31303 case COLUMNS:
31304 return getColumns();
31305
31306 case TIMESTAMP:
31307 return new Long(getTimestamp());
31308
31309 }
31310 throw new IllegalStateException();
31311 }
31312
31313 public Object getFieldValue(int fieldId) {
31314 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
31315 }
31316
31317
31318 public boolean isSet(_Fields field) {
31319 switch (field) {
31320 case TABLE_NAME:
31321 return isSetTableName();
31322 case START_ROW:
31323 return isSetStartRow();
31324 case COLUMNS:
31325 return isSetColumns();
31326 case TIMESTAMP:
31327 return isSetTimestamp();
31328 }
31329 throw new IllegalStateException();
31330 }
31331
31332 public boolean isSet(int fieldID) {
31333 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
31334 }
31335
31336 @Override
31337 public boolean equals(Object that) {
31338 if (that == null)
31339 return false;
31340 if (that instanceof scannerOpenTs_args)
31341 return this.equals((scannerOpenTs_args)that);
31342 return false;
31343 }
31344
31345 public boolean equals(scannerOpenTs_args that) {
31346 if (that == null)
31347 return false;
31348
31349 boolean this_present_tableName = true && this.isSetTableName();
31350 boolean that_present_tableName = true && that.isSetTableName();
31351 if (this_present_tableName || that_present_tableName) {
31352 if (!(this_present_tableName && that_present_tableName))
31353 return false;
31354 if (!java.util.Arrays.equals(this.tableName, that.tableName))
31355 return false;
31356 }
31357
31358 boolean this_present_startRow = true && this.isSetStartRow();
31359 boolean that_present_startRow = true && that.isSetStartRow();
31360 if (this_present_startRow || that_present_startRow) {
31361 if (!(this_present_startRow && that_present_startRow))
31362 return false;
31363 if (!java.util.Arrays.equals(this.startRow, that.startRow))
31364 return false;
31365 }
31366
31367 boolean this_present_columns = true && this.isSetColumns();
31368 boolean that_present_columns = true && that.isSetColumns();
31369 if (this_present_columns || that_present_columns) {
31370 if (!(this_present_columns && that_present_columns))
31371 return false;
31372 if (!this.columns.equals(that.columns))
31373 return false;
31374 }
31375
31376 boolean this_present_timestamp = true;
31377 boolean that_present_timestamp = true;
31378 if (this_present_timestamp || that_present_timestamp) {
31379 if (!(this_present_timestamp && that_present_timestamp))
31380 return false;
31381 if (this.timestamp != that.timestamp)
31382 return false;
31383 }
31384
31385 return true;
31386 }
31387
31388 @Override
31389 public int hashCode() {
31390 HashCodeBuilder builder = new HashCodeBuilder();
31391
31392 boolean present_tableName = true && (isSetTableName());
31393 builder.append(present_tableName);
31394 if (present_tableName)
31395 builder.append(tableName);
31396
31397 boolean present_startRow = true && (isSetStartRow());
31398 builder.append(present_startRow);
31399 if (present_startRow)
31400 builder.append(startRow);
31401
31402 boolean present_columns = true && (isSetColumns());
31403 builder.append(present_columns);
31404 if (present_columns)
31405 builder.append(columns);
31406
31407 boolean present_timestamp = true;
31408 builder.append(present_timestamp);
31409 if (present_timestamp)
31410 builder.append(timestamp);
31411
31412 return builder.toHashCode();
31413 }
31414
31415 public int compareTo(scannerOpenTs_args other) {
31416 if (!getClass().equals(other.getClass())) {
31417 return getClass().getName().compareTo(other.getClass().getName());
31418 }
31419
31420 int lastComparison = 0;
31421 scannerOpenTs_args typedOther = (scannerOpenTs_args)other;
31422
31423 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
31424 if (lastComparison != 0) {
31425 return lastComparison;
31426 }
31427 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
31428 if (lastComparison != 0) {
31429 return lastComparison;
31430 }
31431 lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
31432 if (lastComparison != 0) {
31433 return lastComparison;
31434 }
31435 lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
31436 if (lastComparison != 0) {
31437 return lastComparison;
31438 }
31439 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
31440 if (lastComparison != 0) {
31441 return lastComparison;
31442 }
31443 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
31444 if (lastComparison != 0) {
31445 return lastComparison;
31446 }
31447 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
31448 if (lastComparison != 0) {
31449 return lastComparison;
31450 }
31451 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
31452 if (lastComparison != 0) {
31453 return lastComparison;
31454 }
31455 return 0;
31456 }
31457
31458 public void read(TProtocol iprot) throws TException {
31459 TField field;
31460 iprot.readStructBegin();
31461 while (true)
31462 {
31463 field = iprot.readFieldBegin();
31464 if (field.type == TType.STOP) {
31465 break;
31466 }
31467 _Fields fieldId = _Fields.findByThriftId(field.id);
31468 if (fieldId == null) {
31469 TProtocolUtil.skip(iprot, field.type);
31470 } else {
31471 switch (fieldId) {
31472 case TABLE_NAME:
31473 if (field.type == TType.STRING) {
31474 this.tableName = iprot.readBinary();
31475 } else {
31476 TProtocolUtil.skip(iprot, field.type);
31477 }
31478 break;
31479 case START_ROW:
31480 if (field.type == TType.STRING) {
31481 this.startRow = iprot.readBinary();
31482 } else {
31483 TProtocolUtil.skip(iprot, field.type);
31484 }
31485 break;
31486 case COLUMNS:
31487 if (field.type == TType.LIST) {
31488 {
31489 TList _list130 = iprot.readListBegin();
31490 this.columns = new ArrayList<byte[]>(_list130.size);
31491 for (int _i131 = 0; _i131 < _list130.size; ++_i131)
31492 {
31493 byte[] _elem132;
31494 _elem132 = iprot.readBinary();
31495 this.columns.add(_elem132);
31496 }
31497 iprot.readListEnd();
31498 }
31499 } else {
31500 TProtocolUtil.skip(iprot, field.type);
31501 }
31502 break;
31503 case TIMESTAMP:
31504 if (field.type == TType.I64) {
31505 this.timestamp = iprot.readI64();
31506 setTimestampIsSet(true);
31507 } else {
31508 TProtocolUtil.skip(iprot, field.type);
31509 }
31510 break;
31511 }
31512 iprot.readFieldEnd();
31513 }
31514 }
31515 iprot.readStructEnd();
31516
31517
31518 validate();
31519 }
31520
31521 public void write(TProtocol oprot) throws TException {
31522 validate();
31523
31524 oprot.writeStructBegin(STRUCT_DESC);
31525 if (this.tableName != null) {
31526 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
31527 oprot.writeBinary(this.tableName);
31528 oprot.writeFieldEnd();
31529 }
31530 if (this.startRow != null) {
31531 oprot.writeFieldBegin(START_ROW_FIELD_DESC);
31532 oprot.writeBinary(this.startRow);
31533 oprot.writeFieldEnd();
31534 }
31535 if (this.columns != null) {
31536 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
31537 {
31538 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
31539 for (byte[] _iter133 : this.columns)
31540 {
31541 oprot.writeBinary(_iter133);
31542 }
31543 oprot.writeListEnd();
31544 }
31545 oprot.writeFieldEnd();
31546 }
31547 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
31548 oprot.writeI64(this.timestamp);
31549 oprot.writeFieldEnd();
31550 oprot.writeFieldStop();
31551 oprot.writeStructEnd();
31552 }
31553
31554 @Override
31555 public String toString() {
31556 StringBuilder sb = new StringBuilder("scannerOpenTs_args(");
31557 boolean first = true;
31558
31559 sb.append("tableName:");
31560 if (this.tableName == null) {
31561 sb.append("null");
31562 } else {
31563 sb.append(this.tableName);
31564 }
31565 first = false;
31566 if (!first) sb.append(", ");
31567 sb.append("startRow:");
31568 if (this.startRow == null) {
31569 sb.append("null");
31570 } else {
31571 sb.append(this.startRow);
31572 }
31573 first = false;
31574 if (!first) sb.append(", ");
31575 sb.append("columns:");
31576 if (this.columns == null) {
31577 sb.append("null");
31578 } else {
31579 sb.append(this.columns);
31580 }
31581 first = false;
31582 if (!first) sb.append(", ");
31583 sb.append("timestamp:");
31584 sb.append(this.timestamp);
31585 first = false;
31586 sb.append(")");
31587 return sb.toString();
31588 }
31589
31590 public void validate() throws TException {
31591
31592 }
31593
31594 }
31595
31596 public static class scannerOpenTs_result implements TBase<scannerOpenTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_result> {
31597 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_result");
31598
31599 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
31600 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
31601
31602 public int success;
31603 public IOError io;
31604
31605
31606 public enum _Fields implements TFieldIdEnum {
31607 SUCCESS((short)0, "success"),
31608 IO((short)1, "io");
31609
31610 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
31611 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
31612
31613 static {
31614 for (_Fields field : EnumSet.allOf(_Fields.class)) {
31615 byId.put((int)field._thriftId, field);
31616 byName.put(field.getFieldName(), field);
31617 }
31618 }
31619
31620
31621
31622
31623 public static _Fields findByThriftId(int fieldId) {
31624 return byId.get(fieldId);
31625 }
31626
31627
31628
31629
31630
31631 public static _Fields findByThriftIdOrThrow(int fieldId) {
31632 _Fields fields = findByThriftId(fieldId);
31633 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
31634 return fields;
31635 }
31636
31637
31638
31639
31640 public static _Fields findByName(String name) {
31641 return byName.get(name);
31642 }
31643
31644 private final short _thriftId;
31645 private final String _fieldName;
31646
31647 _Fields(short thriftId, String fieldName) {
31648 _thriftId = thriftId;
31649 _fieldName = fieldName;
31650 }
31651
31652 public short getThriftFieldId() {
31653 return _thriftId;
31654 }
31655
31656 public String getFieldName() {
31657 return _fieldName;
31658 }
31659 }
31660
31661
31662 private static final int __SUCCESS_ISSET_ID = 0;
31663 private BitSet __isset_bit_vector = new BitSet(1);
31664
31665 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
31666 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
31667 new FieldValueMetaData(TType.I32)));
31668 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
31669 new FieldValueMetaData(TType.STRUCT)));
31670 }});
31671
31672 static {
31673 FieldMetaData.addStructMetaDataMap(scannerOpenTs_result.class, metaDataMap);
31674 }
31675
31676 public scannerOpenTs_result() {
31677 }
31678
31679 public scannerOpenTs_result(
31680 int success,
31681 IOError io)
31682 {
31683 this();
31684 this.success = success;
31685 setSuccessIsSet(true);
31686 this.io = io;
31687 }
31688
31689
31690
31691
31692 public scannerOpenTs_result(scannerOpenTs_result other) {
31693 __isset_bit_vector.clear();
31694 __isset_bit_vector.or(other.__isset_bit_vector);
31695 this.success = other.success;
31696 if (other.isSetIo()) {
31697 this.io = new IOError(other.io);
31698 }
31699 }
31700
31701 public scannerOpenTs_result deepCopy() {
31702 return new scannerOpenTs_result(this);
31703 }
31704
31705 @Deprecated
31706 public scannerOpenTs_result clone() {
31707 return new scannerOpenTs_result(this);
31708 }
31709
31710 public int getSuccess() {
31711 return this.success;
31712 }
31713
31714 public scannerOpenTs_result setSuccess(int success) {
31715 this.success = success;
31716 setSuccessIsSet(true);
31717 return this;
31718 }
31719
31720 public void unsetSuccess() {
31721 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
31722 }
31723
31724
31725 public boolean isSetSuccess() {
31726 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
31727 }
31728
31729 public void setSuccessIsSet(boolean value) {
31730 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
31731 }
31732
31733 public IOError getIo() {
31734 return this.io;
31735 }
31736
31737 public scannerOpenTs_result setIo(IOError io) {
31738 this.io = io;
31739 return this;
31740 }
31741
31742 public void unsetIo() {
31743 this.io = null;
31744 }
31745
31746
31747 public boolean isSetIo() {
31748 return this.io != null;
31749 }
31750
31751 public void setIoIsSet(boolean value) {
31752 if (!value) {
31753 this.io = null;
31754 }
31755 }
31756
31757 public void setFieldValue(_Fields field, Object value) {
31758 switch (field) {
31759 case SUCCESS:
31760 if (value == null) {
31761 unsetSuccess();
31762 } else {
31763 setSuccess((Integer)value);
31764 }
31765 break;
31766
31767 case IO:
31768 if (value == null) {
31769 unsetIo();
31770 } else {
31771 setIo((IOError)value);
31772 }
31773 break;
31774
31775 }
31776 }
31777
31778 public void setFieldValue(int fieldID, Object value) {
31779 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
31780 }
31781
31782 public Object getFieldValue(_Fields field) {
31783 switch (field) {
31784 case SUCCESS:
31785 return new Integer(getSuccess());
31786
31787 case IO:
31788 return getIo();
31789
31790 }
31791 throw new IllegalStateException();
31792 }
31793
31794 public Object getFieldValue(int fieldId) {
31795 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
31796 }
31797
31798
31799 public boolean isSet(_Fields field) {
31800 switch (field) {
31801 case SUCCESS:
31802 return isSetSuccess();
31803 case IO:
31804 return isSetIo();
31805 }
31806 throw new IllegalStateException();
31807 }
31808
31809 public boolean isSet(int fieldID) {
31810 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
31811 }
31812
31813 @Override
31814 public boolean equals(Object that) {
31815 if (that == null)
31816 return false;
31817 if (that instanceof scannerOpenTs_result)
31818 return this.equals((scannerOpenTs_result)that);
31819 return false;
31820 }
31821
31822 public boolean equals(scannerOpenTs_result that) {
31823 if (that == null)
31824 return false;
31825
31826 boolean this_present_success = true;
31827 boolean that_present_success = true;
31828 if (this_present_success || that_present_success) {
31829 if (!(this_present_success && that_present_success))
31830 return false;
31831 if (this.success != that.success)
31832 return false;
31833 }
31834
31835 boolean this_present_io = true && this.isSetIo();
31836 boolean that_present_io = true && that.isSetIo();
31837 if (this_present_io || that_present_io) {
31838 if (!(this_present_io && that_present_io))
31839 return false;
31840 if (!this.io.equals(that.io))
31841 return false;
31842 }
31843
31844 return true;
31845 }
31846
31847 @Override
31848 public int hashCode() {
31849 HashCodeBuilder builder = new HashCodeBuilder();
31850
31851 boolean present_success = true;
31852 builder.append(present_success);
31853 if (present_success)
31854 builder.append(success);
31855
31856 boolean present_io = true && (isSetIo());
31857 builder.append(present_io);
31858 if (present_io)
31859 builder.append(io);
31860
31861 return builder.toHashCode();
31862 }
31863
31864 public int compareTo(scannerOpenTs_result other) {
31865 if (!getClass().equals(other.getClass())) {
31866 return getClass().getName().compareTo(other.getClass().getName());
31867 }
31868
31869 int lastComparison = 0;
31870 scannerOpenTs_result typedOther = (scannerOpenTs_result)other;
31871
31872 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
31873 if (lastComparison != 0) {
31874 return lastComparison;
31875 }
31876 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
31877 if (lastComparison != 0) {
31878 return lastComparison;
31879 }
31880 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
31881 if (lastComparison != 0) {
31882 return lastComparison;
31883 }
31884 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
31885 if (lastComparison != 0) {
31886 return lastComparison;
31887 }
31888 return 0;
31889 }
31890
31891 public void read(TProtocol iprot) throws TException {
31892 TField field;
31893 iprot.readStructBegin();
31894 while (true)
31895 {
31896 field = iprot.readFieldBegin();
31897 if (field.type == TType.STOP) {
31898 break;
31899 }
31900 _Fields fieldId = _Fields.findByThriftId(field.id);
31901 if (fieldId == null) {
31902 TProtocolUtil.skip(iprot, field.type);
31903 } else {
31904 switch (fieldId) {
31905 case SUCCESS:
31906 if (field.type == TType.I32) {
31907 this.success = iprot.readI32();
31908 setSuccessIsSet(true);
31909 } else {
31910 TProtocolUtil.skip(iprot, field.type);
31911 }
31912 break;
31913 case IO:
31914 if (field.type == TType.STRUCT) {
31915 this.io = new IOError();
31916 this.io.read(iprot);
31917 } else {
31918 TProtocolUtil.skip(iprot, field.type);
31919 }
31920 break;
31921 }
31922 iprot.readFieldEnd();
31923 }
31924 }
31925 iprot.readStructEnd();
31926
31927
31928 validate();
31929 }
31930
31931 public void write(TProtocol oprot) throws TException {
31932 oprot.writeStructBegin(STRUCT_DESC);
31933
31934 if (this.isSetSuccess()) {
31935 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
31936 oprot.writeI32(this.success);
31937 oprot.writeFieldEnd();
31938 } else if (this.isSetIo()) {
31939 oprot.writeFieldBegin(IO_FIELD_DESC);
31940 this.io.write(oprot);
31941 oprot.writeFieldEnd();
31942 }
31943 oprot.writeFieldStop();
31944 oprot.writeStructEnd();
31945 }
31946
31947 @Override
31948 public String toString() {
31949 StringBuilder sb = new StringBuilder("scannerOpenTs_result(");
31950 boolean first = true;
31951
31952 sb.append("success:");
31953 sb.append(this.success);
31954 first = false;
31955 if (!first) sb.append(", ");
31956 sb.append("io:");
31957 if (this.io == null) {
31958 sb.append("null");
31959 } else {
31960 sb.append(this.io);
31961 }
31962 first = false;
31963 sb.append(")");
31964 return sb.toString();
31965 }
31966
31967 public void validate() throws TException {
31968
31969 }
31970
31971 }
31972
31973 public static class scannerOpenWithStopTs_args implements TBase<scannerOpenWithStopTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_args> {
31974 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_args");
31975
31976 private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
31977 private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
31978 private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3);
31979 private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4);
31980 private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)5);
31981
31982
31983
31984
31985 public byte[] tableName;
31986
31987
31988
31989
31990 public byte[] startRow;
31991
31992
31993
31994
31995 public byte[] stopRow;
31996
31997
31998
31999
32000
32001 public List<byte[]> columns;
32002
32003
32004
32005 public long timestamp;
32006
32007
32008 public enum _Fields implements TFieldIdEnum {
32009
32010
32011
32012 TABLE_NAME((short)1, "tableName"),
32013
32014
32015
32016
32017 START_ROW((short)2, "startRow"),
32018
32019
32020
32021
32022 STOP_ROW((short)3, "stopRow"),
32023
32024
32025
32026
32027
32028 COLUMNS((short)4, "columns"),
32029
32030
32031
32032 TIMESTAMP((short)5, "timestamp");
32033
32034 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
32035 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
32036
32037 static {
32038 for (_Fields field : EnumSet.allOf(_Fields.class)) {
32039 byId.put((int)field._thriftId, field);
32040 byName.put(field.getFieldName(), field);
32041 }
32042 }
32043
32044
32045
32046
32047 public static _Fields findByThriftId(int fieldId) {
32048 return byId.get(fieldId);
32049 }
32050
32051
32052
32053
32054
32055 public static _Fields findByThriftIdOrThrow(int fieldId) {
32056 _Fields fields = findByThriftId(fieldId);
32057 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
32058 return fields;
32059 }
32060
32061
32062
32063
32064 public static _Fields findByName(String name) {
32065 return byName.get(name);
32066 }
32067
32068 private final short _thriftId;
32069 private final String _fieldName;
32070
32071 _Fields(short thriftId, String fieldName) {
32072 _thriftId = thriftId;
32073 _fieldName = fieldName;
32074 }
32075
32076 public short getThriftFieldId() {
32077 return _thriftId;
32078 }
32079
32080 public String getFieldName() {
32081 return _fieldName;
32082 }
32083 }
32084
32085
32086 private static final int __TIMESTAMP_ISSET_ID = 0;
32087 private BitSet __isset_bit_vector = new BitSet(1);
32088
32089 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
32090 put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
32091 new FieldValueMetaData(TType.STRING)));
32092 put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
32093 new FieldValueMetaData(TType.STRING)));
32094 put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT,
32095 new FieldValueMetaData(TType.STRING)));
32096 put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
32097 new ListMetaData(TType.LIST,
32098 new FieldValueMetaData(TType.STRING))));
32099 put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
32100 new FieldValueMetaData(TType.I64)));
32101 }});
32102
32103 static {
32104 FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_args.class, metaDataMap);
32105 }
32106
32107 public scannerOpenWithStopTs_args() {
32108 }
32109
32110 public scannerOpenWithStopTs_args(
32111 byte[] tableName,
32112 byte[] startRow,
32113 byte[] stopRow,
32114 List<byte[]> columns,
32115 long timestamp)
32116 {
32117 this();
32118 this.tableName = tableName;
32119 this.startRow = startRow;
32120 this.stopRow = stopRow;
32121 this.columns = columns;
32122 this.timestamp = timestamp;
32123 setTimestampIsSet(true);
32124 }
32125
32126
32127
32128
32129 public scannerOpenWithStopTs_args(scannerOpenWithStopTs_args other) {
32130 __isset_bit_vector.clear();
32131 __isset_bit_vector.or(other.__isset_bit_vector);
32132 if (other.isSetTableName()) {
32133 this.tableName = other.tableName;
32134 }
32135 if (other.isSetStartRow()) {
32136 this.startRow = other.startRow;
32137 }
32138 if (other.isSetStopRow()) {
32139 this.stopRow = other.stopRow;
32140 }
32141 if (other.isSetColumns()) {
32142 List<byte[]> __this__columns = new ArrayList<byte[]>();
32143 for (byte[] other_element : other.columns) {
32144 __this__columns.add(other_element);
32145 }
32146 this.columns = __this__columns;
32147 }
32148 this.timestamp = other.timestamp;
32149 }
32150
32151 public scannerOpenWithStopTs_args deepCopy() {
32152 return new scannerOpenWithStopTs_args(this);
32153 }
32154
32155 @Deprecated
32156 public scannerOpenWithStopTs_args clone() {
32157 return new scannerOpenWithStopTs_args(this);
32158 }
32159
32160
32161
32162
32163 public byte[] getTableName() {
32164 return this.tableName;
32165 }
32166
32167
32168
32169
32170 public scannerOpenWithStopTs_args setTableName(byte[] tableName) {
32171 this.tableName = tableName;
32172 return this;
32173 }
32174
32175 public void unsetTableName() {
32176 this.tableName = null;
32177 }
32178
32179
32180 public boolean isSetTableName() {
32181 return this.tableName != null;
32182 }
32183
32184 public void setTableNameIsSet(boolean value) {
32185 if (!value) {
32186 this.tableName = null;
32187 }
32188 }
32189
32190
32191
32192
32193
32194 public byte[] getStartRow() {
32195 return this.startRow;
32196 }
32197
32198
32199
32200
32201
32202 public scannerOpenWithStopTs_args setStartRow(byte[] startRow) {
32203 this.startRow = startRow;
32204 return this;
32205 }
32206
32207 public void unsetStartRow() {
32208 this.startRow = null;
32209 }
32210
32211
32212 public boolean isSetStartRow() {
32213 return this.startRow != null;
32214 }
32215
32216 public void setStartRowIsSet(boolean value) {
32217 if (!value) {
32218 this.startRow = null;
32219 }
32220 }
32221
32222
32223
32224
32225
32226 public byte[] getStopRow() {
32227 return this.stopRow;
32228 }
32229
32230
32231
32232
32233
32234 public scannerOpenWithStopTs_args setStopRow(byte[] stopRow) {
32235 this.stopRow = stopRow;
32236 return this;
32237 }
32238
32239 public void unsetStopRow() {
32240 this.stopRow = null;
32241 }
32242
32243
32244 public boolean isSetStopRow() {
32245 return this.stopRow != null;
32246 }
32247
32248 public void setStopRowIsSet(boolean value) {
32249 if (!value) {
32250 this.stopRow = null;
32251 }
32252 }
32253
32254 public int getColumnsSize() {
32255 return (this.columns == null) ? 0 : this.columns.size();
32256 }
32257
32258 public java.util.Iterator<byte[]> getColumnsIterator() {
32259 return (this.columns == null) ? null : this.columns.iterator();
32260 }
32261
32262 public void addToColumns(byte[] elem) {
32263 if (this.columns == null) {
32264 this.columns = new ArrayList<byte[]>();
32265 }
32266 this.columns.add(elem);
32267 }
32268
32269
32270
32271
32272
32273
32274 public List<byte[]> getColumns() {
32275 return this.columns;
32276 }
32277
32278
32279
32280
32281
32282
32283 public scannerOpenWithStopTs_args setColumns(List<byte[]> columns) {
32284 this.columns = columns;
32285 return this;
32286 }
32287
32288 public void unsetColumns() {
32289 this.columns = null;
32290 }
32291
32292
32293 public boolean isSetColumns() {
32294 return this.columns != null;
32295 }
32296
32297 public void setColumnsIsSet(boolean value) {
32298 if (!value) {
32299 this.columns = null;
32300 }
32301 }
32302
32303
32304
32305
32306 public long getTimestamp() {
32307 return this.timestamp;
32308 }
32309
32310
32311
32312
32313 public scannerOpenWithStopTs_args setTimestamp(long timestamp) {
32314 this.timestamp = timestamp;
32315 setTimestampIsSet(true);
32316 return this;
32317 }
32318
32319 public void unsetTimestamp() {
32320 __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
32321 }
32322
32323
32324 public boolean isSetTimestamp() {
32325 return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
32326 }
32327
32328 public void setTimestampIsSet(boolean value) {
32329 __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
32330 }
32331
32332 public void setFieldValue(_Fields field, Object value) {
32333 switch (field) {
32334 case TABLE_NAME:
32335 if (value == null) {
32336 unsetTableName();
32337 } else {
32338 setTableName((byte[])value);
32339 }
32340 break;
32341
32342 case START_ROW:
32343 if (value == null) {
32344 unsetStartRow();
32345 } else {
32346 setStartRow((byte[])value);
32347 }
32348 break;
32349
32350 case STOP_ROW:
32351 if (value == null) {
32352 unsetStopRow();
32353 } else {
32354 setStopRow((byte[])value);
32355 }
32356 break;
32357
32358 case COLUMNS:
32359 if (value == null) {
32360 unsetColumns();
32361 } else {
32362 setColumns((List<byte[]>)value);
32363 }
32364 break;
32365
32366 case TIMESTAMP:
32367 if (value == null) {
32368 unsetTimestamp();
32369 } else {
32370 setTimestamp((Long)value);
32371 }
32372 break;
32373
32374 }
32375 }
32376
32377 public void setFieldValue(int fieldID, Object value) {
32378 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
32379 }
32380
32381 public Object getFieldValue(_Fields field) {
32382 switch (field) {
32383 case TABLE_NAME:
32384 return getTableName();
32385
32386 case START_ROW:
32387 return getStartRow();
32388
32389 case STOP_ROW:
32390 return getStopRow();
32391
32392 case COLUMNS:
32393 return getColumns();
32394
32395 case TIMESTAMP:
32396 return new Long(getTimestamp());
32397
32398 }
32399 throw new IllegalStateException();
32400 }
32401
32402 public Object getFieldValue(int fieldId) {
32403 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
32404 }
32405
32406
32407 public boolean isSet(_Fields field) {
32408 switch (field) {
32409 case TABLE_NAME:
32410 return isSetTableName();
32411 case START_ROW:
32412 return isSetStartRow();
32413 case STOP_ROW:
32414 return isSetStopRow();
32415 case COLUMNS:
32416 return isSetColumns();
32417 case TIMESTAMP:
32418 return isSetTimestamp();
32419 }
32420 throw new IllegalStateException();
32421 }
32422
32423 public boolean isSet(int fieldID) {
32424 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
32425 }
32426
32427 @Override
32428 public boolean equals(Object that) {
32429 if (that == null)
32430 return false;
32431 if (that instanceof scannerOpenWithStopTs_args)
32432 return this.equals((scannerOpenWithStopTs_args)that);
32433 return false;
32434 }
32435
32436 public boolean equals(scannerOpenWithStopTs_args that) {
32437 if (that == null)
32438 return false;
32439
32440 boolean this_present_tableName = true && this.isSetTableName();
32441 boolean that_present_tableName = true && that.isSetTableName();
32442 if (this_present_tableName || that_present_tableName) {
32443 if (!(this_present_tableName && that_present_tableName))
32444 return false;
32445 if (!java.util.Arrays.equals(this.tableName, that.tableName))
32446 return false;
32447 }
32448
32449 boolean this_present_startRow = true && this.isSetStartRow();
32450 boolean that_present_startRow = true && that.isSetStartRow();
32451 if (this_present_startRow || that_present_startRow) {
32452 if (!(this_present_startRow && that_present_startRow))
32453 return false;
32454 if (!java.util.Arrays.equals(this.startRow, that.startRow))
32455 return false;
32456 }
32457
32458 boolean this_present_stopRow = true && this.isSetStopRow();
32459 boolean that_present_stopRow = true && that.isSetStopRow();
32460 if (this_present_stopRow || that_present_stopRow) {
32461 if (!(this_present_stopRow && that_present_stopRow))
32462 return false;
32463 if (!java.util.Arrays.equals(this.stopRow, that.stopRow))
32464 return false;
32465 }
32466
32467 boolean this_present_columns = true && this.isSetColumns();
32468 boolean that_present_columns = true && that.isSetColumns();
32469 if (this_present_columns || that_present_columns) {
32470 if (!(this_present_columns && that_present_columns))
32471 return false;
32472 if (!this.columns.equals(that.columns))
32473 return false;
32474 }
32475
32476 boolean this_present_timestamp = true;
32477 boolean that_present_timestamp = true;
32478 if (this_present_timestamp || that_present_timestamp) {
32479 if (!(this_present_timestamp && that_present_timestamp))
32480 return false;
32481 if (this.timestamp != that.timestamp)
32482 return false;
32483 }
32484
32485 return true;
32486 }
32487
32488 @Override
32489 public int hashCode() {
32490 HashCodeBuilder builder = new HashCodeBuilder();
32491
32492 boolean present_tableName = true && (isSetTableName());
32493 builder.append(present_tableName);
32494 if (present_tableName)
32495 builder.append(tableName);
32496
32497 boolean present_startRow = true && (isSetStartRow());
32498 builder.append(present_startRow);
32499 if (present_startRow)
32500 builder.append(startRow);
32501
32502 boolean present_stopRow = true && (isSetStopRow());
32503 builder.append(present_stopRow);
32504 if (present_stopRow)
32505 builder.append(stopRow);
32506
32507 boolean present_columns = true && (isSetColumns());
32508 builder.append(present_columns);
32509 if (present_columns)
32510 builder.append(columns);
32511
32512 boolean present_timestamp = true;
32513 builder.append(present_timestamp);
32514 if (present_timestamp)
32515 builder.append(timestamp);
32516
32517 return builder.toHashCode();
32518 }
32519
32520 public int compareTo(scannerOpenWithStopTs_args other) {
32521 if (!getClass().equals(other.getClass())) {
32522 return getClass().getName().compareTo(other.getClass().getName());
32523 }
32524
32525 int lastComparison = 0;
32526 scannerOpenWithStopTs_args typedOther = (scannerOpenWithStopTs_args)other;
32527
32528 lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
32529 if (lastComparison != 0) {
32530 return lastComparison;
32531 }
32532 lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
32533 if (lastComparison != 0) {
32534 return lastComparison;
32535 }
32536 lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
32537 if (lastComparison != 0) {
32538 return lastComparison;
32539 }
32540 lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
32541 if (lastComparison != 0) {
32542 return lastComparison;
32543 }
32544 lastComparison = Boolean.valueOf(isSetStopRow()).compareTo(isSetStopRow());
32545 if (lastComparison != 0) {
32546 return lastComparison;
32547 }
32548 lastComparison = TBaseHelper.compareTo(stopRow, typedOther.stopRow);
32549 if (lastComparison != 0) {
32550 return lastComparison;
32551 }
32552 lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
32553 if (lastComparison != 0) {
32554 return lastComparison;
32555 }
32556 lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
32557 if (lastComparison != 0) {
32558 return lastComparison;
32559 }
32560 lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
32561 if (lastComparison != 0) {
32562 return lastComparison;
32563 }
32564 lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
32565 if (lastComparison != 0) {
32566 return lastComparison;
32567 }
32568 return 0;
32569 }
32570
32571 public void read(TProtocol iprot) throws TException {
32572 TField field;
32573 iprot.readStructBegin();
32574 while (true)
32575 {
32576 field = iprot.readFieldBegin();
32577 if (field.type == TType.STOP) {
32578 break;
32579 }
32580 _Fields fieldId = _Fields.findByThriftId(field.id);
32581 if (fieldId == null) {
32582 TProtocolUtil.skip(iprot, field.type);
32583 } else {
32584 switch (fieldId) {
32585 case TABLE_NAME:
32586 if (field.type == TType.STRING) {
32587 this.tableName = iprot.readBinary();
32588 } else {
32589 TProtocolUtil.skip(iprot, field.type);
32590 }
32591 break;
32592 case START_ROW:
32593 if (field.type == TType.STRING) {
32594 this.startRow = iprot.readBinary();
32595 } else {
32596 TProtocolUtil.skip(iprot, field.type);
32597 }
32598 break;
32599 case STOP_ROW:
32600 if (field.type == TType.STRING) {
32601 this.stopRow = iprot.readBinary();
32602 } else {
32603 TProtocolUtil.skip(iprot, field.type);
32604 }
32605 break;
32606 case COLUMNS:
32607 if (field.type == TType.LIST) {
32608 {
32609 TList _list134 = iprot.readListBegin();
32610 this.columns = new ArrayList<byte[]>(_list134.size);
32611 for (int _i135 = 0; _i135 < _list134.size; ++_i135)
32612 {
32613 byte[] _elem136;
32614 _elem136 = iprot.readBinary();
32615 this.columns.add(_elem136);
32616 }
32617 iprot.readListEnd();
32618 }
32619 } else {
32620 TProtocolUtil.skip(iprot, field.type);
32621 }
32622 break;
32623 case TIMESTAMP:
32624 if (field.type == TType.I64) {
32625 this.timestamp = iprot.readI64();
32626 setTimestampIsSet(true);
32627 } else {
32628 TProtocolUtil.skip(iprot, field.type);
32629 }
32630 break;
32631 }
32632 iprot.readFieldEnd();
32633 }
32634 }
32635 iprot.readStructEnd();
32636
32637
32638 validate();
32639 }
32640
32641 public void write(TProtocol oprot) throws TException {
32642 validate();
32643
32644 oprot.writeStructBegin(STRUCT_DESC);
32645 if (this.tableName != null) {
32646 oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
32647 oprot.writeBinary(this.tableName);
32648 oprot.writeFieldEnd();
32649 }
32650 if (this.startRow != null) {
32651 oprot.writeFieldBegin(START_ROW_FIELD_DESC);
32652 oprot.writeBinary(this.startRow);
32653 oprot.writeFieldEnd();
32654 }
32655 if (this.stopRow != null) {
32656 oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
32657 oprot.writeBinary(this.stopRow);
32658 oprot.writeFieldEnd();
32659 }
32660 if (this.columns != null) {
32661 oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
32662 {
32663 oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
32664 for (byte[] _iter137 : this.columns)
32665 {
32666 oprot.writeBinary(_iter137);
32667 }
32668 oprot.writeListEnd();
32669 }
32670 oprot.writeFieldEnd();
32671 }
32672 oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
32673 oprot.writeI64(this.timestamp);
32674 oprot.writeFieldEnd();
32675 oprot.writeFieldStop();
32676 oprot.writeStructEnd();
32677 }
32678
32679 @Override
32680 public String toString() {
32681 StringBuilder sb = new StringBuilder("scannerOpenWithStopTs_args(");
32682 boolean first = true;
32683
32684 sb.append("tableName:");
32685 if (this.tableName == null) {
32686 sb.append("null");
32687 } else {
32688 sb.append(this.tableName);
32689 }
32690 first = false;
32691 if (!first) sb.append(", ");
32692 sb.append("startRow:");
32693 if (this.startRow == null) {
32694 sb.append("null");
32695 } else {
32696 sb.append(this.startRow);
32697 }
32698 first = false;
32699 if (!first) sb.append(", ");
32700 sb.append("stopRow:");
32701 if (this.stopRow == null) {
32702 sb.append("null");
32703 } else {
32704 sb.append(this.stopRow);
32705 }
32706 first = false;
32707 if (!first) sb.append(", ");
32708 sb.append("columns:");
32709 if (this.columns == null) {
32710 sb.append("null");
32711 } else {
32712 sb.append(this.columns);
32713 }
32714 first = false;
32715 if (!first) sb.append(", ");
32716 sb.append("timestamp:");
32717 sb.append(this.timestamp);
32718 first = false;
32719 sb.append(")");
32720 return sb.toString();
32721 }
32722
32723 public void validate() throws TException {
32724
32725 }
32726
32727 }
32728
32729 public static class scannerOpenWithStopTs_result implements TBase<scannerOpenWithStopTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_result> {
32730 private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_result");
32731
32732 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
32733 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
32734
32735 public int success;
32736 public IOError io;
32737
32738
32739 public enum _Fields implements TFieldIdEnum {
32740 SUCCESS((short)0, "success"),
32741 IO((short)1, "io");
32742
32743 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
32744 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
32745
32746 static {
32747 for (_Fields field : EnumSet.allOf(_Fields.class)) {
32748 byId.put((int)field._thriftId, field);
32749 byName.put(field.getFieldName(), field);
32750 }
32751 }
32752
32753
32754
32755
32756 public static _Fields findByThriftId(int fieldId) {
32757 return byId.get(fieldId);
32758 }
32759
32760
32761
32762
32763
32764 public static _Fields findByThriftIdOrThrow(int fieldId) {
32765 _Fields fields = findByThriftId(fieldId);
32766 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
32767 return fields;
32768 }
32769
32770
32771
32772
32773 public static _Fields findByName(String name) {
32774 return byName.get(name);
32775 }
32776
32777 private final short _thriftId;
32778 private final String _fieldName;
32779
32780 _Fields(short thriftId, String fieldName) {
32781 _thriftId = thriftId;
32782 _fieldName = fieldName;
32783 }
32784
32785 public short getThriftFieldId() {
32786 return _thriftId;
32787 }
32788
32789 public String getFieldName() {
32790 return _fieldName;
32791 }
32792 }
32793
32794
32795 private static final int __SUCCESS_ISSET_ID = 0;
32796 private BitSet __isset_bit_vector = new BitSet(1);
32797
32798 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
32799 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
32800 new FieldValueMetaData(TType.I32)));
32801 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
32802 new FieldValueMetaData(TType.STRUCT)));
32803 }});
32804
32805 static {
32806 FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_result.class, metaDataMap);
32807 }
32808
32809 public scannerOpenWithStopTs_result() {
32810 }
32811
32812 public scannerOpenWithStopTs_result(
32813 int success,
32814 IOError io)
32815 {
32816 this();
32817 this.success = success;
32818 setSuccessIsSet(true);
32819 this.io = io;
32820 }
32821
32822
32823
32824
32825 public scannerOpenWithStopTs_result(scannerOpenWithStopTs_result other) {
32826 __isset_bit_vector.clear();
32827 __isset_bit_vector.or(other.__isset_bit_vector);
32828 this.success = other.success;
32829 if (other.isSetIo()) {
32830 this.io = new IOError(other.io);
32831 }
32832 }
32833
32834 public scannerOpenWithStopTs_result deepCopy() {
32835 return new scannerOpenWithStopTs_result(this);
32836 }
32837
32838 @Deprecated
32839 public scannerOpenWithStopTs_result clone() {
32840 return new scannerOpenWithStopTs_result(this);
32841 }
32842
32843 public int getSuccess() {
32844 return this.success;
32845 }
32846
32847 public scannerOpenWithStopTs_result setSuccess(int success) {
32848 this.success = success;
32849 setSuccessIsSet(true);
32850 return this;
32851 }
32852
32853 public void unsetSuccess() {
32854 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
32855 }
32856
32857
32858 public boolean isSetSuccess() {
32859 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
32860 }
32861
32862 public void setSuccessIsSet(boolean value) {
32863 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
32864 }
32865
32866 public IOError getIo() {
32867 return this.io;
32868 }
32869
32870 public scannerOpenWithStopTs_result setIo(IOError io) {
32871 this.io = io;
32872 return this;
32873 }
32874
32875 public void unsetIo() {
32876 this.io = null;
32877 }
32878
32879
32880 public boolean isSetIo() {
32881 return this.io != null;
32882 }
32883
32884 public void setIoIsSet(boolean value) {
32885 if (!value) {
32886 this.io = null;
32887 }
32888 }
32889
32890 public void setFieldValue(_Fields field, Object value) {
32891 switch (field) {
32892 case SUCCESS:
32893 if (value == null) {
32894 unsetSuccess();
32895 } else {
32896 setSuccess((Integer)value);
32897 }
32898 break;
32899
32900 case IO:
32901 if (value == null) {
32902 unsetIo();
32903 } else {
32904 setIo((IOError)value);
32905 }
32906 break;
32907
32908 }
32909 }
32910
32911 public void setFieldValue(int fieldID, Object value) {
32912 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
32913 }
32914
32915 public Object getFieldValue(_Fields field) {
32916 switch (field) {
32917 case SUCCESS:
32918 return new Integer(getSuccess());
32919
32920 case IO:
32921 return getIo();
32922
32923 }
32924 throw new IllegalStateException();
32925 }
32926
32927 public Object getFieldValue(int fieldId) {
32928 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
32929 }
32930
32931
32932 public boolean isSet(_Fields field) {
32933 switch (field) {
32934 case SUCCESS:
32935 return isSetSuccess();
32936 case IO:
32937 return isSetIo();
32938 }
32939 throw new IllegalStateException();
32940 }
32941
32942 public boolean isSet(int fieldID) {
32943 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
32944 }
32945
32946 @Override
32947 public boolean equals(Object that) {
32948 if (that == null)
32949 return false;
32950 if (that instanceof scannerOpenWithStopTs_result)
32951 return this.equals((scannerOpenWithStopTs_result)that);
32952 return false;
32953 }
32954
32955 public boolean equals(scannerOpenWithStopTs_result that) {
32956 if (that == null)
32957 return false;
32958
32959 boolean this_present_success = true;
32960 boolean that_present_success = true;
32961 if (this_present_success || that_present_success) {
32962 if (!(this_present_success && that_present_success))
32963 return false;
32964 if (this.success != that.success)
32965 return false;
32966 }
32967
32968 boolean this_present_io = true && this.isSetIo();
32969 boolean that_present_io = true && that.isSetIo();
32970 if (this_present_io || that_present_io) {
32971 if (!(this_present_io && that_present_io))
32972 return false;
32973 if (!this.io.equals(that.io))
32974 return false;
32975 }
32976
32977 return true;
32978 }
32979
32980 @Override
32981 public int hashCode() {
32982 HashCodeBuilder builder = new HashCodeBuilder();
32983
32984 boolean present_success = true;
32985 builder.append(present_success);
32986 if (present_success)
32987 builder.append(success);
32988
32989 boolean present_io = true && (isSetIo());
32990 builder.append(present_io);
32991 if (present_io)
32992 builder.append(io);
32993
32994 return builder.toHashCode();
32995 }
32996
32997 public int compareTo(scannerOpenWithStopTs_result other) {
32998 if (!getClass().equals(other.getClass())) {
32999 return getClass().getName().compareTo(other.getClass().getName());
33000 }
33001
33002 int lastComparison = 0;
33003 scannerOpenWithStopTs_result typedOther = (scannerOpenWithStopTs_result)other;
33004
33005 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
33006 if (lastComparison != 0) {
33007 return lastComparison;
33008 }
33009 lastComparison = TBaseHelper.compareTo(success, typedOther.success);
33010 if (lastComparison != 0) {
33011 return lastComparison;
33012 }
33013 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
33014 if (lastComparison != 0) {
33015 return lastComparison;
33016 }
33017 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
33018 if (lastComparison != 0) {
33019 return lastComparison;
33020 }
33021 return 0;
33022 }
33023
33024 public void read(TProtocol iprot) throws TException {
33025 TField field;
33026 iprot.readStructBegin();
33027 while (true)
33028 {
33029 field = iprot.readFieldBegin();
33030 if (field.type == TType.STOP) {
33031 break;
33032 }
33033 _Fields fieldId = _Fields.findByThriftId(field.id);
33034 if (fieldId == null) {
33035 TProtocolUtil.skip(iprot, field.type);
33036 } else {
33037 switch (fieldId) {
33038 case SUCCESS:
33039 if (field.type == TType.I32) {
33040 this.success = iprot.readI32();
33041 setSuccessIsSet(true);
33042 } else {
33043 TProtocolUtil.skip(iprot, field.type);
33044 }
33045 break;
33046 case IO:
33047 if (field.type == TType.STRUCT) {
33048 this.io = new IOError();
33049 this.io.read(iprot);
33050 } else {
33051 TProtocolUtil.skip(iprot, field.type);
33052 }
33053 break;
33054 }
33055 iprot.readFieldEnd();
33056 }
33057 }
33058 iprot.readStructEnd();
33059
33060
33061 validate();
33062 }
33063
33064 public void write(TProtocol oprot) throws TException {
33065 oprot.writeStructBegin(STRUCT_DESC);
33066
33067 if (this.isSetSuccess()) {
33068 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33069 oprot.writeI32(this.success);
33070 oprot.writeFieldEnd();
33071 } else if (this.isSetIo()) {
33072 oprot.writeFieldBegin(IO_FIELD_DESC);
33073 this.io.write(oprot);
33074 oprot.writeFieldEnd();
33075 }
33076 oprot.writeFieldStop();
33077 oprot.writeStructEnd();
33078 }
33079
33080 @Override
33081 public String toString() {
33082 StringBuilder sb = new StringBuilder("scannerOpenWithStopTs_result(");
33083 boolean first = true;
33084
33085 sb.append("success:");
33086 sb.append(this.success);
33087 first = false;
33088 if (!first) sb.append(", ");
33089 sb.append("io:");
33090 if (this.io == null) {
33091 sb.append("null");
33092 } else {
33093 sb.append(this.io);
33094 }
33095 first = false;
33096 sb.append(")");
33097 return sb.toString();
33098 }
33099
33100 public void validate() throws TException {
33101
33102 }
33103
33104 }
33105
33106 public static class scannerGet_args implements TBase<scannerGet_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGet_args> {
33107 private static final TStruct STRUCT_DESC = new TStruct("scannerGet_args");
33108
33109 private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
33110
33111
33112
33113
33114 public int id;
33115
33116
33117 public enum _Fields implements TFieldIdEnum {
33118
33119
33120
33121 ID((short)1, "id");
33122
33123 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
33124 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
33125
33126 static {
33127 for (_Fields field : EnumSet.allOf(_Fields.class)) {
33128 byId.put((int)field._thriftId, field);
33129 byName.put(field.getFieldName(), field);
33130 }
33131 }
33132
33133
33134
33135
33136 public static _Fields findByThriftId(int fieldId) {
33137 return byId.get(fieldId);
33138 }
33139
33140
33141
33142
33143
33144 public static _Fields findByThriftIdOrThrow(int fieldId) {
33145 _Fields fields = findByThriftId(fieldId);
33146 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
33147 return fields;
33148 }
33149
33150
33151
33152
33153 public static _Fields findByName(String name) {
33154 return byName.get(name);
33155 }
33156
33157 private final short _thriftId;
33158 private final String _fieldName;
33159
33160 _Fields(short thriftId, String fieldName) {
33161 _thriftId = thriftId;
33162 _fieldName = fieldName;
33163 }
33164
33165 public short getThriftFieldId() {
33166 return _thriftId;
33167 }
33168
33169 public String getFieldName() {
33170 return _fieldName;
33171 }
33172 }
33173
33174
33175 private static final int __ID_ISSET_ID = 0;
33176 private BitSet __isset_bit_vector = new BitSet(1);
33177
33178 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
33179 put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
33180 new FieldValueMetaData(TType.I32)));
33181 }});
33182
33183 static {
33184 FieldMetaData.addStructMetaDataMap(scannerGet_args.class, metaDataMap);
33185 }
33186
33187 public scannerGet_args() {
33188 }
33189
33190 public scannerGet_args(
33191 int id)
33192 {
33193 this();
33194 this.id = id;
33195 setIdIsSet(true);
33196 }
33197
33198
33199
33200
33201 public scannerGet_args(scannerGet_args other) {
33202 __isset_bit_vector.clear();
33203 __isset_bit_vector.or(other.__isset_bit_vector);
33204 this.id = other.id;
33205 }
33206
33207 public scannerGet_args deepCopy() {
33208 return new scannerGet_args(this);
33209 }
33210
33211 @Deprecated
33212 public scannerGet_args clone() {
33213 return new scannerGet_args(this);
33214 }
33215
33216
33217
33218
33219 public int getId() {
33220 return this.id;
33221 }
33222
33223
33224
33225
33226 public scannerGet_args setId(int id) {
33227 this.id = id;
33228 setIdIsSet(true);
33229 return this;
33230 }
33231
33232 public void unsetId() {
33233 __isset_bit_vector.clear(__ID_ISSET_ID);
33234 }
33235
33236
33237 public boolean isSetId() {
33238 return __isset_bit_vector.get(__ID_ISSET_ID);
33239 }
33240
33241 public void setIdIsSet(boolean value) {
33242 __isset_bit_vector.set(__ID_ISSET_ID, value);
33243 }
33244
33245 public void setFieldValue(_Fields field, Object value) {
33246 switch (field) {
33247 case ID:
33248 if (value == null) {
33249 unsetId();
33250 } else {
33251 setId((Integer)value);
33252 }
33253 break;
33254
33255 }
33256 }
33257
33258 public void setFieldValue(int fieldID, Object value) {
33259 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
33260 }
33261
33262 public Object getFieldValue(_Fields field) {
33263 switch (field) {
33264 case ID:
33265 return new Integer(getId());
33266
33267 }
33268 throw new IllegalStateException();
33269 }
33270
33271 public Object getFieldValue(int fieldId) {
33272 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
33273 }
33274
33275
33276 public boolean isSet(_Fields field) {
33277 switch (field) {
33278 case ID:
33279 return isSetId();
33280 }
33281 throw new IllegalStateException();
33282 }
33283
33284 public boolean isSet(int fieldID) {
33285 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
33286 }
33287
33288 @Override
33289 public boolean equals(Object that) {
33290 if (that == null)
33291 return false;
33292 if (that instanceof scannerGet_args)
33293 return this.equals((scannerGet_args)that);
33294 return false;
33295 }
33296
33297 public boolean equals(scannerGet_args that) {
33298 if (that == null)
33299 return false;
33300
33301 boolean this_present_id = true;
33302 boolean that_present_id = true;
33303 if (this_present_id || that_present_id) {
33304 if (!(this_present_id && that_present_id))
33305 return false;
33306 if (this.id != that.id)
33307 return false;
33308 }
33309
33310 return true;
33311 }
33312
33313 @Override
33314 public int hashCode() {
33315 HashCodeBuilder builder = new HashCodeBuilder();
33316
33317 boolean present_id = true;
33318 builder.append(present_id);
33319 if (present_id)
33320 builder.append(id);
33321
33322 return builder.toHashCode();
33323 }
33324
33325 public int compareTo(scannerGet_args other) {
33326 if (!getClass().equals(other.getClass())) {
33327 return getClass().getName().compareTo(other.getClass().getName());
33328 }
33329
33330 int lastComparison = 0;
33331 scannerGet_args typedOther = (scannerGet_args)other;
33332
33333 lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
33334 if (lastComparison != 0) {
33335 return lastComparison;
33336 }
33337 lastComparison = TBaseHelper.compareTo(id, typedOther.id);
33338 if (lastComparison != 0) {
33339 return lastComparison;
33340 }
33341 return 0;
33342 }
33343
33344 public void read(TProtocol iprot) throws TException {
33345 TField field;
33346 iprot.readStructBegin();
33347 while (true)
33348 {
33349 field = iprot.readFieldBegin();
33350 if (field.type == TType.STOP) {
33351 break;
33352 }
33353 _Fields fieldId = _Fields.findByThriftId(field.id);
33354 if (fieldId == null) {
33355 TProtocolUtil.skip(iprot, field.type);
33356 } else {
33357 switch (fieldId) {
33358 case ID:
33359 if (field.type == TType.I32) {
33360 this.id = iprot.readI32();
33361 setIdIsSet(true);
33362 } else {
33363 TProtocolUtil.skip(iprot, field.type);
33364 }
33365 break;
33366 }
33367 iprot.readFieldEnd();
33368 }
33369 }
33370 iprot.readStructEnd();
33371
33372
33373 validate();
33374 }
33375
33376 public void write(TProtocol oprot) throws TException {
33377 validate();
33378
33379 oprot.writeStructBegin(STRUCT_DESC);
33380 oprot.writeFieldBegin(ID_FIELD_DESC);
33381 oprot.writeI32(this.id);
33382 oprot.writeFieldEnd();
33383 oprot.writeFieldStop();
33384 oprot.writeStructEnd();
33385 }
33386
33387 @Override
33388 public String toString() {
33389 StringBuilder sb = new StringBuilder("scannerGet_args(");
33390 boolean first = true;
33391
33392 sb.append("id:");
33393 sb.append(this.id);
33394 first = false;
33395 sb.append(")");
33396 return sb.toString();
33397 }
33398
33399 public void validate() throws TException {
33400
33401 }
33402
33403 }
33404
33405 public static class scannerGet_result implements TBase<scannerGet_result._Fields>, java.io.Serializable, Cloneable {
33406 private static final TStruct STRUCT_DESC = new TStruct("scannerGet_result");
33407
33408 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
33409 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
33410 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
33411
33412 public List<TRowResult> success;
33413 public IOError io;
33414 public IllegalArgument ia;
33415
33416
33417 public enum _Fields implements TFieldIdEnum {
33418 SUCCESS((short)0, "success"),
33419 IO((short)1, "io"),
33420 IA((short)2, "ia");
33421
33422 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
33423 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
33424
33425 static {
33426 for (_Fields field : EnumSet.allOf(_Fields.class)) {
33427 byId.put((int)field._thriftId, field);
33428 byName.put(field.getFieldName(), field);
33429 }
33430 }
33431
33432
33433
33434
33435 public static _Fields findByThriftId(int fieldId) {
33436 return byId.get(fieldId);
33437 }
33438
33439
33440
33441
33442
33443 public static _Fields findByThriftIdOrThrow(int fieldId) {
33444 _Fields fields = findByThriftId(fieldId);
33445 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
33446 return fields;
33447 }
33448
33449
33450
33451
33452 public static _Fields findByName(String name) {
33453 return byName.get(name);
33454 }
33455
33456 private final short _thriftId;
33457 private final String _fieldName;
33458
33459 _Fields(short thriftId, String fieldName) {
33460 _thriftId = thriftId;
33461 _fieldName = fieldName;
33462 }
33463
33464 public short getThriftFieldId() {
33465 return _thriftId;
33466 }
33467
33468 public String getFieldName() {
33469 return _fieldName;
33470 }
33471 }
33472
33473
33474
33475 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
33476 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
33477 new ListMetaData(TType.LIST,
33478 new StructMetaData(TType.STRUCT, TRowResult.class))));
33479 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
33480 new FieldValueMetaData(TType.STRUCT)));
33481 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
33482 new FieldValueMetaData(TType.STRUCT)));
33483 }});
33484
33485 static {
33486 FieldMetaData.addStructMetaDataMap(scannerGet_result.class, metaDataMap);
33487 }
33488
33489 public scannerGet_result() {
33490 }
33491
33492 public scannerGet_result(
33493 List<TRowResult> success,
33494 IOError io,
33495 IllegalArgument ia)
33496 {
33497 this();
33498 this.success = success;
33499 this.io = io;
33500 this.ia = ia;
33501 }
33502
33503
33504
33505
33506 public scannerGet_result(scannerGet_result other) {
33507 if (other.isSetSuccess()) {
33508 List<TRowResult> __this__success = new ArrayList<TRowResult>();
33509 for (TRowResult other_element : other.success) {
33510 __this__success.add(new TRowResult(other_element));
33511 }
33512 this.success = __this__success;
33513 }
33514 if (other.isSetIo()) {
33515 this.io = new IOError(other.io);
33516 }
33517 if (other.isSetIa()) {
33518 this.ia = new IllegalArgument(other.ia);
33519 }
33520 }
33521
33522 public scannerGet_result deepCopy() {
33523 return new scannerGet_result(this);
33524 }
33525
33526 @Deprecated
33527 public scannerGet_result clone() {
33528 return new scannerGet_result(this);
33529 }
33530
33531 public int getSuccessSize() {
33532 return (this.success == null) ? 0 : this.success.size();
33533 }
33534
33535 public java.util.Iterator<TRowResult> getSuccessIterator() {
33536 return (this.success == null) ? null : this.success.iterator();
33537 }
33538
33539 public void addToSuccess(TRowResult elem) {
33540 if (this.success == null) {
33541 this.success = new ArrayList<TRowResult>();
33542 }
33543 this.success.add(elem);
33544 }
33545
33546 public List<TRowResult> getSuccess() {
33547 return this.success;
33548 }
33549
33550 public scannerGet_result setSuccess(List<TRowResult> success) {
33551 this.success = success;
33552 return this;
33553 }
33554
33555 public void unsetSuccess() {
33556 this.success = null;
33557 }
33558
33559
33560 public boolean isSetSuccess() {
33561 return this.success != null;
33562 }
33563
33564 public void setSuccessIsSet(boolean value) {
33565 if (!value) {
33566 this.success = null;
33567 }
33568 }
33569
33570 public IOError getIo() {
33571 return this.io;
33572 }
33573
33574 public scannerGet_result setIo(IOError io) {
33575 this.io = io;
33576 return this;
33577 }
33578
33579 public void unsetIo() {
33580 this.io = null;
33581 }
33582
33583
33584 public boolean isSetIo() {
33585 return this.io != null;
33586 }
33587
33588 public void setIoIsSet(boolean value) {
33589 if (!value) {
33590 this.io = null;
33591 }
33592 }
33593
33594 public IllegalArgument getIa() {
33595 return this.ia;
33596 }
33597
33598 public scannerGet_result setIa(IllegalArgument ia) {
33599 this.ia = ia;
33600 return this;
33601 }
33602
33603 public void unsetIa() {
33604 this.ia = null;
33605 }
33606
33607
33608 public boolean isSetIa() {
33609 return this.ia != null;
33610 }
33611
33612 public void setIaIsSet(boolean value) {
33613 if (!value) {
33614 this.ia = null;
33615 }
33616 }
33617
33618 public void setFieldValue(_Fields field, Object value) {
33619 switch (field) {
33620 case SUCCESS:
33621 if (value == null) {
33622 unsetSuccess();
33623 } else {
33624 setSuccess((List<TRowResult>)value);
33625 }
33626 break;
33627
33628 case IO:
33629 if (value == null) {
33630 unsetIo();
33631 } else {
33632 setIo((IOError)value);
33633 }
33634 break;
33635
33636 case IA:
33637 if (value == null) {
33638 unsetIa();
33639 } else {
33640 setIa((IllegalArgument)value);
33641 }
33642 break;
33643
33644 }
33645 }
33646
33647 public void setFieldValue(int fieldID, Object value) {
33648 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
33649 }
33650
33651 public Object getFieldValue(_Fields field) {
33652 switch (field) {
33653 case SUCCESS:
33654 return getSuccess();
33655
33656 case IO:
33657 return getIo();
33658
33659 case IA:
33660 return getIa();
33661
33662 }
33663 throw new IllegalStateException();
33664 }
33665
33666 public Object getFieldValue(int fieldId) {
33667 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
33668 }
33669
33670
33671 public boolean isSet(_Fields field) {
33672 switch (field) {
33673 case SUCCESS:
33674 return isSetSuccess();
33675 case IO:
33676 return isSetIo();
33677 case IA:
33678 return isSetIa();
33679 }
33680 throw new IllegalStateException();
33681 }
33682
33683 public boolean isSet(int fieldID) {
33684 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
33685 }
33686
33687 @Override
33688 public boolean equals(Object that) {
33689 if (that == null)
33690 return false;
33691 if (that instanceof scannerGet_result)
33692 return this.equals((scannerGet_result)that);
33693 return false;
33694 }
33695
33696 public boolean equals(scannerGet_result that) {
33697 if (that == null)
33698 return false;
33699
33700 boolean this_present_success = true && this.isSetSuccess();
33701 boolean that_present_success = true && that.isSetSuccess();
33702 if (this_present_success || that_present_success) {
33703 if (!(this_present_success && that_present_success))
33704 return false;
33705 if (!this.success.equals(that.success))
33706 return false;
33707 }
33708
33709 boolean this_present_io = true && this.isSetIo();
33710 boolean that_present_io = true && that.isSetIo();
33711 if (this_present_io || that_present_io) {
33712 if (!(this_present_io && that_present_io))
33713 return false;
33714 if (!this.io.equals(that.io))
33715 return false;
33716 }
33717
33718 boolean this_present_ia = true && this.isSetIa();
33719 boolean that_present_ia = true && that.isSetIa();
33720 if (this_present_ia || that_present_ia) {
33721 if (!(this_present_ia && that_present_ia))
33722 return false;
33723 if (!this.ia.equals(that.ia))
33724 return false;
33725 }
33726
33727 return true;
33728 }
33729
33730 @Override
33731 public int hashCode() {
33732 HashCodeBuilder builder = new HashCodeBuilder();
33733
33734 boolean present_success = true && (isSetSuccess());
33735 builder.append(present_success);
33736 if (present_success)
33737 builder.append(success);
33738
33739 boolean present_io = true && (isSetIo());
33740 builder.append(present_io);
33741 if (present_io)
33742 builder.append(io);
33743
33744 boolean present_ia = true && (isSetIa());
33745 builder.append(present_ia);
33746 if (present_ia)
33747 builder.append(ia);
33748
33749 return builder.toHashCode();
33750 }
33751
33752 public void read(TProtocol iprot) throws TException {
33753 TField field;
33754 iprot.readStructBegin();
33755 while (true)
33756 {
33757 field = iprot.readFieldBegin();
33758 if (field.type == TType.STOP) {
33759 break;
33760 }
33761 _Fields fieldId = _Fields.findByThriftId(field.id);
33762 if (fieldId == null) {
33763 TProtocolUtil.skip(iprot, field.type);
33764 } else {
33765 switch (fieldId) {
33766 case SUCCESS:
33767 if (field.type == TType.LIST) {
33768 {
33769 TList _list138 = iprot.readListBegin();
33770 this.success = new ArrayList<TRowResult>(_list138.size);
33771 for (int _i139 = 0; _i139 < _list138.size; ++_i139)
33772 {
33773 TRowResult _elem140;
33774 _elem140 = new TRowResult();
33775 _elem140.read(iprot);
33776 this.success.add(_elem140);
33777 }
33778 iprot.readListEnd();
33779 }
33780 } else {
33781 TProtocolUtil.skip(iprot, field.type);
33782 }
33783 break;
33784 case IO:
33785 if (field.type == TType.STRUCT) {
33786 this.io = new IOError();
33787 this.io.read(iprot);
33788 } else {
33789 TProtocolUtil.skip(iprot, field.type);
33790 }
33791 break;
33792 case IA:
33793 if (field.type == TType.STRUCT) {
33794 this.ia = new IllegalArgument();
33795 this.ia.read(iprot);
33796 } else {
33797 TProtocolUtil.skip(iprot, field.type);
33798 }
33799 break;
33800 }
33801 iprot.readFieldEnd();
33802 }
33803 }
33804 iprot.readStructEnd();
33805
33806
33807 validate();
33808 }
33809
33810 public void write(TProtocol oprot) throws TException {
33811 oprot.writeStructBegin(STRUCT_DESC);
33812
33813 if (this.isSetSuccess()) {
33814 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33815 {
33816 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
33817 for (TRowResult _iter141 : this.success)
33818 {
33819 _iter141.write(oprot);
33820 }
33821 oprot.writeListEnd();
33822 }
33823 oprot.writeFieldEnd();
33824 } else if (this.isSetIo()) {
33825 oprot.writeFieldBegin(IO_FIELD_DESC);
33826 this.io.write(oprot);
33827 oprot.writeFieldEnd();
33828 } else if (this.isSetIa()) {
33829 oprot.writeFieldBegin(IA_FIELD_DESC);
33830 this.ia.write(oprot);
33831 oprot.writeFieldEnd();
33832 }
33833 oprot.writeFieldStop();
33834 oprot.writeStructEnd();
33835 }
33836
33837 @Override
33838 public String toString() {
33839 StringBuilder sb = new StringBuilder("scannerGet_result(");
33840 boolean first = true;
33841
33842 sb.append("success:");
33843 if (this.success == null) {
33844 sb.append("null");
33845 } else {
33846 sb.append(this.success);
33847 }
33848 first = false;
33849 if (!first) sb.append(", ");
33850 sb.append("io:");
33851 if (this.io == null) {
33852 sb.append("null");
33853 } else {
33854 sb.append(this.io);
33855 }
33856 first = false;
33857 if (!first) sb.append(", ");
33858 sb.append("ia:");
33859 if (this.ia == null) {
33860 sb.append("null");
33861 } else {
33862 sb.append(this.ia);
33863 }
33864 first = false;
33865 sb.append(")");
33866 return sb.toString();
33867 }
33868
33869 public void validate() throws TException {
33870
33871 }
33872
33873 }
33874
33875 public static class scannerGetList_args implements TBase<scannerGetList_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGetList_args> {
33876 private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_args");
33877
33878 private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
33879 private static final TField NB_ROWS_FIELD_DESC = new TField("nbRows", TType.I32, (short)2);
33880
33881
33882
33883
33884 public int id;
33885
33886
33887
33888 public int nbRows;
33889
33890
33891 public enum _Fields implements TFieldIdEnum {
33892
33893
33894
33895 ID((short)1, "id"),
33896
33897
33898
33899 NB_ROWS((short)2, "nbRows");
33900
33901 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
33902 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
33903
33904 static {
33905 for (_Fields field : EnumSet.allOf(_Fields.class)) {
33906 byId.put((int)field._thriftId, field);
33907 byName.put(field.getFieldName(), field);
33908 }
33909 }
33910
33911
33912
33913
33914 public static _Fields findByThriftId(int fieldId) {
33915 return byId.get(fieldId);
33916 }
33917
33918
33919
33920
33921
33922 public static _Fields findByThriftIdOrThrow(int fieldId) {
33923 _Fields fields = findByThriftId(fieldId);
33924 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
33925 return fields;
33926 }
33927
33928
33929
33930
33931 public static _Fields findByName(String name) {
33932 return byName.get(name);
33933 }
33934
33935 private final short _thriftId;
33936 private final String _fieldName;
33937
33938 _Fields(short thriftId, String fieldName) {
33939 _thriftId = thriftId;
33940 _fieldName = fieldName;
33941 }
33942
33943 public short getThriftFieldId() {
33944 return _thriftId;
33945 }
33946
33947 public String getFieldName() {
33948 return _fieldName;
33949 }
33950 }
33951
33952
33953 private static final int __ID_ISSET_ID = 0;
33954 private static final int __NBROWS_ISSET_ID = 1;
33955 private BitSet __isset_bit_vector = new BitSet(2);
33956
33957 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
33958 put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
33959 new FieldValueMetaData(TType.I32)));
33960 put(_Fields.NB_ROWS, new FieldMetaData("nbRows", TFieldRequirementType.DEFAULT,
33961 new FieldValueMetaData(TType.I32)));
33962 }});
33963
33964 static {
33965 FieldMetaData.addStructMetaDataMap(scannerGetList_args.class, metaDataMap);
33966 }
33967
33968 public scannerGetList_args() {
33969 }
33970
33971 public scannerGetList_args(
33972 int id,
33973 int nbRows)
33974 {
33975 this();
33976 this.id = id;
33977 setIdIsSet(true);
33978 this.nbRows = nbRows;
33979 setNbRowsIsSet(true);
33980 }
33981
33982
33983
33984
33985 public scannerGetList_args(scannerGetList_args other) {
33986 __isset_bit_vector.clear();
33987 __isset_bit_vector.or(other.__isset_bit_vector);
33988 this.id = other.id;
33989 this.nbRows = other.nbRows;
33990 }
33991
33992 public scannerGetList_args deepCopy() {
33993 return new scannerGetList_args(this);
33994 }
33995
33996 @Deprecated
33997 public scannerGetList_args clone() {
33998 return new scannerGetList_args(this);
33999 }
34000
34001
34002
34003
34004 public int getId() {
34005 return this.id;
34006 }
34007
34008
34009
34010
34011 public scannerGetList_args setId(int id) {
34012 this.id = id;
34013 setIdIsSet(true);
34014 return this;
34015 }
34016
34017 public void unsetId() {
34018 __isset_bit_vector.clear(__ID_ISSET_ID);
34019 }
34020
34021
34022 public boolean isSetId() {
34023 return __isset_bit_vector.get(__ID_ISSET_ID);
34024 }
34025
34026 public void setIdIsSet(boolean value) {
34027 __isset_bit_vector.set(__ID_ISSET_ID, value);
34028 }
34029
34030
34031
34032
34033 public int getNbRows() {
34034 return this.nbRows;
34035 }
34036
34037
34038
34039
34040 public scannerGetList_args setNbRows(int nbRows) {
34041 this.nbRows = nbRows;
34042 setNbRowsIsSet(true);
34043 return this;
34044 }
34045
34046 public void unsetNbRows() {
34047 __isset_bit_vector.clear(__NBROWS_ISSET_ID);
34048 }
34049
34050
34051 public boolean isSetNbRows() {
34052 return __isset_bit_vector.get(__NBROWS_ISSET_ID);
34053 }
34054
34055 public void setNbRowsIsSet(boolean value) {
34056 __isset_bit_vector.set(__NBROWS_ISSET_ID, value);
34057 }
34058
34059 public void setFieldValue(_Fields field, Object value) {
34060 switch (field) {
34061 case ID:
34062 if (value == null) {
34063 unsetId();
34064 } else {
34065 setId((Integer)value);
34066 }
34067 break;
34068
34069 case NB_ROWS:
34070 if (value == null) {
34071 unsetNbRows();
34072 } else {
34073 setNbRows((Integer)value);
34074 }
34075 break;
34076
34077 }
34078 }
34079
34080 public void setFieldValue(int fieldID, Object value) {
34081 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
34082 }
34083
34084 public Object getFieldValue(_Fields field) {
34085 switch (field) {
34086 case ID:
34087 return new Integer(getId());
34088
34089 case NB_ROWS:
34090 return new Integer(getNbRows());
34091
34092 }
34093 throw new IllegalStateException();
34094 }
34095
34096 public Object getFieldValue(int fieldId) {
34097 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
34098 }
34099
34100
34101 public boolean isSet(_Fields field) {
34102 switch (field) {
34103 case ID:
34104 return isSetId();
34105 case NB_ROWS:
34106 return isSetNbRows();
34107 }
34108 throw new IllegalStateException();
34109 }
34110
34111 public boolean isSet(int fieldID) {
34112 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
34113 }
34114
34115 @Override
34116 public boolean equals(Object that) {
34117 if (that == null)
34118 return false;
34119 if (that instanceof scannerGetList_args)
34120 return this.equals((scannerGetList_args)that);
34121 return false;
34122 }
34123
34124 public boolean equals(scannerGetList_args that) {
34125 if (that == null)
34126 return false;
34127
34128 boolean this_present_id = true;
34129 boolean that_present_id = true;
34130 if (this_present_id || that_present_id) {
34131 if (!(this_present_id && that_present_id))
34132 return false;
34133 if (this.id != that.id)
34134 return false;
34135 }
34136
34137 boolean this_present_nbRows = true;
34138 boolean that_present_nbRows = true;
34139 if (this_present_nbRows || that_present_nbRows) {
34140 if (!(this_present_nbRows && that_present_nbRows))
34141 return false;
34142 if (this.nbRows != that.nbRows)
34143 return false;
34144 }
34145
34146 return true;
34147 }
34148
34149 @Override
34150 public int hashCode() {
34151 HashCodeBuilder builder = new HashCodeBuilder();
34152
34153 boolean present_id = true;
34154 builder.append(present_id);
34155 if (present_id)
34156 builder.append(id);
34157
34158 boolean present_nbRows = true;
34159 builder.append(present_nbRows);
34160 if (present_nbRows)
34161 builder.append(nbRows);
34162
34163 return builder.toHashCode();
34164 }
34165
34166 public int compareTo(scannerGetList_args other) {
34167 if (!getClass().equals(other.getClass())) {
34168 return getClass().getName().compareTo(other.getClass().getName());
34169 }
34170
34171 int lastComparison = 0;
34172 scannerGetList_args typedOther = (scannerGetList_args)other;
34173
34174 lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
34175 if (lastComparison != 0) {
34176 return lastComparison;
34177 }
34178 lastComparison = TBaseHelper.compareTo(id, typedOther.id);
34179 if (lastComparison != 0) {
34180 return lastComparison;
34181 }
34182 lastComparison = Boolean.valueOf(isSetNbRows()).compareTo(isSetNbRows());
34183 if (lastComparison != 0) {
34184 return lastComparison;
34185 }
34186 lastComparison = TBaseHelper.compareTo(nbRows, typedOther.nbRows);
34187 if (lastComparison != 0) {
34188 return lastComparison;
34189 }
34190 return 0;
34191 }
34192
34193 public void read(TProtocol iprot) throws TException {
34194 TField field;
34195 iprot.readStructBegin();
34196 while (true)
34197 {
34198 field = iprot.readFieldBegin();
34199 if (field.type == TType.STOP) {
34200 break;
34201 }
34202 _Fields fieldId = _Fields.findByThriftId(field.id);
34203 if (fieldId == null) {
34204 TProtocolUtil.skip(iprot, field.type);
34205 } else {
34206 switch (fieldId) {
34207 case ID:
34208 if (field.type == TType.I32) {
34209 this.id = iprot.readI32();
34210 setIdIsSet(true);
34211 } else {
34212 TProtocolUtil.skip(iprot, field.type);
34213 }
34214 break;
34215 case NB_ROWS:
34216 if (field.type == TType.I32) {
34217 this.nbRows = iprot.readI32();
34218 setNbRowsIsSet(true);
34219 } else {
34220 TProtocolUtil.skip(iprot, field.type);
34221 }
34222 break;
34223 }
34224 iprot.readFieldEnd();
34225 }
34226 }
34227 iprot.readStructEnd();
34228
34229
34230 validate();
34231 }
34232
34233 public void write(TProtocol oprot) throws TException {
34234 validate();
34235
34236 oprot.writeStructBegin(STRUCT_DESC);
34237 oprot.writeFieldBegin(ID_FIELD_DESC);
34238 oprot.writeI32(this.id);
34239 oprot.writeFieldEnd();
34240 oprot.writeFieldBegin(NB_ROWS_FIELD_DESC);
34241 oprot.writeI32(this.nbRows);
34242 oprot.writeFieldEnd();
34243 oprot.writeFieldStop();
34244 oprot.writeStructEnd();
34245 }
34246
34247 @Override
34248 public String toString() {
34249 StringBuilder sb = new StringBuilder("scannerGetList_args(");
34250 boolean first = true;
34251
34252 sb.append("id:");
34253 sb.append(this.id);
34254 first = false;
34255 if (!first) sb.append(", ");
34256 sb.append("nbRows:");
34257 sb.append(this.nbRows);
34258 first = false;
34259 sb.append(")");
34260 return sb.toString();
34261 }
34262
34263 public void validate() throws TException {
34264
34265 }
34266
34267 }
34268
34269 public static class scannerGetList_result implements TBase<scannerGetList_result._Fields>, java.io.Serializable, Cloneable {
34270 private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_result");
34271
34272 private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
34273 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
34274 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
34275
34276 public List<TRowResult> success;
34277 public IOError io;
34278 public IllegalArgument ia;
34279
34280
34281 public enum _Fields implements TFieldIdEnum {
34282 SUCCESS((short)0, "success"),
34283 IO((short)1, "io"),
34284 IA((short)2, "ia");
34285
34286 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
34287 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
34288
34289 static {
34290 for (_Fields field : EnumSet.allOf(_Fields.class)) {
34291 byId.put((int)field._thriftId, field);
34292 byName.put(field.getFieldName(), field);
34293 }
34294 }
34295
34296
34297
34298
34299 public static _Fields findByThriftId(int fieldId) {
34300 return byId.get(fieldId);
34301 }
34302
34303
34304
34305
34306
34307 public static _Fields findByThriftIdOrThrow(int fieldId) {
34308 _Fields fields = findByThriftId(fieldId);
34309 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
34310 return fields;
34311 }
34312
34313
34314
34315
34316 public static _Fields findByName(String name) {
34317 return byName.get(name);
34318 }
34319
34320 private final short _thriftId;
34321 private final String _fieldName;
34322
34323 _Fields(short thriftId, String fieldName) {
34324 _thriftId = thriftId;
34325 _fieldName = fieldName;
34326 }
34327
34328 public short getThriftFieldId() {
34329 return _thriftId;
34330 }
34331
34332 public String getFieldName() {
34333 return _fieldName;
34334 }
34335 }
34336
34337
34338
34339 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
34340 put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
34341 new ListMetaData(TType.LIST,
34342 new StructMetaData(TType.STRUCT, TRowResult.class))));
34343 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
34344 new FieldValueMetaData(TType.STRUCT)));
34345 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
34346 new FieldValueMetaData(TType.STRUCT)));
34347 }});
34348
34349 static {
34350 FieldMetaData.addStructMetaDataMap(scannerGetList_result.class, metaDataMap);
34351 }
34352
34353 public scannerGetList_result() {
34354 }
34355
34356 public scannerGetList_result(
34357 List<TRowResult> success,
34358 IOError io,
34359 IllegalArgument ia)
34360 {
34361 this();
34362 this.success = success;
34363 this.io = io;
34364 this.ia = ia;
34365 }
34366
34367
34368
34369
34370 public scannerGetList_result(scannerGetList_result other) {
34371 if (other.isSetSuccess()) {
34372 List<TRowResult> __this__success = new ArrayList<TRowResult>();
34373 for (TRowResult other_element : other.success) {
34374 __this__success.add(new TRowResult(other_element));
34375 }
34376 this.success = __this__success;
34377 }
34378 if (other.isSetIo()) {
34379 this.io = new IOError(other.io);
34380 }
34381 if (other.isSetIa()) {
34382 this.ia = new IllegalArgument(other.ia);
34383 }
34384 }
34385
34386 public scannerGetList_result deepCopy() {
34387 return new scannerGetList_result(this);
34388 }
34389
34390 @Deprecated
34391 public scannerGetList_result clone() {
34392 return new scannerGetList_result(this);
34393 }
34394
34395 public int getSuccessSize() {
34396 return (this.success == null) ? 0 : this.success.size();
34397 }
34398
34399 public java.util.Iterator<TRowResult> getSuccessIterator() {
34400 return (this.success == null) ? null : this.success.iterator();
34401 }
34402
34403 public void addToSuccess(TRowResult elem) {
34404 if (this.success == null) {
34405 this.success = new ArrayList<TRowResult>();
34406 }
34407 this.success.add(elem);
34408 }
34409
34410 public List<TRowResult> getSuccess() {
34411 return this.success;
34412 }
34413
34414 public scannerGetList_result setSuccess(List<TRowResult> success) {
34415 this.success = success;
34416 return this;
34417 }
34418
34419 public void unsetSuccess() {
34420 this.success = null;
34421 }
34422
34423
34424 public boolean isSetSuccess() {
34425 return this.success != null;
34426 }
34427
34428 public void setSuccessIsSet(boolean value) {
34429 if (!value) {
34430 this.success = null;
34431 }
34432 }
34433
34434 public IOError getIo() {
34435 return this.io;
34436 }
34437
34438 public scannerGetList_result setIo(IOError io) {
34439 this.io = io;
34440 return this;
34441 }
34442
34443 public void unsetIo() {
34444 this.io = null;
34445 }
34446
34447
34448 public boolean isSetIo() {
34449 return this.io != null;
34450 }
34451
34452 public void setIoIsSet(boolean value) {
34453 if (!value) {
34454 this.io = null;
34455 }
34456 }
34457
34458 public IllegalArgument getIa() {
34459 return this.ia;
34460 }
34461
34462 public scannerGetList_result setIa(IllegalArgument ia) {
34463 this.ia = ia;
34464 return this;
34465 }
34466
34467 public void unsetIa() {
34468 this.ia = null;
34469 }
34470
34471
34472 public boolean isSetIa() {
34473 return this.ia != null;
34474 }
34475
34476 public void setIaIsSet(boolean value) {
34477 if (!value) {
34478 this.ia = null;
34479 }
34480 }
34481
34482 public void setFieldValue(_Fields field, Object value) {
34483 switch (field) {
34484 case SUCCESS:
34485 if (value == null) {
34486 unsetSuccess();
34487 } else {
34488 setSuccess((List<TRowResult>)value);
34489 }
34490 break;
34491
34492 case IO:
34493 if (value == null) {
34494 unsetIo();
34495 } else {
34496 setIo((IOError)value);
34497 }
34498 break;
34499
34500 case IA:
34501 if (value == null) {
34502 unsetIa();
34503 } else {
34504 setIa((IllegalArgument)value);
34505 }
34506 break;
34507
34508 }
34509 }
34510
34511 public void setFieldValue(int fieldID, Object value) {
34512 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
34513 }
34514
34515 public Object getFieldValue(_Fields field) {
34516 switch (field) {
34517 case SUCCESS:
34518 return getSuccess();
34519
34520 case IO:
34521 return getIo();
34522
34523 case IA:
34524 return getIa();
34525
34526 }
34527 throw new IllegalStateException();
34528 }
34529
34530 public Object getFieldValue(int fieldId) {
34531 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
34532 }
34533
34534
34535 public boolean isSet(_Fields field) {
34536 switch (field) {
34537 case SUCCESS:
34538 return isSetSuccess();
34539 case IO:
34540 return isSetIo();
34541 case IA:
34542 return isSetIa();
34543 }
34544 throw new IllegalStateException();
34545 }
34546
34547 public boolean isSet(int fieldID) {
34548 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
34549 }
34550
34551 @Override
34552 public boolean equals(Object that) {
34553 if (that == null)
34554 return false;
34555 if (that instanceof scannerGetList_result)
34556 return this.equals((scannerGetList_result)that);
34557 return false;
34558 }
34559
34560 public boolean equals(scannerGetList_result that) {
34561 if (that == null)
34562 return false;
34563
34564 boolean this_present_success = true && this.isSetSuccess();
34565 boolean that_present_success = true && that.isSetSuccess();
34566 if (this_present_success || that_present_success) {
34567 if (!(this_present_success && that_present_success))
34568 return false;
34569 if (!this.success.equals(that.success))
34570 return false;
34571 }
34572
34573 boolean this_present_io = true && this.isSetIo();
34574 boolean that_present_io = true && that.isSetIo();
34575 if (this_present_io || that_present_io) {
34576 if (!(this_present_io && that_present_io))
34577 return false;
34578 if (!this.io.equals(that.io))
34579 return false;
34580 }
34581
34582 boolean this_present_ia = true && this.isSetIa();
34583 boolean that_present_ia = true && that.isSetIa();
34584 if (this_present_ia || that_present_ia) {
34585 if (!(this_present_ia && that_present_ia))
34586 return false;
34587 if (!this.ia.equals(that.ia))
34588 return false;
34589 }
34590
34591 return true;
34592 }
34593
34594 @Override
34595 public int hashCode() {
34596 HashCodeBuilder builder = new HashCodeBuilder();
34597
34598 boolean present_success = true && (isSetSuccess());
34599 builder.append(present_success);
34600 if (present_success)
34601 builder.append(success);
34602
34603 boolean present_io = true && (isSetIo());
34604 builder.append(present_io);
34605 if (present_io)
34606 builder.append(io);
34607
34608 boolean present_ia = true && (isSetIa());
34609 builder.append(present_ia);
34610 if (present_ia)
34611 builder.append(ia);
34612
34613 return builder.toHashCode();
34614 }
34615
34616 public void read(TProtocol iprot) throws TException {
34617 TField field;
34618 iprot.readStructBegin();
34619 while (true)
34620 {
34621 field = iprot.readFieldBegin();
34622 if (field.type == TType.STOP) {
34623 break;
34624 }
34625 _Fields fieldId = _Fields.findByThriftId(field.id);
34626 if (fieldId == null) {
34627 TProtocolUtil.skip(iprot, field.type);
34628 } else {
34629 switch (fieldId) {
34630 case SUCCESS:
34631 if (field.type == TType.LIST) {
34632 {
34633 TList _list142 = iprot.readListBegin();
34634 this.success = new ArrayList<TRowResult>(_list142.size);
34635 for (int _i143 = 0; _i143 < _list142.size; ++_i143)
34636 {
34637 TRowResult _elem144;
34638 _elem144 = new TRowResult();
34639 _elem144.read(iprot);
34640 this.success.add(_elem144);
34641 }
34642 iprot.readListEnd();
34643 }
34644 } else {
34645 TProtocolUtil.skip(iprot, field.type);
34646 }
34647 break;
34648 case IO:
34649 if (field.type == TType.STRUCT) {
34650 this.io = new IOError();
34651 this.io.read(iprot);
34652 } else {
34653 TProtocolUtil.skip(iprot, field.type);
34654 }
34655 break;
34656 case IA:
34657 if (field.type == TType.STRUCT) {
34658 this.ia = new IllegalArgument();
34659 this.ia.read(iprot);
34660 } else {
34661 TProtocolUtil.skip(iprot, field.type);
34662 }
34663 break;
34664 }
34665 iprot.readFieldEnd();
34666 }
34667 }
34668 iprot.readStructEnd();
34669
34670
34671 validate();
34672 }
34673
34674 public void write(TProtocol oprot) throws TException {
34675 oprot.writeStructBegin(STRUCT_DESC);
34676
34677 if (this.isSetSuccess()) {
34678 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
34679 {
34680 oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
34681 for (TRowResult _iter145 : this.success)
34682 {
34683 _iter145.write(oprot);
34684 }
34685 oprot.writeListEnd();
34686 }
34687 oprot.writeFieldEnd();
34688 } else if (this.isSetIo()) {
34689 oprot.writeFieldBegin(IO_FIELD_DESC);
34690 this.io.write(oprot);
34691 oprot.writeFieldEnd();
34692 } else if (this.isSetIa()) {
34693 oprot.writeFieldBegin(IA_FIELD_DESC);
34694 this.ia.write(oprot);
34695 oprot.writeFieldEnd();
34696 }
34697 oprot.writeFieldStop();
34698 oprot.writeStructEnd();
34699 }
34700
34701 @Override
34702 public String toString() {
34703 StringBuilder sb = new StringBuilder("scannerGetList_result(");
34704 boolean first = true;
34705
34706 sb.append("success:");
34707 if (this.success == null) {
34708 sb.append("null");
34709 } else {
34710 sb.append(this.success);
34711 }
34712 first = false;
34713 if (!first) sb.append(", ");
34714 sb.append("io:");
34715 if (this.io == null) {
34716 sb.append("null");
34717 } else {
34718 sb.append(this.io);
34719 }
34720 first = false;
34721 if (!first) sb.append(", ");
34722 sb.append("ia:");
34723 if (this.ia == null) {
34724 sb.append("null");
34725 } else {
34726 sb.append(this.ia);
34727 }
34728 first = false;
34729 sb.append(")");
34730 return sb.toString();
34731 }
34732
34733 public void validate() throws TException {
34734
34735 }
34736
34737 }
34738
34739 public static class scannerClose_args implements TBase<scannerClose_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_args> {
34740 private static final TStruct STRUCT_DESC = new TStruct("scannerClose_args");
34741
34742 private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
34743
34744
34745
34746
34747 public int id;
34748
34749
34750 public enum _Fields implements TFieldIdEnum {
34751
34752
34753
34754 ID((short)1, "id");
34755
34756 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
34757 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
34758
34759 static {
34760 for (_Fields field : EnumSet.allOf(_Fields.class)) {
34761 byId.put((int)field._thriftId, field);
34762 byName.put(field.getFieldName(), field);
34763 }
34764 }
34765
34766
34767
34768
34769 public static _Fields findByThriftId(int fieldId) {
34770 return byId.get(fieldId);
34771 }
34772
34773
34774
34775
34776
34777 public static _Fields findByThriftIdOrThrow(int fieldId) {
34778 _Fields fields = findByThriftId(fieldId);
34779 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
34780 return fields;
34781 }
34782
34783
34784
34785
34786 public static _Fields findByName(String name) {
34787 return byName.get(name);
34788 }
34789
34790 private final short _thriftId;
34791 private final String _fieldName;
34792
34793 _Fields(short thriftId, String fieldName) {
34794 _thriftId = thriftId;
34795 _fieldName = fieldName;
34796 }
34797
34798 public short getThriftFieldId() {
34799 return _thriftId;
34800 }
34801
34802 public String getFieldName() {
34803 return _fieldName;
34804 }
34805 }
34806
34807
34808 private static final int __ID_ISSET_ID = 0;
34809 private BitSet __isset_bit_vector = new BitSet(1);
34810
34811 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
34812 put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
34813 new FieldValueMetaData(TType.I32)));
34814 }});
34815
34816 static {
34817 FieldMetaData.addStructMetaDataMap(scannerClose_args.class, metaDataMap);
34818 }
34819
34820 public scannerClose_args() {
34821 }
34822
34823 public scannerClose_args(
34824 int id)
34825 {
34826 this();
34827 this.id = id;
34828 setIdIsSet(true);
34829 }
34830
34831
34832
34833
34834 public scannerClose_args(scannerClose_args other) {
34835 __isset_bit_vector.clear();
34836 __isset_bit_vector.or(other.__isset_bit_vector);
34837 this.id = other.id;
34838 }
34839
34840 public scannerClose_args deepCopy() {
34841 return new scannerClose_args(this);
34842 }
34843
34844 @Deprecated
34845 public scannerClose_args clone() {
34846 return new scannerClose_args(this);
34847 }
34848
34849
34850
34851
34852 public int getId() {
34853 return this.id;
34854 }
34855
34856
34857
34858
34859 public scannerClose_args setId(int id) {
34860 this.id = id;
34861 setIdIsSet(true);
34862 return this;
34863 }
34864
34865 public void unsetId() {
34866 __isset_bit_vector.clear(__ID_ISSET_ID);
34867 }
34868
34869
34870 public boolean isSetId() {
34871 return __isset_bit_vector.get(__ID_ISSET_ID);
34872 }
34873
34874 public void setIdIsSet(boolean value) {
34875 __isset_bit_vector.set(__ID_ISSET_ID, value);
34876 }
34877
34878 public void setFieldValue(_Fields field, Object value) {
34879 switch (field) {
34880 case ID:
34881 if (value == null) {
34882 unsetId();
34883 } else {
34884 setId((Integer)value);
34885 }
34886 break;
34887
34888 }
34889 }
34890
34891 public void setFieldValue(int fieldID, Object value) {
34892 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
34893 }
34894
34895 public Object getFieldValue(_Fields field) {
34896 switch (field) {
34897 case ID:
34898 return new Integer(getId());
34899
34900 }
34901 throw new IllegalStateException();
34902 }
34903
34904 public Object getFieldValue(int fieldId) {
34905 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
34906 }
34907
34908
34909 public boolean isSet(_Fields field) {
34910 switch (field) {
34911 case ID:
34912 return isSetId();
34913 }
34914 throw new IllegalStateException();
34915 }
34916
34917 public boolean isSet(int fieldID) {
34918 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
34919 }
34920
34921 @Override
34922 public boolean equals(Object that) {
34923 if (that == null)
34924 return false;
34925 if (that instanceof scannerClose_args)
34926 return this.equals((scannerClose_args)that);
34927 return false;
34928 }
34929
34930 public boolean equals(scannerClose_args that) {
34931 if (that == null)
34932 return false;
34933
34934 boolean this_present_id = true;
34935 boolean that_present_id = true;
34936 if (this_present_id || that_present_id) {
34937 if (!(this_present_id && that_present_id))
34938 return false;
34939 if (this.id != that.id)
34940 return false;
34941 }
34942
34943 return true;
34944 }
34945
34946 @Override
34947 public int hashCode() {
34948 HashCodeBuilder builder = new HashCodeBuilder();
34949
34950 boolean present_id = true;
34951 builder.append(present_id);
34952 if (present_id)
34953 builder.append(id);
34954
34955 return builder.toHashCode();
34956 }
34957
34958 public int compareTo(scannerClose_args other) {
34959 if (!getClass().equals(other.getClass())) {
34960 return getClass().getName().compareTo(other.getClass().getName());
34961 }
34962
34963 int lastComparison = 0;
34964 scannerClose_args typedOther = (scannerClose_args)other;
34965
34966 lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
34967 if (lastComparison != 0) {
34968 return lastComparison;
34969 }
34970 lastComparison = TBaseHelper.compareTo(id, typedOther.id);
34971 if (lastComparison != 0) {
34972 return lastComparison;
34973 }
34974 return 0;
34975 }
34976
34977 public void read(TProtocol iprot) throws TException {
34978 TField field;
34979 iprot.readStructBegin();
34980 while (true)
34981 {
34982 field = iprot.readFieldBegin();
34983 if (field.type == TType.STOP) {
34984 break;
34985 }
34986 _Fields fieldId = _Fields.findByThriftId(field.id);
34987 if (fieldId == null) {
34988 TProtocolUtil.skip(iprot, field.type);
34989 } else {
34990 switch (fieldId) {
34991 case ID:
34992 if (field.type == TType.I32) {
34993 this.id = iprot.readI32();
34994 setIdIsSet(true);
34995 } else {
34996 TProtocolUtil.skip(iprot, field.type);
34997 }
34998 break;
34999 }
35000 iprot.readFieldEnd();
35001 }
35002 }
35003 iprot.readStructEnd();
35004
35005
35006 validate();
35007 }
35008
35009 public void write(TProtocol oprot) throws TException {
35010 validate();
35011
35012 oprot.writeStructBegin(STRUCT_DESC);
35013 oprot.writeFieldBegin(ID_FIELD_DESC);
35014 oprot.writeI32(this.id);
35015 oprot.writeFieldEnd();
35016 oprot.writeFieldStop();
35017 oprot.writeStructEnd();
35018 }
35019
35020 @Override
35021 public String toString() {
35022 StringBuilder sb = new StringBuilder("scannerClose_args(");
35023 boolean first = true;
35024
35025 sb.append("id:");
35026 sb.append(this.id);
35027 first = false;
35028 sb.append(")");
35029 return sb.toString();
35030 }
35031
35032 public void validate() throws TException {
35033
35034 }
35035
35036 }
35037
35038 public static class scannerClose_result implements TBase<scannerClose_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_result> {
35039 private static final TStruct STRUCT_DESC = new TStruct("scannerClose_result");
35040
35041 private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
35042 private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
35043
35044 public IOError io;
35045 public IllegalArgument ia;
35046
35047
35048 public enum _Fields implements TFieldIdEnum {
35049 IO((short)1, "io"),
35050 IA((short)2, "ia");
35051
35052 private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
35053 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
35054
35055 static {
35056 for (_Fields field : EnumSet.allOf(_Fields.class)) {
35057 byId.put((int)field._thriftId, field);
35058 byName.put(field.getFieldName(), field);
35059 }
35060 }
35061
35062
35063
35064
35065 public static _Fields findByThriftId(int fieldId) {
35066 return byId.get(fieldId);
35067 }
35068
35069
35070
35071
35072
35073 public static _Fields findByThriftIdOrThrow(int fieldId) {
35074 _Fields fields = findByThriftId(fieldId);
35075 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
35076 return fields;
35077 }
35078
35079
35080
35081
35082 public static _Fields findByName(String name) {
35083 return byName.get(name);
35084 }
35085
35086 private final short _thriftId;
35087 private final String _fieldName;
35088
35089 _Fields(short thriftId, String fieldName) {
35090 _thriftId = thriftId;
35091 _fieldName = fieldName;
35092 }
35093
35094 public short getThriftFieldId() {
35095 return _thriftId;
35096 }
35097
35098 public String getFieldName() {
35099 return _fieldName;
35100 }
35101 }
35102
35103
35104
35105 public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
35106 put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
35107 new FieldValueMetaData(TType.STRUCT)));
35108 put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
35109 new FieldValueMetaData(TType.STRUCT)));
35110 }});
35111
35112 static {
35113 FieldMetaData.addStructMetaDataMap(scannerClose_result.class, metaDataMap);
35114 }
35115
35116 public scannerClose_result() {
35117 }
35118
35119 public scannerClose_result(
35120 IOError io,
35121 IllegalArgument ia)
35122 {
35123 this();
35124 this.io = io;
35125 this.ia = ia;
35126 }
35127
35128
35129
35130
35131 public scannerClose_result(scannerClose_result other) {
35132 if (other.isSetIo()) {
35133 this.io = new IOError(other.io);
35134 }
35135 if (other.isSetIa()) {
35136 this.ia = new IllegalArgument(other.ia);
35137 }
35138 }
35139
35140 public scannerClose_result deepCopy() {
35141 return new scannerClose_result(this);
35142 }
35143
35144 @Deprecated
35145 public scannerClose_result clone() {
35146 return new scannerClose_result(this);
35147 }
35148
35149 public IOError getIo() {
35150 return this.io;
35151 }
35152
35153 public scannerClose_result setIo(IOError io) {
35154 this.io = io;
35155 return this;
35156 }
35157
35158 public void unsetIo() {
35159 this.io = null;
35160 }
35161
35162
35163 public boolean isSetIo() {
35164 return this.io != null;
35165 }
35166
35167 public void setIoIsSet(boolean value) {
35168 if (!value) {
35169 this.io = null;
35170 }
35171 }
35172
35173 public IllegalArgument getIa() {
35174 return this.ia;
35175 }
35176
35177 public scannerClose_result setIa(IllegalArgument ia) {
35178 this.ia = ia;
35179 return this;
35180 }
35181
35182 public void unsetIa() {
35183 this.ia = null;
35184 }
35185
35186
35187 public boolean isSetIa() {
35188 return this.ia != null;
35189 }
35190
35191 public void setIaIsSet(boolean value) {
35192 if (!value) {
35193 this.ia = null;
35194 }
35195 }
35196
35197 public void setFieldValue(_Fields field, Object value) {
35198 switch (field) {
35199 case IO:
35200 if (value == null) {
35201 unsetIo();
35202 } else {
35203 setIo((IOError)value);
35204 }
35205 break;
35206
35207 case IA:
35208 if (value == null) {
35209 unsetIa();
35210 } else {
35211 setIa((IllegalArgument)value);
35212 }
35213 break;
35214
35215 }
35216 }
35217
35218 public void setFieldValue(int fieldID, Object value) {
35219 setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
35220 }
35221
35222 public Object getFieldValue(_Fields field) {
35223 switch (field) {
35224 case IO:
35225 return getIo();
35226
35227 case IA:
35228 return getIa();
35229
35230 }
35231 throw new IllegalStateException();
35232 }
35233
35234 public Object getFieldValue(int fieldId) {
35235 return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
35236 }
35237
35238
35239 public boolean isSet(_Fields field) {
35240 switch (field) {
35241 case IO:
35242 return isSetIo();
35243 case IA:
35244 return isSetIa();
35245 }
35246 throw new IllegalStateException();
35247 }
35248
35249 public boolean isSet(int fieldID) {
35250 return isSet(_Fields.findByThriftIdOrThrow(fieldID));
35251 }
35252
35253 @Override
35254 public boolean equals(Object that) {
35255 if (that == null)
35256 return false;
35257 if (that instanceof scannerClose_result)
35258 return this.equals((scannerClose_result)that);
35259 return false;
35260 }
35261
35262 public boolean equals(scannerClose_result that) {
35263 if (that == null)
35264 return false;
35265
35266 boolean this_present_io = true && this.isSetIo();
35267 boolean that_present_io = true && that.isSetIo();
35268 if (this_present_io || that_present_io) {
35269 if (!(this_present_io && that_present_io))
35270 return false;
35271 if (!this.io.equals(that.io))
35272 return false;
35273 }
35274
35275 boolean this_present_ia = true && this.isSetIa();
35276 boolean that_present_ia = true && that.isSetIa();
35277 if (this_present_ia || that_present_ia) {
35278 if (!(this_present_ia && that_present_ia))
35279 return false;
35280 if (!this.ia.equals(that.ia))
35281 return false;
35282 }
35283
35284 return true;
35285 }
35286
35287 @Override
35288 public int hashCode() {
35289 HashCodeBuilder builder = new HashCodeBuilder();
35290
35291 boolean present_io = true && (isSetIo());
35292 builder.append(present_io);
35293 if (present_io)
35294 builder.append(io);
35295
35296 boolean present_ia = true && (isSetIa());
35297 builder.append(present_ia);
35298 if (present_ia)
35299 builder.append(ia);
35300
35301 return builder.toHashCode();
35302 }
35303
35304 public int compareTo(scannerClose_result other) {
35305 if (!getClass().equals(other.getClass())) {
35306 return getClass().getName().compareTo(other.getClass().getName());
35307 }
35308
35309 int lastComparison = 0;
35310 scannerClose_result typedOther = (scannerClose_result)other;
35311
35312 lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
35313 if (lastComparison != 0) {
35314 return lastComparison;
35315 }
35316 lastComparison = TBaseHelper.compareTo(io, typedOther.io);
35317 if (lastComparison != 0) {
35318 return lastComparison;
35319 }
35320 lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
35321 if (lastComparison != 0) {
35322 return lastComparison;
35323 }
35324 lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
35325 if (lastComparison != 0) {
35326 return lastComparison;
35327 }
35328 return 0;
35329 }
35330
35331 public void read(TProtocol iprot) throws TException {
35332 TField field;
35333 iprot.readStructBegin();
35334 while (true)
35335 {
35336 field = iprot.readFieldBegin();
35337 if (field.type == TType.STOP) {
35338 break;
35339 }
35340 _Fields fieldId = _Fields.findByThriftId(field.id);
35341 if (fieldId == null) {
35342 TProtocolUtil.skip(iprot, field.type);
35343 } else {
35344 switch (fieldId) {
35345 case IO:
35346 if (field.type == TType.STRUCT) {
35347 this.io = new IOError();
35348 this.io.read(iprot);
35349 } else {
35350 TProtocolUtil.skip(iprot, field.type);
35351 }
35352 break;
35353 case IA:
35354 if (field.type == TType.STRUCT) {
35355 this.ia = new IllegalArgument();
35356 this.ia.read(iprot);
35357 } else {
35358 TProtocolUtil.skip(iprot, field.type);
35359 }
35360 break;
35361 }
35362 iprot.readFieldEnd();
35363 }
35364 }
35365 iprot.readStructEnd();
35366
35367
35368 validate();
35369 }
35370
35371 public void write(TProtocol oprot) throws TException {
35372 oprot.writeStructBegin(STRUCT_DESC);
35373
35374 if (this.isSetIo()) {
35375 oprot.writeFieldBegin(IO_FIELD_DESC);
35376 this.io.write(oprot);
35377 oprot.writeFieldEnd();
35378 } else if (this.isSetIa()) {
35379 oprot.writeFieldBegin(IA_FIELD_DESC);
35380 this.ia.write(oprot);
35381 oprot.writeFieldEnd();
35382 }
35383 oprot.writeFieldStop();
35384 oprot.writeStructEnd();
35385 }
35386
35387 @Override
35388 public String toString() {
35389 StringBuilder sb = new StringBuilder("scannerClose_result(");
35390 boolean first = true;
35391
35392 sb.append("io:");
35393 if (this.io == null) {
35394 sb.append("null");
35395 } else {
35396 sb.append(this.io);
35397 }
35398 first = false;
35399 if (!first) sb.append(", ");
35400 sb.append("ia:");
35401 if (this.ia == null) {
35402 sb.append("null");
35403 } else {
35404 sb.append(this.ia);
35405 }
35406 first = false;
35407 sb.append(")");
35408 return sb.toString();
35409 }
35410
35411 public void validate() throws TException {
35412
35413 }
35414
35415 }
35416
35417 }