1
2
3
4
5
6
7 package org.apache.hadoop.hbase.thrift2.generated;
8
9 import org.apache.commons.lang.builder.HashCodeBuilder;
10 import org.apache.thrift.scheme.IScheme;
11 import org.apache.thrift.scheme.SchemeFactory;
12 import org.apache.thrift.scheme.StandardScheme;
13
14 import org.apache.thrift.scheme.TupleScheme;
15 import org.apache.thrift.protocol.TTupleProtocol;
16 import java.util.List;
17 import java.util.ArrayList;
18 import java.util.Map;
19 import java.util.HashMap;
20 import java.util.EnumMap;
21 import java.util.Set;
22 import java.util.HashSet;
23 import java.util.EnumSet;
24 import java.util.Collections;
25 import java.util.BitSet;
26 import java.nio.ByteBuffer;
27 import java.util.Arrays;
28 import org.slf4j.Logger;
29 import org.slf4j.LoggerFactory;
30
31 public class THBaseService {
32
33 public interface Iface {
34
35
36
37
38
39
40
41
42
43
44 public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
45
46
47
48
49
50
51
52
53
54
55
56
57
58 public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75 public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException;
76
77
78
79
80
81
82
83
84 public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException;
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106 public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException;
107
108
109
110
111
112
113
114
115 public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException;
116
117
118
119
120
121
122
123
124
125
126
127 public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
128
129
130
131
132
133
134
135
136
137
138
139
140 public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException;
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162 public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
163
164 public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException;
165
166
167
168
169
170
171
172
173
174
175 public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException;
176
177
178
179
180
181
182
183
184
185
186 public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
187
188
189
190
191
192
193
194
195 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
196
197
198
199
200
201
202
203
204 public void mutateRow(ByteBuffer table, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException;
205
206
207
208
209
210
211
212
213
214
215
216
217
218 public List<TResult> getScannerResults(ByteBuffer table, TScan scan, int numRows) throws TIOError, org.apache.thrift.TException;
219
220 }
221
222 public interface AsyncIface {
223
224 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.exists_call> resultHandler) throws org.apache.thrift.TException;
225
226 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.get_call> resultHandler) throws org.apache.thrift.TException;
227
228 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getMultiple_call> resultHandler) throws org.apache.thrift.TException;
229
230 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.put_call> resultHandler) throws org.apache.thrift.TException;
231
232 public void checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.checkAndPut_call> resultHandler) throws org.apache.thrift.TException;
233
234 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.putMultiple_call> resultHandler) throws org.apache.thrift.TException;
235
236 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteSingle_call> resultHandler) throws org.apache.thrift.TException;
237
238 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteMultiple_call> resultHandler) throws org.apache.thrift.TException;
239
240 public void checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.checkAndDelete_call> resultHandler) throws org.apache.thrift.TException;
241
242 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.increment_call> resultHandler) throws org.apache.thrift.TException;
243
244 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.openScanner_call> resultHandler) throws org.apache.thrift.TException;
245
246 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getScannerRows_call> resultHandler) throws org.apache.thrift.TException;
247
248 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeScanner_call> resultHandler) throws org.apache.thrift.TException;
249
250 public void mutateRow(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.mutateRow_call> resultHandler) throws org.apache.thrift.TException;
251
252 public void getScannerResults(ByteBuffer table, TScan scan, int numRows, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getScannerResults_call> resultHandler) throws org.apache.thrift.TException;
253
254 }
255
256 public static class Client extends org.apache.thrift.TServiceClient implements Iface {
257 public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
258 public Factory() {}
259 public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
260 return new Client(prot);
261 }
262 public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
263 return new Client(iprot, oprot);
264 }
265 }
266
267 public Client(org.apache.thrift.protocol.TProtocol prot)
268 {
269 super(prot, prot);
270 }
271
272 public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
273 super(iprot, oprot);
274 }
275
276 public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
277 {
278 send_exists(table, get);
279 return recv_exists();
280 }
281
282 public void send_exists(ByteBuffer table, TGet get) throws org.apache.thrift.TException
283 {
284 exists_args args = new exists_args();
285 args.setTable(table);
286 args.setGet(get);
287 sendBase("exists", args);
288 }
289
290 public boolean recv_exists() throws TIOError, org.apache.thrift.TException
291 {
292 exists_result result = new exists_result();
293 receiveBase(result, "exists");
294 if (result.isSetSuccess()) {
295 return result.success;
296 }
297 if (result.io != null) {
298 throw result.io;
299 }
300 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "exists failed: unknown result");
301 }
302
303 public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
304 {
305 send_get(table, get);
306 return recv_get();
307 }
308
309 public void send_get(ByteBuffer table, TGet get) throws org.apache.thrift.TException
310 {
311 get_args args = new get_args();
312 args.setTable(table);
313 args.setGet(get);
314 sendBase("get", args);
315 }
316
317 public TResult recv_get() throws TIOError, org.apache.thrift.TException
318 {
319 get_result result = new get_result();
320 receiveBase(result, "get");
321 if (result.isSetSuccess()) {
322 return result.success;
323 }
324 if (result.io != null) {
325 throw result.io;
326 }
327 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get failed: unknown result");
328 }
329
330 public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException
331 {
332 send_getMultiple(table, gets);
333 return recv_getMultiple();
334 }
335
336 public void send_getMultiple(ByteBuffer table, List<TGet> gets) throws org.apache.thrift.TException
337 {
338 getMultiple_args args = new getMultiple_args();
339 args.setTable(table);
340 args.setGets(gets);
341 sendBase("getMultiple", args);
342 }
343
344 public List<TResult> recv_getMultiple() throws TIOError, org.apache.thrift.TException
345 {
346 getMultiple_result result = new getMultiple_result();
347 receiveBase(result, "getMultiple");
348 if (result.isSetSuccess()) {
349 return result.success;
350 }
351 if (result.io != null) {
352 throw result.io;
353 }
354 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getMultiple failed: unknown result");
355 }
356
357 public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException
358 {
359 send_put(table, put);
360 recv_put();
361 }
362
363 public void send_put(ByteBuffer table, TPut put) throws org.apache.thrift.TException
364 {
365 put_args args = new put_args();
366 args.setTable(table);
367 args.setPut(put);
368 sendBase("put", args);
369 }
370
371 public void recv_put() throws TIOError, org.apache.thrift.TException
372 {
373 put_result result = new put_result();
374 receiveBase(result, "put");
375 if (result.io != null) {
376 throw result.io;
377 }
378 return;
379 }
380
381 public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException
382 {
383 send_checkAndPut(table, row, family, qualifier, value, put);
384 return recv_checkAndPut();
385 }
386
387 public void send_checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws org.apache.thrift.TException
388 {
389 checkAndPut_args args = new checkAndPut_args();
390 args.setTable(table);
391 args.setRow(row);
392 args.setFamily(family);
393 args.setQualifier(qualifier);
394 args.setValue(value);
395 args.setPut(put);
396 sendBase("checkAndPut", args);
397 }
398
399 public boolean recv_checkAndPut() throws TIOError, org.apache.thrift.TException
400 {
401 checkAndPut_result result = new checkAndPut_result();
402 receiveBase(result, "checkAndPut");
403 if (result.isSetSuccess()) {
404 return result.success;
405 }
406 if (result.io != null) {
407 throw result.io;
408 }
409 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndPut failed: unknown result");
410 }
411
412 public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException
413 {
414 send_putMultiple(table, puts);
415 recv_putMultiple();
416 }
417
418 public void send_putMultiple(ByteBuffer table, List<TPut> puts) throws org.apache.thrift.TException
419 {
420 putMultiple_args args = new putMultiple_args();
421 args.setTable(table);
422 args.setPuts(puts);
423 sendBase("putMultiple", args);
424 }
425
426 public void recv_putMultiple() throws TIOError, org.apache.thrift.TException
427 {
428 putMultiple_result result = new putMultiple_result();
429 receiveBase(result, "putMultiple");
430 if (result.io != null) {
431 throw result.io;
432 }
433 return;
434 }
435
436 public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
437 {
438 send_deleteSingle(table, deleteSingle);
439 recv_deleteSingle();
440 }
441
442 public void send_deleteSingle(ByteBuffer table, TDelete deleteSingle) throws org.apache.thrift.TException
443 {
444 deleteSingle_args args = new deleteSingle_args();
445 args.setTable(table);
446 args.setDeleteSingle(deleteSingle);
447 sendBase("deleteSingle", args);
448 }
449
450 public void recv_deleteSingle() throws TIOError, org.apache.thrift.TException
451 {
452 deleteSingle_result result = new deleteSingle_result();
453 receiveBase(result, "deleteSingle");
454 if (result.io != null) {
455 throw result.io;
456 }
457 return;
458 }
459
460 public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException
461 {
462 send_deleteMultiple(table, deletes);
463 return recv_deleteMultiple();
464 }
465
466 public void send_deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws org.apache.thrift.TException
467 {
468 deleteMultiple_args args = new deleteMultiple_args();
469 args.setTable(table);
470 args.setDeletes(deletes);
471 sendBase("deleteMultiple", args);
472 }
473
474 public List<TDelete> recv_deleteMultiple() throws TIOError, org.apache.thrift.TException
475 {
476 deleteMultiple_result result = new deleteMultiple_result();
477 receiveBase(result, "deleteMultiple");
478 if (result.isSetSuccess()) {
479 return result.success;
480 }
481 if (result.io != null) {
482 throw result.io;
483 }
484 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "deleteMultiple failed: unknown result");
485 }
486
487 public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
488 {
489 send_checkAndDelete(table, row, family, qualifier, value, deleteSingle);
490 return recv_checkAndDelete();
491 }
492
493 public void send_checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws org.apache.thrift.TException
494 {
495 checkAndDelete_args args = new checkAndDelete_args();
496 args.setTable(table);
497 args.setRow(row);
498 args.setFamily(family);
499 args.setQualifier(qualifier);
500 args.setValue(value);
501 args.setDeleteSingle(deleteSingle);
502 sendBase("checkAndDelete", args);
503 }
504
505 public boolean recv_checkAndDelete() throws TIOError, org.apache.thrift.TException
506 {
507 checkAndDelete_result result = new checkAndDelete_result();
508 receiveBase(result, "checkAndDelete");
509 if (result.isSetSuccess()) {
510 return result.success;
511 }
512 if (result.io != null) {
513 throw result.io;
514 }
515 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndDelete failed: unknown result");
516 }
517
518 public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException
519 {
520 send_increment(table, increment);
521 return recv_increment();
522 }
523
524 public void send_increment(ByteBuffer table, TIncrement increment) throws org.apache.thrift.TException
525 {
526 increment_args args = new increment_args();
527 args.setTable(table);
528 args.setIncrement(increment);
529 sendBase("increment", args);
530 }
531
532 public TResult recv_increment() throws TIOError, org.apache.thrift.TException
533 {
534 increment_result result = new increment_result();
535 receiveBase(result, "increment");
536 if (result.isSetSuccess()) {
537 return result.success;
538 }
539 if (result.io != null) {
540 throw result.io;
541 }
542 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "increment failed: unknown result");
543 }
544
545 public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException
546 {
547 send_openScanner(table, scan);
548 return recv_openScanner();
549 }
550
551 public void send_openScanner(ByteBuffer table, TScan scan) throws org.apache.thrift.TException
552 {
553 openScanner_args args = new openScanner_args();
554 args.setTable(table);
555 args.setScan(scan);
556 sendBase("openScanner", args);
557 }
558
559 public int recv_openScanner() throws TIOError, org.apache.thrift.TException
560 {
561 openScanner_result result = new openScanner_result();
562 receiveBase(result, "openScanner");
563 if (result.isSetSuccess()) {
564 return result.success;
565 }
566 if (result.io != null) {
567 throw result.io;
568 }
569 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "openScanner failed: unknown result");
570 }
571
572 public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException
573 {
574 send_getScannerRows(scannerId, numRows);
575 return recv_getScannerRows();
576 }
577
578 public void send_getScannerRows(int scannerId, int numRows) throws org.apache.thrift.TException
579 {
580 getScannerRows_args args = new getScannerRows_args();
581 args.setScannerId(scannerId);
582 args.setNumRows(numRows);
583 sendBase("getScannerRows", args);
584 }
585
586 public List<TResult> recv_getScannerRows() throws TIOError, TIllegalArgument, org.apache.thrift.TException
587 {
588 getScannerRows_result result = new getScannerRows_result();
589 receiveBase(result, "getScannerRows");
590 if (result.isSetSuccess()) {
591 return result.success;
592 }
593 if (result.io != null) {
594 throw result.io;
595 }
596 if (result.ia != null) {
597 throw result.ia;
598 }
599 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerRows failed: unknown result");
600 }
601
602 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException
603 {
604 send_closeScanner(scannerId);
605 recv_closeScanner();
606 }
607
608 public void send_closeScanner(int scannerId) throws org.apache.thrift.TException
609 {
610 closeScanner_args args = new closeScanner_args();
611 args.setScannerId(scannerId);
612 sendBase("closeScanner", args);
613 }
614
615 public void recv_closeScanner() throws TIOError, TIllegalArgument, org.apache.thrift.TException
616 {
617 closeScanner_result result = new closeScanner_result();
618 receiveBase(result, "closeScanner");
619 if (result.io != null) {
620 throw result.io;
621 }
622 if (result.ia != null) {
623 throw result.ia;
624 }
625 return;
626 }
627
628 public void mutateRow(ByteBuffer table, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException
629 {
630 send_mutateRow(table, rowMutations);
631 recv_mutateRow();
632 }
633
634 public void send_mutateRow(ByteBuffer table, TRowMutations rowMutations) throws org.apache.thrift.TException
635 {
636 mutateRow_args args = new mutateRow_args();
637 args.setTable(table);
638 args.setRowMutations(rowMutations);
639 sendBase("mutateRow", args);
640 }
641
642 public void recv_mutateRow() throws TIOError, org.apache.thrift.TException
643 {
644 mutateRow_result result = new mutateRow_result();
645 receiveBase(result, "mutateRow");
646 if (result.io != null) {
647 throw result.io;
648 }
649 return;
650 }
651
652 public List<TResult> getScannerResults(ByteBuffer table, TScan scan, int numRows) throws TIOError, org.apache.thrift.TException
653 {
654 send_getScannerResults(table, scan, numRows);
655 return recv_getScannerResults();
656 }
657
658 public void send_getScannerResults(ByteBuffer table, TScan scan, int numRows) throws org.apache.thrift.TException
659 {
660 getScannerResults_args args = new getScannerResults_args();
661 args.setTable(table);
662 args.setScan(scan);
663 args.setNumRows(numRows);
664 sendBase("getScannerResults", args);
665 }
666
667 public List<TResult> recv_getScannerResults() throws TIOError, org.apache.thrift.TException
668 {
669 getScannerResults_result result = new getScannerResults_result();
670 receiveBase(result, "getScannerResults");
671 if (result.isSetSuccess()) {
672 return result.success;
673 }
674 if (result.io != null) {
675 throw result.io;
676 }
677 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerResults failed: unknown result");
678 }
679
680 }
681 public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
682 public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
683 private org.apache.thrift.async.TAsyncClientManager clientManager;
684 private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
685 public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) {
686 this.clientManager = clientManager;
687 this.protocolFactory = protocolFactory;
688 }
689 public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) {
690 return new AsyncClient(protocolFactory, clientManager, transport);
691 }
692 }
693
694 public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) {
695 super(protocolFactory, clientManager, transport);
696 }
697
698 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<exists_call> resultHandler) throws org.apache.thrift.TException {
699 checkReady();
700 exists_call method_call = new exists_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
701 this.___currentMethod = method_call;
702 ___manager.call(method_call);
703 }
704
705 public static class exists_call extends org.apache.thrift.async.TAsyncMethodCall {
706 private ByteBuffer table;
707 private TGet get;
708 public exists_call(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<exists_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
709 super(client, protocolFactory, transport, resultHandler, false);
710 this.table = table;
711 this.get = get;
712 }
713
714 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
715 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("exists", org.apache.thrift.protocol.TMessageType.CALL, 0));
716 exists_args args = new exists_args();
717 args.setTable(table);
718 args.setGet(get);
719 args.write(prot);
720 prot.writeMessageEnd();
721 }
722
723 public boolean getResult() throws TIOError, org.apache.thrift.TException {
724 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
725 throw new IllegalStateException("Method call not finished!");
726 }
727 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
728 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
729 return (new Client(prot)).recv_exists();
730 }
731 }
732
733 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<get_call> resultHandler) throws org.apache.thrift.TException {
734 checkReady();
735 get_call method_call = new get_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
736 this.___currentMethod = method_call;
737 ___manager.call(method_call);
738 }
739
740 public static class get_call extends org.apache.thrift.async.TAsyncMethodCall {
741 private ByteBuffer table;
742 private TGet get;
743 public get_call(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<get_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
744 super(client, protocolFactory, transport, resultHandler, false);
745 this.table = table;
746 this.get = get;
747 }
748
749 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
750 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.CALL, 0));
751 get_args args = new get_args();
752 args.setTable(table);
753 args.setGet(get);
754 args.write(prot);
755 prot.writeMessageEnd();
756 }
757
758 public TResult getResult() throws TIOError, org.apache.thrift.TException {
759 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
760 throw new IllegalStateException("Method call not finished!");
761 }
762 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
763 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
764 return (new Client(prot)).recv_get();
765 }
766 }
767
768 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<getMultiple_call> resultHandler) throws org.apache.thrift.TException {
769 checkReady();
770 getMultiple_call method_call = new getMultiple_call(table, gets, resultHandler, this, ___protocolFactory, ___transport);
771 this.___currentMethod = method_call;
772 ___manager.call(method_call);
773 }
774
775 public static class getMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
776 private ByteBuffer table;
777 private List<TGet> gets;
778 public getMultiple_call(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<getMultiple_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
779 super(client, protocolFactory, transport, resultHandler, false);
780 this.table = table;
781 this.gets = gets;
782 }
783
784 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
785 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
786 getMultiple_args args = new getMultiple_args();
787 args.setTable(table);
788 args.setGets(gets);
789 args.write(prot);
790 prot.writeMessageEnd();
791 }
792
793 public List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
794 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
795 throw new IllegalStateException("Method call not finished!");
796 }
797 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
798 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
799 return (new Client(prot)).recv_getMultiple();
800 }
801 }
802
803 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<put_call> resultHandler) throws org.apache.thrift.TException {
804 checkReady();
805 put_call method_call = new put_call(table, put, resultHandler, this, ___protocolFactory, ___transport);
806 this.___currentMethod = method_call;
807 ___manager.call(method_call);
808 }
809
810 public static class put_call extends org.apache.thrift.async.TAsyncMethodCall {
811 private ByteBuffer table;
812 private TPut put;
813 public put_call(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<put_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
814 super(client, protocolFactory, transport, resultHandler, false);
815 this.table = table;
816 this.put = put;
817 }
818
819 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
820 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("put", org.apache.thrift.protocol.TMessageType.CALL, 0));
821 put_args args = new put_args();
822 args.setTable(table);
823 args.setPut(put);
824 args.write(prot);
825 prot.writeMessageEnd();
826 }
827
828 public void getResult() throws TIOError, org.apache.thrift.TException {
829 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
830 throw new IllegalStateException("Method call not finished!");
831 }
832 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
833 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
834 (new Client(prot)).recv_put();
835 }
836 }
837
838 public void checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put, org.apache.thrift.async.AsyncMethodCallback<checkAndPut_call> resultHandler) throws org.apache.thrift.TException {
839 checkReady();
840 checkAndPut_call method_call = new checkAndPut_call(table, row, family, qualifier, value, put, resultHandler, this, ___protocolFactory, ___transport);
841 this.___currentMethod = method_call;
842 ___manager.call(method_call);
843 }
844
845 public static class checkAndPut_call extends org.apache.thrift.async.TAsyncMethodCall {
846 private ByteBuffer table;
847 private ByteBuffer row;
848 private ByteBuffer family;
849 private ByteBuffer qualifier;
850 private ByteBuffer value;
851 private TPut put;
852 public checkAndPut_call(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put, org.apache.thrift.async.AsyncMethodCallback<checkAndPut_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
853 super(client, protocolFactory, transport, resultHandler, false);
854 this.table = table;
855 this.row = row;
856 this.family = family;
857 this.qualifier = qualifier;
858 this.value = value;
859 this.put = put;
860 }
861
862 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
863 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndPut", org.apache.thrift.protocol.TMessageType.CALL, 0));
864 checkAndPut_args args = new checkAndPut_args();
865 args.setTable(table);
866 args.setRow(row);
867 args.setFamily(family);
868 args.setQualifier(qualifier);
869 args.setValue(value);
870 args.setPut(put);
871 args.write(prot);
872 prot.writeMessageEnd();
873 }
874
875 public boolean getResult() throws TIOError, org.apache.thrift.TException {
876 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
877 throw new IllegalStateException("Method call not finished!");
878 }
879 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
880 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
881 return (new Client(prot)).recv_checkAndPut();
882 }
883 }
884
885 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<putMultiple_call> resultHandler) throws org.apache.thrift.TException {
886 checkReady();
887 putMultiple_call method_call = new putMultiple_call(table, puts, resultHandler, this, ___protocolFactory, ___transport);
888 this.___currentMethod = method_call;
889 ___manager.call(method_call);
890 }
891
892 public static class putMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
893 private ByteBuffer table;
894 private List<TPut> puts;
895 public putMultiple_call(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<putMultiple_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
896 super(client, protocolFactory, transport, resultHandler, false);
897 this.table = table;
898 this.puts = puts;
899 }
900
901 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
902 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("putMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
903 putMultiple_args args = new putMultiple_args();
904 args.setTable(table);
905 args.setPuts(puts);
906 args.write(prot);
907 prot.writeMessageEnd();
908 }
909
910 public void getResult() throws TIOError, org.apache.thrift.TException {
911 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
912 throw new IllegalStateException("Method call not finished!");
913 }
914 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
915 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
916 (new Client(prot)).recv_putMultiple();
917 }
918 }
919
920 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<deleteSingle_call> resultHandler) throws org.apache.thrift.TException {
921 checkReady();
922 deleteSingle_call method_call = new deleteSingle_call(table, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
923 this.___currentMethod = method_call;
924 ___manager.call(method_call);
925 }
926
927 public static class deleteSingle_call extends org.apache.thrift.async.TAsyncMethodCall {
928 private ByteBuffer table;
929 private TDelete deleteSingle;
930 public deleteSingle_call(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<deleteSingle_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
931 super(client, protocolFactory, transport, resultHandler, false);
932 this.table = table;
933 this.deleteSingle = deleteSingle;
934 }
935
936 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
937 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteSingle", org.apache.thrift.protocol.TMessageType.CALL, 0));
938 deleteSingle_args args = new deleteSingle_args();
939 args.setTable(table);
940 args.setDeleteSingle(deleteSingle);
941 args.write(prot);
942 prot.writeMessageEnd();
943 }
944
945 public void getResult() throws TIOError, org.apache.thrift.TException {
946 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
947 throw new IllegalStateException("Method call not finished!");
948 }
949 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
950 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
951 (new Client(prot)).recv_deleteSingle();
952 }
953 }
954
955 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<deleteMultiple_call> resultHandler) throws org.apache.thrift.TException {
956 checkReady();
957 deleteMultiple_call method_call = new deleteMultiple_call(table, deletes, resultHandler, this, ___protocolFactory, ___transport);
958 this.___currentMethod = method_call;
959 ___manager.call(method_call);
960 }
961
962 public static class deleteMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
963 private ByteBuffer table;
964 private List<TDelete> deletes;
965 public deleteMultiple_call(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<deleteMultiple_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
966 super(client, protocolFactory, transport, resultHandler, false);
967 this.table = table;
968 this.deletes = deletes;
969 }
970
971 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
972 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
973 deleteMultiple_args args = new deleteMultiple_args();
974 args.setTable(table);
975 args.setDeletes(deletes);
976 args.write(prot);
977 prot.writeMessageEnd();
978 }
979
980 public List<TDelete> getResult() throws TIOError, org.apache.thrift.TException {
981 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
982 throw new IllegalStateException("Method call not finished!");
983 }
984 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
985 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
986 return (new Client(prot)).recv_deleteMultiple();
987 }
988 }
989
990 public void checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<checkAndDelete_call> resultHandler) throws org.apache.thrift.TException {
991 checkReady();
992 checkAndDelete_call method_call = new checkAndDelete_call(table, row, family, qualifier, value, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
993 this.___currentMethod = method_call;
994 ___manager.call(method_call);
995 }
996
997 public static class checkAndDelete_call extends org.apache.thrift.async.TAsyncMethodCall {
998 private ByteBuffer table;
999 private ByteBuffer row;
1000 private ByteBuffer family;
1001 private ByteBuffer qualifier;
1002 private ByteBuffer value;
1003 private TDelete deleteSingle;
1004 public checkAndDelete_call(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<checkAndDelete_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1005 super(client, protocolFactory, transport, resultHandler, false);
1006 this.table = table;
1007 this.row = row;
1008 this.family = family;
1009 this.qualifier = qualifier;
1010 this.value = value;
1011 this.deleteSingle = deleteSingle;
1012 }
1013
1014 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1015 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndDelete", org.apache.thrift.protocol.TMessageType.CALL, 0));
1016 checkAndDelete_args args = new checkAndDelete_args();
1017 args.setTable(table);
1018 args.setRow(row);
1019 args.setFamily(family);
1020 args.setQualifier(qualifier);
1021 args.setValue(value);
1022 args.setDeleteSingle(deleteSingle);
1023 args.write(prot);
1024 prot.writeMessageEnd();
1025 }
1026
1027 public boolean getResult() throws TIOError, org.apache.thrift.TException {
1028 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1029 throw new IllegalStateException("Method call not finished!");
1030 }
1031 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1032 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1033 return (new Client(prot)).recv_checkAndDelete();
1034 }
1035 }
1036
1037 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<increment_call> resultHandler) throws org.apache.thrift.TException {
1038 checkReady();
1039 increment_call method_call = new increment_call(table, increment, resultHandler, this, ___protocolFactory, ___transport);
1040 this.___currentMethod = method_call;
1041 ___manager.call(method_call);
1042 }
1043
1044 public static class increment_call extends org.apache.thrift.async.TAsyncMethodCall {
1045 private ByteBuffer table;
1046 private TIncrement increment;
1047 public increment_call(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<increment_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1048 super(client, protocolFactory, transport, resultHandler, false);
1049 this.table = table;
1050 this.increment = increment;
1051 }
1052
1053 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1054 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("increment", org.apache.thrift.protocol.TMessageType.CALL, 0));
1055 increment_args args = new increment_args();
1056 args.setTable(table);
1057 args.setIncrement(increment);
1058 args.write(prot);
1059 prot.writeMessageEnd();
1060 }
1061
1062 public TResult getResult() throws TIOError, org.apache.thrift.TException {
1063 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1064 throw new IllegalStateException("Method call not finished!");
1065 }
1066 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1067 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1068 return (new Client(prot)).recv_increment();
1069 }
1070 }
1071
1072 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<openScanner_call> resultHandler) throws org.apache.thrift.TException {
1073 checkReady();
1074 openScanner_call method_call = new openScanner_call(table, scan, resultHandler, this, ___protocolFactory, ___transport);
1075 this.___currentMethod = method_call;
1076 ___manager.call(method_call);
1077 }
1078
1079 public static class openScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1080 private ByteBuffer table;
1081 private TScan scan;
1082 public openScanner_call(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<openScanner_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1083 super(client, protocolFactory, transport, resultHandler, false);
1084 this.table = table;
1085 this.scan = scan;
1086 }
1087
1088 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1089 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("openScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1090 openScanner_args args = new openScanner_args();
1091 args.setTable(table);
1092 args.setScan(scan);
1093 args.write(prot);
1094 prot.writeMessageEnd();
1095 }
1096
1097 public int getResult() throws TIOError, org.apache.thrift.TException {
1098 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1099 throw new IllegalStateException("Method call not finished!");
1100 }
1101 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1102 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1103 return (new Client(prot)).recv_openScanner();
1104 }
1105 }
1106
1107 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerRows_call> resultHandler) throws org.apache.thrift.TException {
1108 checkReady();
1109 getScannerRows_call method_call = new getScannerRows_call(scannerId, numRows, resultHandler, this, ___protocolFactory, ___transport);
1110 this.___currentMethod = method_call;
1111 ___manager.call(method_call);
1112 }
1113
1114 public static class getScannerRows_call extends org.apache.thrift.async.TAsyncMethodCall {
1115 private int scannerId;
1116 private int numRows;
1117 public getScannerRows_call(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerRows_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1118 super(client, protocolFactory, transport, resultHandler, false);
1119 this.scannerId = scannerId;
1120 this.numRows = numRows;
1121 }
1122
1123 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1124 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerRows", org.apache.thrift.protocol.TMessageType.CALL, 0));
1125 getScannerRows_args args = new getScannerRows_args();
1126 args.setScannerId(scannerId);
1127 args.setNumRows(numRows);
1128 args.write(prot);
1129 prot.writeMessageEnd();
1130 }
1131
1132 public List<TResult> getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1133 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1134 throw new IllegalStateException("Method call not finished!");
1135 }
1136 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1137 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1138 return (new Client(prot)).recv_getScannerRows();
1139 }
1140 }
1141
1142 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<closeScanner_call> resultHandler) throws org.apache.thrift.TException {
1143 checkReady();
1144 closeScanner_call method_call = new closeScanner_call(scannerId, resultHandler, this, ___protocolFactory, ___transport);
1145 this.___currentMethod = method_call;
1146 ___manager.call(method_call);
1147 }
1148
1149 public static class closeScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1150 private int scannerId;
1151 public closeScanner_call(int scannerId, org.apache.thrift.async.AsyncMethodCallback<closeScanner_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1152 super(client, protocolFactory, transport, resultHandler, false);
1153 this.scannerId = scannerId;
1154 }
1155
1156 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1157 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1158 closeScanner_args args = new closeScanner_args();
1159 args.setScannerId(scannerId);
1160 args.write(prot);
1161 prot.writeMessageEnd();
1162 }
1163
1164 public void getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1165 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1166 throw new IllegalStateException("Method call not finished!");
1167 }
1168 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1169 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1170 (new Client(prot)).recv_closeScanner();
1171 }
1172 }
1173
1174 public void mutateRow(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<mutateRow_call> resultHandler) throws org.apache.thrift.TException {
1175 checkReady();
1176 mutateRow_call method_call = new mutateRow_call(table, rowMutations, resultHandler, this, ___protocolFactory, ___transport);
1177 this.___currentMethod = method_call;
1178 ___manager.call(method_call);
1179 }
1180
1181 public static class mutateRow_call extends org.apache.thrift.async.TAsyncMethodCall {
1182 private ByteBuffer table;
1183 private TRowMutations rowMutations;
1184 public mutateRow_call(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<mutateRow_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1185 super(client, protocolFactory, transport, resultHandler, false);
1186 this.table = table;
1187 this.rowMutations = rowMutations;
1188 }
1189
1190 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1191 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRow", org.apache.thrift.protocol.TMessageType.CALL, 0));
1192 mutateRow_args args = new mutateRow_args();
1193 args.setTable(table);
1194 args.setRowMutations(rowMutations);
1195 args.write(prot);
1196 prot.writeMessageEnd();
1197 }
1198
1199 public void getResult() throws TIOError, org.apache.thrift.TException {
1200 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1201 throw new IllegalStateException("Method call not finished!");
1202 }
1203 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1204 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1205 (new Client(prot)).recv_mutateRow();
1206 }
1207 }
1208
1209 public void getScannerResults(ByteBuffer table, TScan scan, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerResults_call> resultHandler) throws org.apache.thrift.TException {
1210 checkReady();
1211 getScannerResults_call method_call = new getScannerResults_call(table, scan, numRows, resultHandler, this, ___protocolFactory, ___transport);
1212 this.___currentMethod = method_call;
1213 ___manager.call(method_call);
1214 }
1215
1216 public static class getScannerResults_call extends org.apache.thrift.async.TAsyncMethodCall {
1217 private ByteBuffer table;
1218 private TScan scan;
1219 private int numRows;
1220 public getScannerResults_call(ByteBuffer table, TScan scan, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerResults_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1221 super(client, protocolFactory, transport, resultHandler, false);
1222 this.table = table;
1223 this.scan = scan;
1224 this.numRows = numRows;
1225 }
1226
1227 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1228 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerResults", org.apache.thrift.protocol.TMessageType.CALL, 0));
1229 getScannerResults_args args = new getScannerResults_args();
1230 args.setTable(table);
1231 args.setScan(scan);
1232 args.setNumRows(numRows);
1233 args.write(prot);
1234 prot.writeMessageEnd();
1235 }
1236
1237 public List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
1238 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1239 throw new IllegalStateException("Method call not finished!");
1240 }
1241 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1242 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1243 return (new Client(prot)).recv_getScannerResults();
1244 }
1245 }
1246
1247 }
1248
1249 public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
1250 private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1251 public Processor(I iface) {
1252 super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
1253 }
1254
1255 protected Processor(I iface, Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
1256 super(iface, getProcessMap(processMap));
1257 }
1258
1259 private static <I extends Iface> Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> getProcessMap(Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
1260 processMap.put("exists", new exists());
1261 processMap.put("get", new get());
1262 processMap.put("getMultiple", new getMultiple());
1263 processMap.put("put", new put());
1264 processMap.put("checkAndPut", new checkAndPut());
1265 processMap.put("putMultiple", new putMultiple());
1266 processMap.put("deleteSingle", new deleteSingle());
1267 processMap.put("deleteMultiple", new deleteMultiple());
1268 processMap.put("checkAndDelete", new checkAndDelete());
1269 processMap.put("increment", new increment());
1270 processMap.put("openScanner", new openScanner());
1271 processMap.put("getScannerRows", new getScannerRows());
1272 processMap.put("closeScanner", new closeScanner());
1273 processMap.put("mutateRow", new mutateRow());
1274 processMap.put("getScannerResults", new getScannerResults());
1275 return processMap;
1276 }
1277
1278 private static class exists<I extends Iface> extends org.apache.thrift.ProcessFunction<I, exists_args> {
1279 public exists() {
1280 super("exists");
1281 }
1282
1283 protected exists_args getEmptyArgsInstance() {
1284 return new exists_args();
1285 }
1286
1287 protected exists_result getResult(I iface, exists_args args) throws org.apache.thrift.TException {
1288 exists_result result = new exists_result();
1289 try {
1290 result.success = iface.exists(args.table, args.get);
1291 result.setSuccessIsSet(true);
1292 } catch (TIOError io) {
1293 result.io = io;
1294 }
1295 return result;
1296 }
1297 }
1298
1299 private static class get<I extends Iface> extends org.apache.thrift.ProcessFunction<I, get_args> {
1300 public get() {
1301 super("get");
1302 }
1303
1304 protected get_args getEmptyArgsInstance() {
1305 return new get_args();
1306 }
1307
1308 protected get_result getResult(I iface, get_args args) throws org.apache.thrift.TException {
1309 get_result result = new get_result();
1310 try {
1311 result.success = iface.get(args.table, args.get);
1312 } catch (TIOError io) {
1313 result.io = io;
1314 }
1315 return result;
1316 }
1317 }
1318
1319 private static class getMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getMultiple_args> {
1320 public getMultiple() {
1321 super("getMultiple");
1322 }
1323
1324 protected getMultiple_args getEmptyArgsInstance() {
1325 return new getMultiple_args();
1326 }
1327
1328 protected getMultiple_result getResult(I iface, getMultiple_args args) throws org.apache.thrift.TException {
1329 getMultiple_result result = new getMultiple_result();
1330 try {
1331 result.success = iface.getMultiple(args.table, args.gets);
1332 } catch (TIOError io) {
1333 result.io = io;
1334 }
1335 return result;
1336 }
1337 }
1338
1339 private static class put<I extends Iface> extends org.apache.thrift.ProcessFunction<I, put_args> {
1340 public put() {
1341 super("put");
1342 }
1343
1344 protected put_args getEmptyArgsInstance() {
1345 return new put_args();
1346 }
1347
1348 protected put_result getResult(I iface, put_args args) throws org.apache.thrift.TException {
1349 put_result result = new put_result();
1350 try {
1351 iface.put(args.table, args.put);
1352 } catch (TIOError io) {
1353 result.io = io;
1354 }
1355 return result;
1356 }
1357 }
1358
1359 private static class checkAndPut<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndPut_args> {
1360 public checkAndPut() {
1361 super("checkAndPut");
1362 }
1363
1364 protected checkAndPut_args getEmptyArgsInstance() {
1365 return new checkAndPut_args();
1366 }
1367
1368 protected checkAndPut_result getResult(I iface, checkAndPut_args args) throws org.apache.thrift.TException {
1369 checkAndPut_result result = new checkAndPut_result();
1370 try {
1371 result.success = iface.checkAndPut(args.table, args.row, args.family, args.qualifier, args.value, args.put);
1372 result.setSuccessIsSet(true);
1373 } catch (TIOError io) {
1374 result.io = io;
1375 }
1376 return result;
1377 }
1378 }
1379
1380 private static class putMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, putMultiple_args> {
1381 public putMultiple() {
1382 super("putMultiple");
1383 }
1384
1385 protected putMultiple_args getEmptyArgsInstance() {
1386 return new putMultiple_args();
1387 }
1388
1389 protected putMultiple_result getResult(I iface, putMultiple_args args) throws org.apache.thrift.TException {
1390 putMultiple_result result = new putMultiple_result();
1391 try {
1392 iface.putMultiple(args.table, args.puts);
1393 } catch (TIOError io) {
1394 result.io = io;
1395 }
1396 return result;
1397 }
1398 }
1399
1400 private static class deleteSingle<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteSingle_args> {
1401 public deleteSingle() {
1402 super("deleteSingle");
1403 }
1404
1405 protected deleteSingle_args getEmptyArgsInstance() {
1406 return new deleteSingle_args();
1407 }
1408
1409 protected deleteSingle_result getResult(I iface, deleteSingle_args args) throws org.apache.thrift.TException {
1410 deleteSingle_result result = new deleteSingle_result();
1411 try {
1412 iface.deleteSingle(args.table, args.deleteSingle);
1413 } catch (TIOError io) {
1414 result.io = io;
1415 }
1416 return result;
1417 }
1418 }
1419
1420 private static class deleteMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteMultiple_args> {
1421 public deleteMultiple() {
1422 super("deleteMultiple");
1423 }
1424
1425 protected deleteMultiple_args getEmptyArgsInstance() {
1426 return new deleteMultiple_args();
1427 }
1428
1429 protected deleteMultiple_result getResult(I iface, deleteMultiple_args args) throws org.apache.thrift.TException {
1430 deleteMultiple_result result = new deleteMultiple_result();
1431 try {
1432 result.success = iface.deleteMultiple(args.table, args.deletes);
1433 } catch (TIOError io) {
1434 result.io = io;
1435 }
1436 return result;
1437 }
1438 }
1439
1440 private static class checkAndDelete<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndDelete_args> {
1441 public checkAndDelete() {
1442 super("checkAndDelete");
1443 }
1444
1445 protected checkAndDelete_args getEmptyArgsInstance() {
1446 return new checkAndDelete_args();
1447 }
1448
1449 protected checkAndDelete_result getResult(I iface, checkAndDelete_args args) throws org.apache.thrift.TException {
1450 checkAndDelete_result result = new checkAndDelete_result();
1451 try {
1452 result.success = iface.checkAndDelete(args.table, args.row, args.family, args.qualifier, args.value, args.deleteSingle);
1453 result.setSuccessIsSet(true);
1454 } catch (TIOError io) {
1455 result.io = io;
1456 }
1457 return result;
1458 }
1459 }
1460
1461 private static class increment<I extends Iface> extends org.apache.thrift.ProcessFunction<I, increment_args> {
1462 public increment() {
1463 super("increment");
1464 }
1465
1466 protected increment_args getEmptyArgsInstance() {
1467 return new increment_args();
1468 }
1469
1470 protected increment_result getResult(I iface, increment_args args) throws org.apache.thrift.TException {
1471 increment_result result = new increment_result();
1472 try {
1473 result.success = iface.increment(args.table, args.increment);
1474 } catch (TIOError io) {
1475 result.io = io;
1476 }
1477 return result;
1478 }
1479 }
1480
1481 private static class openScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, openScanner_args> {
1482 public openScanner() {
1483 super("openScanner");
1484 }
1485
1486 protected openScanner_args getEmptyArgsInstance() {
1487 return new openScanner_args();
1488 }
1489
1490 protected openScanner_result getResult(I iface, openScanner_args args) throws org.apache.thrift.TException {
1491 openScanner_result result = new openScanner_result();
1492 try {
1493 result.success = iface.openScanner(args.table, args.scan);
1494 result.setSuccessIsSet(true);
1495 } catch (TIOError io) {
1496 result.io = io;
1497 }
1498 return result;
1499 }
1500 }
1501
1502 private static class getScannerRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerRows_args> {
1503 public getScannerRows() {
1504 super("getScannerRows");
1505 }
1506
1507 protected getScannerRows_args getEmptyArgsInstance() {
1508 return new getScannerRows_args();
1509 }
1510
1511 protected getScannerRows_result getResult(I iface, getScannerRows_args args) throws org.apache.thrift.TException {
1512 getScannerRows_result result = new getScannerRows_result();
1513 try {
1514 result.success = iface.getScannerRows(args.scannerId, args.numRows);
1515 } catch (TIOError io) {
1516 result.io = io;
1517 } catch (TIllegalArgument ia) {
1518 result.ia = ia;
1519 }
1520 return result;
1521 }
1522 }
1523
1524 private static class closeScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeScanner_args> {
1525 public closeScanner() {
1526 super("closeScanner");
1527 }
1528
1529 protected closeScanner_args getEmptyArgsInstance() {
1530 return new closeScanner_args();
1531 }
1532
1533 protected closeScanner_result getResult(I iface, closeScanner_args args) throws org.apache.thrift.TException {
1534 closeScanner_result result = new closeScanner_result();
1535 try {
1536 iface.closeScanner(args.scannerId);
1537 } catch (TIOError io) {
1538 result.io = io;
1539 } catch (TIllegalArgument ia) {
1540 result.ia = ia;
1541 }
1542 return result;
1543 }
1544 }
1545
1546 private static class mutateRow<I extends Iface> extends org.apache.thrift.ProcessFunction<I, mutateRow_args> {
1547 public mutateRow() {
1548 super("mutateRow");
1549 }
1550
1551 protected mutateRow_args getEmptyArgsInstance() {
1552 return new mutateRow_args();
1553 }
1554
1555 protected mutateRow_result getResult(I iface, mutateRow_args args) throws org.apache.thrift.TException {
1556 mutateRow_result result = new mutateRow_result();
1557 try {
1558 iface.mutateRow(args.table, args.rowMutations);
1559 } catch (TIOError io) {
1560 result.io = io;
1561 }
1562 return result;
1563 }
1564 }
1565
1566 private static class getScannerResults<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerResults_args> {
1567 public getScannerResults() {
1568 super("getScannerResults");
1569 }
1570
1571 protected getScannerResults_args getEmptyArgsInstance() {
1572 return new getScannerResults_args();
1573 }
1574
1575 protected getScannerResults_result getResult(I iface, getScannerResults_args args) throws org.apache.thrift.TException {
1576 getScannerResults_result result = new getScannerResults_result();
1577 try {
1578 result.success = iface.getScannerResults(args.table, args.scan, args.numRows);
1579 } catch (TIOError io) {
1580 result.io = io;
1581 }
1582 return result;
1583 }
1584 }
1585
1586 }
1587
1588 public static class exists_args implements org.apache.thrift.TBase<exists_args, exists_args._Fields>, java.io.Serializable, Cloneable {
1589 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_args");
1590
1591 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
1592 private static final org.apache.thrift.protocol.TField GET_FIELD_DESC = new org.apache.thrift.protocol.TField("get", org.apache.thrift.protocol.TType.STRUCT, (short)2);
1593
1594 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
1595 static {
1596 schemes.put(StandardScheme.class, new exists_argsStandardSchemeFactory());
1597 schemes.put(TupleScheme.class, new exists_argsTupleSchemeFactory());
1598 }
1599
1600
1601
1602
1603 public ByteBuffer table;
1604
1605
1606
1607 public TGet get;
1608
1609
1610 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
1611
1612
1613
1614 TABLE((short)1, "table"),
1615
1616
1617
1618 GET((short)2, "get");
1619
1620 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
1621
1622 static {
1623 for (_Fields field : EnumSet.allOf(_Fields.class)) {
1624 byName.put(field.getFieldName(), field);
1625 }
1626 }
1627
1628
1629
1630
1631 public static _Fields findByThriftId(int fieldId) {
1632 switch(fieldId) {
1633 case 1:
1634 return TABLE;
1635 case 2:
1636 return GET;
1637 default:
1638 return null;
1639 }
1640 }
1641
1642
1643
1644
1645
1646 public static _Fields findByThriftIdOrThrow(int fieldId) {
1647 _Fields fields = findByThriftId(fieldId);
1648 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
1649 return fields;
1650 }
1651
1652
1653
1654
1655 public static _Fields findByName(String name) {
1656 return byName.get(name);
1657 }
1658
1659 private final short _thriftId;
1660 private final String _fieldName;
1661
1662 _Fields(short thriftId, String fieldName) {
1663 _thriftId = thriftId;
1664 _fieldName = fieldName;
1665 }
1666
1667 public short getThriftFieldId() {
1668 return _thriftId;
1669 }
1670
1671 public String getFieldName() {
1672 return _fieldName;
1673 }
1674 }
1675
1676
1677 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
1678 static {
1679 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
1680 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
1681 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
1682 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
1683 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
1684 metaDataMap = Collections.unmodifiableMap(tmpMap);
1685 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_args.class, metaDataMap);
1686 }
1687
1688 public exists_args() {
1689 }
1690
1691 public exists_args(
1692 ByteBuffer table,
1693 TGet get)
1694 {
1695 this();
1696 this.table = table;
1697 this.get = get;
1698 }
1699
1700
1701
1702
1703 public exists_args(exists_args other) {
1704 if (other.isSetTable()) {
1705 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
1706 ;
1707 }
1708 if (other.isSetGet()) {
1709 this.get = new TGet(other.get);
1710 }
1711 }
1712
1713 public exists_args deepCopy() {
1714 return new exists_args(this);
1715 }
1716
1717 @Override
1718 public void clear() {
1719 this.table = null;
1720 this.get = null;
1721 }
1722
1723
1724
1725
1726 public byte[] getTable() {
1727 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
1728 return table == null ? null : table.array();
1729 }
1730
1731 public ByteBuffer bufferForTable() {
1732 return table;
1733 }
1734
1735
1736
1737
1738 public exists_args setTable(byte[] table) {
1739 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
1740 return this;
1741 }
1742
1743 public exists_args setTable(ByteBuffer table) {
1744 this.table = table;
1745 return this;
1746 }
1747
1748 public void unsetTable() {
1749 this.table = null;
1750 }
1751
1752
1753 public boolean isSetTable() {
1754 return this.table != null;
1755 }
1756
1757 public void setTableIsSet(boolean value) {
1758 if (!value) {
1759 this.table = null;
1760 }
1761 }
1762
1763
1764
1765
1766 public TGet getGet() {
1767 return this.get;
1768 }
1769
1770
1771
1772
1773 public exists_args setGet(TGet get) {
1774 this.get = get;
1775 return this;
1776 }
1777
1778 public void unsetGet() {
1779 this.get = null;
1780 }
1781
1782
1783 public boolean isSetGet() {
1784 return this.get != null;
1785 }
1786
1787 public void setGetIsSet(boolean value) {
1788 if (!value) {
1789 this.get = null;
1790 }
1791 }
1792
1793 public void setFieldValue(_Fields field, Object value) {
1794 switch (field) {
1795 case TABLE:
1796 if (value == null) {
1797 unsetTable();
1798 } else {
1799 setTable((ByteBuffer)value);
1800 }
1801 break;
1802
1803 case GET:
1804 if (value == null) {
1805 unsetGet();
1806 } else {
1807 setGet((TGet)value);
1808 }
1809 break;
1810
1811 }
1812 }
1813
1814 public Object getFieldValue(_Fields field) {
1815 switch (field) {
1816 case TABLE:
1817 return getTable();
1818
1819 case GET:
1820 return getGet();
1821
1822 }
1823 throw new IllegalStateException();
1824 }
1825
1826
1827 public boolean isSet(_Fields field) {
1828 if (field == null) {
1829 throw new IllegalArgumentException();
1830 }
1831
1832 switch (field) {
1833 case TABLE:
1834 return isSetTable();
1835 case GET:
1836 return isSetGet();
1837 }
1838 throw new IllegalStateException();
1839 }
1840
1841 @Override
1842 public boolean equals(Object that) {
1843 if (that == null)
1844 return false;
1845 if (that instanceof exists_args)
1846 return this.equals((exists_args)that);
1847 return false;
1848 }
1849
1850 public boolean equals(exists_args that) {
1851 if (that == null)
1852 return false;
1853
1854 boolean this_present_table = true && this.isSetTable();
1855 boolean that_present_table = true && that.isSetTable();
1856 if (this_present_table || that_present_table) {
1857 if (!(this_present_table && that_present_table))
1858 return false;
1859 if (!this.table.equals(that.table))
1860 return false;
1861 }
1862
1863 boolean this_present_get = true && this.isSetGet();
1864 boolean that_present_get = true && that.isSetGet();
1865 if (this_present_get || that_present_get) {
1866 if (!(this_present_get && that_present_get))
1867 return false;
1868 if (!this.get.equals(that.get))
1869 return false;
1870 }
1871
1872 return true;
1873 }
1874
1875 @Override
1876 public int hashCode() {
1877 HashCodeBuilder builder = new HashCodeBuilder();
1878
1879 boolean present_table = true && (isSetTable());
1880 builder.append(present_table);
1881 if (present_table)
1882 builder.append(table);
1883
1884 boolean present_get = true && (isSetGet());
1885 builder.append(present_get);
1886 if (present_get)
1887 builder.append(get);
1888
1889 return builder.toHashCode();
1890 }
1891
1892 public int compareTo(exists_args other) {
1893 if (!getClass().equals(other.getClass())) {
1894 return getClass().getName().compareTo(other.getClass().getName());
1895 }
1896
1897 int lastComparison = 0;
1898 exists_args typedOther = (exists_args)other;
1899
1900 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
1901 if (lastComparison != 0) {
1902 return lastComparison;
1903 }
1904 if (isSetTable()) {
1905 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
1906 if (lastComparison != 0) {
1907 return lastComparison;
1908 }
1909 }
1910 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
1911 if (lastComparison != 0) {
1912 return lastComparison;
1913 }
1914 if (isSetGet()) {
1915 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
1916 if (lastComparison != 0) {
1917 return lastComparison;
1918 }
1919 }
1920 return 0;
1921 }
1922
1923 public _Fields fieldForId(int fieldId) {
1924 return _Fields.findByThriftId(fieldId);
1925 }
1926
1927 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
1928 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
1929 }
1930
1931 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
1932 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
1933 }
1934
1935 @Override
1936 public String toString() {
1937 StringBuilder sb = new StringBuilder("exists_args(");
1938 boolean first = true;
1939
1940 sb.append("table:");
1941 if (this.table == null) {
1942 sb.append("null");
1943 } else {
1944 org.apache.thrift.TBaseHelper.toString(this.table, sb);
1945 }
1946 first = false;
1947 if (!first) sb.append(", ");
1948 sb.append("get:");
1949 if (this.get == null) {
1950 sb.append("null");
1951 } else {
1952 sb.append(this.get);
1953 }
1954 first = false;
1955 sb.append(")");
1956 return sb.toString();
1957 }
1958
1959 public void validate() throws org.apache.thrift.TException {
1960
1961 if (table == null) {
1962 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
1963 }
1964 if (get == null) {
1965 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
1966 }
1967 }
1968
1969 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
1970 try {
1971 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
1972 } catch (org.apache.thrift.TException te) {
1973 throw new java.io.IOException(te);
1974 }
1975 }
1976
1977 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
1978 try {
1979 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
1980 } catch (org.apache.thrift.TException te) {
1981 throw new java.io.IOException(te);
1982 }
1983 }
1984
1985 private static class exists_argsStandardSchemeFactory implements SchemeFactory {
1986 public exists_argsStandardScheme getScheme() {
1987 return new exists_argsStandardScheme();
1988 }
1989 }
1990
1991 private static class exists_argsStandardScheme extends StandardScheme<exists_args> {
1992
1993 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_args struct) throws org.apache.thrift.TException {
1994 org.apache.thrift.protocol.TField schemeField;
1995 iprot.readStructBegin();
1996 while (true)
1997 {
1998 schemeField = iprot.readFieldBegin();
1999 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2000 break;
2001 }
2002 switch (schemeField.id) {
2003 case 1:
2004 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
2005 struct.table = iprot.readBinary();
2006 struct.setTableIsSet(true);
2007 } else {
2008 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2009 }
2010 break;
2011 case 2:
2012 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2013 struct.get = new TGet();
2014 struct.get.read(iprot);
2015 struct.setGetIsSet(true);
2016 } else {
2017 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2018 }
2019 break;
2020 default:
2021 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2022 }
2023 iprot.readFieldEnd();
2024 }
2025 iprot.readStructEnd();
2026
2027
2028 struct.validate();
2029 }
2030
2031 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_args struct) throws org.apache.thrift.TException {
2032 struct.validate();
2033
2034 oprot.writeStructBegin(STRUCT_DESC);
2035 if (struct.table != null) {
2036 oprot.writeFieldBegin(TABLE_FIELD_DESC);
2037 oprot.writeBinary(struct.table);
2038 oprot.writeFieldEnd();
2039 }
2040 if (struct.get != null) {
2041 oprot.writeFieldBegin(GET_FIELD_DESC);
2042 struct.get.write(oprot);
2043 oprot.writeFieldEnd();
2044 }
2045 oprot.writeFieldStop();
2046 oprot.writeStructEnd();
2047 }
2048
2049 }
2050
2051 private static class exists_argsTupleSchemeFactory implements SchemeFactory {
2052 public exists_argsTupleScheme getScheme() {
2053 return new exists_argsTupleScheme();
2054 }
2055 }
2056
2057 private static class exists_argsTupleScheme extends TupleScheme<exists_args> {
2058
2059 @Override
2060 public void write(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
2061 TTupleProtocol oprot = (TTupleProtocol) prot;
2062 oprot.writeBinary(struct.table);
2063 struct.get.write(oprot);
2064 }
2065
2066 @Override
2067 public void read(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
2068 TTupleProtocol iprot = (TTupleProtocol) prot;
2069 struct.table = iprot.readBinary();
2070 struct.setTableIsSet(true);
2071 struct.get = new TGet();
2072 struct.get.read(iprot);
2073 struct.setGetIsSet(true);
2074 }
2075 }
2076
2077 }
2078
2079 public static class exists_result implements org.apache.thrift.TBase<exists_result, exists_result._Fields>, java.io.Serializable, Cloneable {
2080 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_result");
2081
2082 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0);
2083 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
2084
2085 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2086 static {
2087 schemes.put(StandardScheme.class, new exists_resultStandardSchemeFactory());
2088 schemes.put(TupleScheme.class, new exists_resultTupleSchemeFactory());
2089 }
2090
2091 public boolean success;
2092 public TIOError io;
2093
2094
2095 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2096 SUCCESS((short)0, "success"),
2097 IO((short)1, "io");
2098
2099 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2100
2101 static {
2102 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2103 byName.put(field.getFieldName(), field);
2104 }
2105 }
2106
2107
2108
2109
2110 public static _Fields findByThriftId(int fieldId) {
2111 switch(fieldId) {
2112 case 0:
2113 return SUCCESS;
2114 case 1:
2115 return IO;
2116 default:
2117 return null;
2118 }
2119 }
2120
2121
2122
2123
2124
2125 public static _Fields findByThriftIdOrThrow(int fieldId) {
2126 _Fields fields = findByThriftId(fieldId);
2127 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2128 return fields;
2129 }
2130
2131
2132
2133
2134 public static _Fields findByName(String name) {
2135 return byName.get(name);
2136 }
2137
2138 private final short _thriftId;
2139 private final String _fieldName;
2140
2141 _Fields(short thriftId, String fieldName) {
2142 _thriftId = thriftId;
2143 _fieldName = fieldName;
2144 }
2145
2146 public short getThriftFieldId() {
2147 return _thriftId;
2148 }
2149
2150 public String getFieldName() {
2151 return _fieldName;
2152 }
2153 }
2154
2155
2156 private static final int __SUCCESS_ISSET_ID = 0;
2157 private BitSet __isset_bit_vector = new BitSet(1);
2158 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2159 static {
2160 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2161 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
2162 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
2163 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
2164 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
2165 metaDataMap = Collections.unmodifiableMap(tmpMap);
2166 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_result.class, metaDataMap);
2167 }
2168
2169 public exists_result() {
2170 }
2171
2172 public exists_result(
2173 boolean success,
2174 TIOError io)
2175 {
2176 this();
2177 this.success = success;
2178 setSuccessIsSet(true);
2179 this.io = io;
2180 }
2181
2182
2183
2184
2185 public exists_result(exists_result other) {
2186 __isset_bit_vector.clear();
2187 __isset_bit_vector.or(other.__isset_bit_vector);
2188 this.success = other.success;
2189 if (other.isSetIo()) {
2190 this.io = new TIOError(other.io);
2191 }
2192 }
2193
2194 public exists_result deepCopy() {
2195 return new exists_result(this);
2196 }
2197
2198 @Override
2199 public void clear() {
2200 setSuccessIsSet(false);
2201 this.success = false;
2202 this.io = null;
2203 }
2204
2205 public boolean isSuccess() {
2206 return this.success;
2207 }
2208
2209 public exists_result setSuccess(boolean success) {
2210 this.success = success;
2211 setSuccessIsSet(true);
2212 return this;
2213 }
2214
2215 public void unsetSuccess() {
2216 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
2217 }
2218
2219
2220 public boolean isSetSuccess() {
2221 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
2222 }
2223
2224 public void setSuccessIsSet(boolean value) {
2225 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
2226 }
2227
2228 public TIOError getIo() {
2229 return this.io;
2230 }
2231
2232 public exists_result setIo(TIOError io) {
2233 this.io = io;
2234 return this;
2235 }
2236
2237 public void unsetIo() {
2238 this.io = null;
2239 }
2240
2241
2242 public boolean isSetIo() {
2243 return this.io != null;
2244 }
2245
2246 public void setIoIsSet(boolean value) {
2247 if (!value) {
2248 this.io = null;
2249 }
2250 }
2251
2252 public void setFieldValue(_Fields field, Object value) {
2253 switch (field) {
2254 case SUCCESS:
2255 if (value == null) {
2256 unsetSuccess();
2257 } else {
2258 setSuccess((Boolean)value);
2259 }
2260 break;
2261
2262 case IO:
2263 if (value == null) {
2264 unsetIo();
2265 } else {
2266 setIo((TIOError)value);
2267 }
2268 break;
2269
2270 }
2271 }
2272
2273 public Object getFieldValue(_Fields field) {
2274 switch (field) {
2275 case SUCCESS:
2276 return Boolean.valueOf(isSuccess());
2277
2278 case IO:
2279 return getIo();
2280
2281 }
2282 throw new IllegalStateException();
2283 }
2284
2285
2286 public boolean isSet(_Fields field) {
2287 if (field == null) {
2288 throw new IllegalArgumentException();
2289 }
2290
2291 switch (field) {
2292 case SUCCESS:
2293 return isSetSuccess();
2294 case IO:
2295 return isSetIo();
2296 }
2297 throw new IllegalStateException();
2298 }
2299
2300 @Override
2301 public boolean equals(Object that) {
2302 if (that == null)
2303 return false;
2304 if (that instanceof exists_result)
2305 return this.equals((exists_result)that);
2306 return false;
2307 }
2308
2309 public boolean equals(exists_result that) {
2310 if (that == null)
2311 return false;
2312
2313 boolean this_present_success = true;
2314 boolean that_present_success = true;
2315 if (this_present_success || that_present_success) {
2316 if (!(this_present_success && that_present_success))
2317 return false;
2318 if (this.success != that.success)
2319 return false;
2320 }
2321
2322 boolean this_present_io = true && this.isSetIo();
2323 boolean that_present_io = true && that.isSetIo();
2324 if (this_present_io || that_present_io) {
2325 if (!(this_present_io && that_present_io))
2326 return false;
2327 if (!this.io.equals(that.io))
2328 return false;
2329 }
2330
2331 return true;
2332 }
2333
2334 @Override
2335 public int hashCode() {
2336 HashCodeBuilder builder = new HashCodeBuilder();
2337
2338 boolean present_success = true;
2339 builder.append(present_success);
2340 if (present_success)
2341 builder.append(success);
2342
2343 boolean present_io = true && (isSetIo());
2344 builder.append(present_io);
2345 if (present_io)
2346 builder.append(io);
2347
2348 return builder.toHashCode();
2349 }
2350
2351 public int compareTo(exists_result other) {
2352 if (!getClass().equals(other.getClass())) {
2353 return getClass().getName().compareTo(other.getClass().getName());
2354 }
2355
2356 int lastComparison = 0;
2357 exists_result typedOther = (exists_result)other;
2358
2359 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
2360 if (lastComparison != 0) {
2361 return lastComparison;
2362 }
2363 if (isSetSuccess()) {
2364 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
2365 if (lastComparison != 0) {
2366 return lastComparison;
2367 }
2368 }
2369 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
2370 if (lastComparison != 0) {
2371 return lastComparison;
2372 }
2373 if (isSetIo()) {
2374 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
2375 if (lastComparison != 0) {
2376 return lastComparison;
2377 }
2378 }
2379 return 0;
2380 }
2381
2382 public _Fields fieldForId(int fieldId) {
2383 return _Fields.findByThriftId(fieldId);
2384 }
2385
2386 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2387 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2388 }
2389
2390 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2391 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2392 }
2393
2394 @Override
2395 public String toString() {
2396 StringBuilder sb = new StringBuilder("exists_result(");
2397 boolean first = true;
2398
2399 sb.append("success:");
2400 sb.append(this.success);
2401 first = false;
2402 if (!first) sb.append(", ");
2403 sb.append("io:");
2404 if (this.io == null) {
2405 sb.append("null");
2406 } else {
2407 sb.append(this.io);
2408 }
2409 first = false;
2410 sb.append(")");
2411 return sb.toString();
2412 }
2413
2414 public void validate() throws org.apache.thrift.TException {
2415
2416 }
2417
2418 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2419 try {
2420 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2421 } catch (org.apache.thrift.TException te) {
2422 throw new java.io.IOException(te);
2423 }
2424 }
2425
2426 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2427 try {
2428 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2429 } catch (org.apache.thrift.TException te) {
2430 throw new java.io.IOException(te);
2431 }
2432 }
2433
2434 private static class exists_resultStandardSchemeFactory implements SchemeFactory {
2435 public exists_resultStandardScheme getScheme() {
2436 return new exists_resultStandardScheme();
2437 }
2438 }
2439
2440 private static class exists_resultStandardScheme extends StandardScheme<exists_result> {
2441
2442 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_result struct) throws org.apache.thrift.TException {
2443 org.apache.thrift.protocol.TField schemeField;
2444 iprot.readStructBegin();
2445 while (true)
2446 {
2447 schemeField = iprot.readFieldBegin();
2448 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2449 break;
2450 }
2451 switch (schemeField.id) {
2452 case 0:
2453 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
2454 struct.success = iprot.readBool();
2455 struct.setSuccessIsSet(true);
2456 } else {
2457 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2458 }
2459 break;
2460 case 1:
2461 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2462 struct.io = new TIOError();
2463 struct.io.read(iprot);
2464 struct.setIoIsSet(true);
2465 } else {
2466 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2467 }
2468 break;
2469 default:
2470 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2471 }
2472 iprot.readFieldEnd();
2473 }
2474 iprot.readStructEnd();
2475
2476
2477 struct.validate();
2478 }
2479
2480 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_result struct) throws org.apache.thrift.TException {
2481 struct.validate();
2482
2483 oprot.writeStructBegin(STRUCT_DESC);
2484 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
2485 oprot.writeBool(struct.success);
2486 oprot.writeFieldEnd();
2487 if (struct.io != null) {
2488 oprot.writeFieldBegin(IO_FIELD_DESC);
2489 struct.io.write(oprot);
2490 oprot.writeFieldEnd();
2491 }
2492 oprot.writeFieldStop();
2493 oprot.writeStructEnd();
2494 }
2495
2496 }
2497
2498 private static class exists_resultTupleSchemeFactory implements SchemeFactory {
2499 public exists_resultTupleScheme getScheme() {
2500 return new exists_resultTupleScheme();
2501 }
2502 }
2503
2504 private static class exists_resultTupleScheme extends TupleScheme<exists_result> {
2505
2506 @Override
2507 public void write(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2508 TTupleProtocol oprot = (TTupleProtocol) prot;
2509 BitSet optionals = new BitSet();
2510 if (struct.isSetSuccess()) {
2511 optionals.set(0);
2512 }
2513 if (struct.isSetIo()) {
2514 optionals.set(1);
2515 }
2516 oprot.writeBitSet(optionals, 2);
2517 if (struct.isSetSuccess()) {
2518 oprot.writeBool(struct.success);
2519 }
2520 if (struct.isSetIo()) {
2521 struct.io.write(oprot);
2522 }
2523 }
2524
2525 @Override
2526 public void read(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2527 TTupleProtocol iprot = (TTupleProtocol) prot;
2528 BitSet incoming = iprot.readBitSet(2);
2529 if (incoming.get(0)) {
2530 struct.success = iprot.readBool();
2531 struct.setSuccessIsSet(true);
2532 }
2533 if (incoming.get(1)) {
2534 struct.io = new TIOError();
2535 struct.io.read(iprot);
2536 struct.setIoIsSet(true);
2537 }
2538 }
2539 }
2540
2541 }
2542
2543 public static class get_args implements org.apache.thrift.TBase<get_args, get_args._Fields>, java.io.Serializable, Cloneable {
2544 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_args");
2545
2546 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
2547 private static final org.apache.thrift.protocol.TField GET_FIELD_DESC = new org.apache.thrift.protocol.TField("get", org.apache.thrift.protocol.TType.STRUCT, (short)2);
2548
2549 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2550 static {
2551 schemes.put(StandardScheme.class, new get_argsStandardSchemeFactory());
2552 schemes.put(TupleScheme.class, new get_argsTupleSchemeFactory());
2553 }
2554
2555
2556
2557
2558 public ByteBuffer table;
2559
2560
2561
2562 public TGet get;
2563
2564
2565 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2566
2567
2568
2569 TABLE((short)1, "table"),
2570
2571
2572
2573 GET((short)2, "get");
2574
2575 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2576
2577 static {
2578 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2579 byName.put(field.getFieldName(), field);
2580 }
2581 }
2582
2583
2584
2585
2586 public static _Fields findByThriftId(int fieldId) {
2587 switch(fieldId) {
2588 case 1:
2589 return TABLE;
2590 case 2:
2591 return GET;
2592 default:
2593 return null;
2594 }
2595 }
2596
2597
2598
2599
2600
2601 public static _Fields findByThriftIdOrThrow(int fieldId) {
2602 _Fields fields = findByThriftId(fieldId);
2603 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2604 return fields;
2605 }
2606
2607
2608
2609
2610 public static _Fields findByName(String name) {
2611 return byName.get(name);
2612 }
2613
2614 private final short _thriftId;
2615 private final String _fieldName;
2616
2617 _Fields(short thriftId, String fieldName) {
2618 _thriftId = thriftId;
2619 _fieldName = fieldName;
2620 }
2621
2622 public short getThriftFieldId() {
2623 return _thriftId;
2624 }
2625
2626 public String getFieldName() {
2627 return _fieldName;
2628 }
2629 }
2630
2631
2632 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2633 static {
2634 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2635 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
2636 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
2637 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
2638 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
2639 metaDataMap = Collections.unmodifiableMap(tmpMap);
2640 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
2641 }
2642
2643 public get_args() {
2644 }
2645
2646 public get_args(
2647 ByteBuffer table,
2648 TGet get)
2649 {
2650 this();
2651 this.table = table;
2652 this.get = get;
2653 }
2654
2655
2656
2657
2658 public get_args(get_args other) {
2659 if (other.isSetTable()) {
2660 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
2661 ;
2662 }
2663 if (other.isSetGet()) {
2664 this.get = new TGet(other.get);
2665 }
2666 }
2667
2668 public get_args deepCopy() {
2669 return new get_args(this);
2670 }
2671
2672 @Override
2673 public void clear() {
2674 this.table = null;
2675 this.get = null;
2676 }
2677
2678
2679
2680
2681 public byte[] getTable() {
2682 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
2683 return table == null ? null : table.array();
2684 }
2685
2686 public ByteBuffer bufferForTable() {
2687 return table;
2688 }
2689
2690
2691
2692
2693 public get_args setTable(byte[] table) {
2694 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
2695 return this;
2696 }
2697
2698 public get_args setTable(ByteBuffer table) {
2699 this.table = table;
2700 return this;
2701 }
2702
2703 public void unsetTable() {
2704 this.table = null;
2705 }
2706
2707
2708 public boolean isSetTable() {
2709 return this.table != null;
2710 }
2711
2712 public void setTableIsSet(boolean value) {
2713 if (!value) {
2714 this.table = null;
2715 }
2716 }
2717
2718
2719
2720
2721 public TGet getGet() {
2722 return this.get;
2723 }
2724
2725
2726
2727
2728 public get_args setGet(TGet get) {
2729 this.get = get;
2730 return this;
2731 }
2732
2733 public void unsetGet() {
2734 this.get = null;
2735 }
2736
2737
2738 public boolean isSetGet() {
2739 return this.get != null;
2740 }
2741
2742 public void setGetIsSet(boolean value) {
2743 if (!value) {
2744 this.get = null;
2745 }
2746 }
2747
2748 public void setFieldValue(_Fields field, Object value) {
2749 switch (field) {
2750 case TABLE:
2751 if (value == null) {
2752 unsetTable();
2753 } else {
2754 setTable((ByteBuffer)value);
2755 }
2756 break;
2757
2758 case GET:
2759 if (value == null) {
2760 unsetGet();
2761 } else {
2762 setGet((TGet)value);
2763 }
2764 break;
2765
2766 }
2767 }
2768
2769 public Object getFieldValue(_Fields field) {
2770 switch (field) {
2771 case TABLE:
2772 return getTable();
2773
2774 case GET:
2775 return getGet();
2776
2777 }
2778 throw new IllegalStateException();
2779 }
2780
2781
2782 public boolean isSet(_Fields field) {
2783 if (field == null) {
2784 throw new IllegalArgumentException();
2785 }
2786
2787 switch (field) {
2788 case TABLE:
2789 return isSetTable();
2790 case GET:
2791 return isSetGet();
2792 }
2793 throw new IllegalStateException();
2794 }
2795
2796 @Override
2797 public boolean equals(Object that) {
2798 if (that == null)
2799 return false;
2800 if (that instanceof get_args)
2801 return this.equals((get_args)that);
2802 return false;
2803 }
2804
2805 public boolean equals(get_args that) {
2806 if (that == null)
2807 return false;
2808
2809 boolean this_present_table = true && this.isSetTable();
2810 boolean that_present_table = true && that.isSetTable();
2811 if (this_present_table || that_present_table) {
2812 if (!(this_present_table && that_present_table))
2813 return false;
2814 if (!this.table.equals(that.table))
2815 return false;
2816 }
2817
2818 boolean this_present_get = true && this.isSetGet();
2819 boolean that_present_get = true && that.isSetGet();
2820 if (this_present_get || that_present_get) {
2821 if (!(this_present_get && that_present_get))
2822 return false;
2823 if (!this.get.equals(that.get))
2824 return false;
2825 }
2826
2827 return true;
2828 }
2829
2830 @Override
2831 public int hashCode() {
2832 HashCodeBuilder builder = new HashCodeBuilder();
2833
2834 boolean present_table = true && (isSetTable());
2835 builder.append(present_table);
2836 if (present_table)
2837 builder.append(table);
2838
2839 boolean present_get = true && (isSetGet());
2840 builder.append(present_get);
2841 if (present_get)
2842 builder.append(get);
2843
2844 return builder.toHashCode();
2845 }
2846
2847 public int compareTo(get_args other) {
2848 if (!getClass().equals(other.getClass())) {
2849 return getClass().getName().compareTo(other.getClass().getName());
2850 }
2851
2852 int lastComparison = 0;
2853 get_args typedOther = (get_args)other;
2854
2855 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
2856 if (lastComparison != 0) {
2857 return lastComparison;
2858 }
2859 if (isSetTable()) {
2860 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
2861 if (lastComparison != 0) {
2862 return lastComparison;
2863 }
2864 }
2865 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
2866 if (lastComparison != 0) {
2867 return lastComparison;
2868 }
2869 if (isSetGet()) {
2870 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
2871 if (lastComparison != 0) {
2872 return lastComparison;
2873 }
2874 }
2875 return 0;
2876 }
2877
2878 public _Fields fieldForId(int fieldId) {
2879 return _Fields.findByThriftId(fieldId);
2880 }
2881
2882 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2883 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2884 }
2885
2886 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2887 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2888 }
2889
2890 @Override
2891 public String toString() {
2892 StringBuilder sb = new StringBuilder("get_args(");
2893 boolean first = true;
2894
2895 sb.append("table:");
2896 if (this.table == null) {
2897 sb.append("null");
2898 } else {
2899 org.apache.thrift.TBaseHelper.toString(this.table, sb);
2900 }
2901 first = false;
2902 if (!first) sb.append(", ");
2903 sb.append("get:");
2904 if (this.get == null) {
2905 sb.append("null");
2906 } else {
2907 sb.append(this.get);
2908 }
2909 first = false;
2910 sb.append(")");
2911 return sb.toString();
2912 }
2913
2914 public void validate() throws org.apache.thrift.TException {
2915
2916 if (table == null) {
2917 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
2918 }
2919 if (get == null) {
2920 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
2921 }
2922 }
2923
2924 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2925 try {
2926 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2927 } catch (org.apache.thrift.TException te) {
2928 throw new java.io.IOException(te);
2929 }
2930 }
2931
2932 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2933 try {
2934 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2935 } catch (org.apache.thrift.TException te) {
2936 throw new java.io.IOException(te);
2937 }
2938 }
2939
2940 private static class get_argsStandardSchemeFactory implements SchemeFactory {
2941 public get_argsStandardScheme getScheme() {
2942 return new get_argsStandardScheme();
2943 }
2944 }
2945
2946 private static class get_argsStandardScheme extends StandardScheme<get_args> {
2947
2948 public void read(org.apache.thrift.protocol.TProtocol iprot, get_args struct) throws org.apache.thrift.TException {
2949 org.apache.thrift.protocol.TField schemeField;
2950 iprot.readStructBegin();
2951 while (true)
2952 {
2953 schemeField = iprot.readFieldBegin();
2954 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2955 break;
2956 }
2957 switch (schemeField.id) {
2958 case 1:
2959 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
2960 struct.table = iprot.readBinary();
2961 struct.setTableIsSet(true);
2962 } else {
2963 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2964 }
2965 break;
2966 case 2:
2967 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2968 struct.get = new TGet();
2969 struct.get.read(iprot);
2970 struct.setGetIsSet(true);
2971 } else {
2972 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2973 }
2974 break;
2975 default:
2976 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2977 }
2978 iprot.readFieldEnd();
2979 }
2980 iprot.readStructEnd();
2981
2982
2983 struct.validate();
2984 }
2985
2986 public void write(org.apache.thrift.protocol.TProtocol oprot, get_args struct) throws org.apache.thrift.TException {
2987 struct.validate();
2988
2989 oprot.writeStructBegin(STRUCT_DESC);
2990 if (struct.table != null) {
2991 oprot.writeFieldBegin(TABLE_FIELD_DESC);
2992 oprot.writeBinary(struct.table);
2993 oprot.writeFieldEnd();
2994 }
2995 if (struct.get != null) {
2996 oprot.writeFieldBegin(GET_FIELD_DESC);
2997 struct.get.write(oprot);
2998 oprot.writeFieldEnd();
2999 }
3000 oprot.writeFieldStop();
3001 oprot.writeStructEnd();
3002 }
3003
3004 }
3005
3006 private static class get_argsTupleSchemeFactory implements SchemeFactory {
3007 public get_argsTupleScheme getScheme() {
3008 return new get_argsTupleScheme();
3009 }
3010 }
3011
3012 private static class get_argsTupleScheme extends TupleScheme<get_args> {
3013
3014 @Override
3015 public void write(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
3016 TTupleProtocol oprot = (TTupleProtocol) prot;
3017 oprot.writeBinary(struct.table);
3018 struct.get.write(oprot);
3019 }
3020
3021 @Override
3022 public void read(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
3023 TTupleProtocol iprot = (TTupleProtocol) prot;
3024 struct.table = iprot.readBinary();
3025 struct.setTableIsSet(true);
3026 struct.get = new TGet();
3027 struct.get.read(iprot);
3028 struct.setGetIsSet(true);
3029 }
3030 }
3031
3032 }
3033
3034 public static class get_result implements org.apache.thrift.TBase<get_result, get_result._Fields>, java.io.Serializable, Cloneable {
3035 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_result");
3036
3037 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
3038 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
3039
3040 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3041 static {
3042 schemes.put(StandardScheme.class, new get_resultStandardSchemeFactory());
3043 schemes.put(TupleScheme.class, new get_resultTupleSchemeFactory());
3044 }
3045
3046 public TResult success;
3047 public TIOError io;
3048
3049
3050 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3051 SUCCESS((short)0, "success"),
3052 IO((short)1, "io");
3053
3054 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3055
3056 static {
3057 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3058 byName.put(field.getFieldName(), field);
3059 }
3060 }
3061
3062
3063
3064
3065 public static _Fields findByThriftId(int fieldId) {
3066 switch(fieldId) {
3067 case 0:
3068 return SUCCESS;
3069 case 1:
3070 return IO;
3071 default:
3072 return null;
3073 }
3074 }
3075
3076
3077
3078
3079
3080 public static _Fields findByThriftIdOrThrow(int fieldId) {
3081 _Fields fields = findByThriftId(fieldId);
3082 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3083 return fields;
3084 }
3085
3086
3087
3088
3089 public static _Fields findByName(String name) {
3090 return byName.get(name);
3091 }
3092
3093 private final short _thriftId;
3094 private final String _fieldName;
3095
3096 _Fields(short thriftId, String fieldName) {
3097 _thriftId = thriftId;
3098 _fieldName = fieldName;
3099 }
3100
3101 public short getThriftFieldId() {
3102 return _thriftId;
3103 }
3104
3105 public String getFieldName() {
3106 return _fieldName;
3107 }
3108 }
3109
3110
3111 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3112 static {
3113 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3114 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
3115 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
3116 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
3117 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
3118 metaDataMap = Collections.unmodifiableMap(tmpMap);
3119 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
3120 }
3121
3122 public get_result() {
3123 }
3124
3125 public get_result(
3126 TResult success,
3127 TIOError io)
3128 {
3129 this();
3130 this.success = success;
3131 this.io = io;
3132 }
3133
3134
3135
3136
3137 public get_result(get_result other) {
3138 if (other.isSetSuccess()) {
3139 this.success = new TResult(other.success);
3140 }
3141 if (other.isSetIo()) {
3142 this.io = new TIOError(other.io);
3143 }
3144 }
3145
3146 public get_result deepCopy() {
3147 return new get_result(this);
3148 }
3149
3150 @Override
3151 public void clear() {
3152 this.success = null;
3153 this.io = null;
3154 }
3155
3156 public TResult getSuccess() {
3157 return this.success;
3158 }
3159
3160 public get_result setSuccess(TResult success) {
3161 this.success = success;
3162 return this;
3163 }
3164
3165 public void unsetSuccess() {
3166 this.success = null;
3167 }
3168
3169
3170 public boolean isSetSuccess() {
3171 return this.success != null;
3172 }
3173
3174 public void setSuccessIsSet(boolean value) {
3175 if (!value) {
3176 this.success = null;
3177 }
3178 }
3179
3180 public TIOError getIo() {
3181 return this.io;
3182 }
3183
3184 public get_result setIo(TIOError io) {
3185 this.io = io;
3186 return this;
3187 }
3188
3189 public void unsetIo() {
3190 this.io = null;
3191 }
3192
3193
3194 public boolean isSetIo() {
3195 return this.io != null;
3196 }
3197
3198 public void setIoIsSet(boolean value) {
3199 if (!value) {
3200 this.io = null;
3201 }
3202 }
3203
3204 public void setFieldValue(_Fields field, Object value) {
3205 switch (field) {
3206 case SUCCESS:
3207 if (value == null) {
3208 unsetSuccess();
3209 } else {
3210 setSuccess((TResult)value);
3211 }
3212 break;
3213
3214 case IO:
3215 if (value == null) {
3216 unsetIo();
3217 } else {
3218 setIo((TIOError)value);
3219 }
3220 break;
3221
3222 }
3223 }
3224
3225 public Object getFieldValue(_Fields field) {
3226 switch (field) {
3227 case SUCCESS:
3228 return getSuccess();
3229
3230 case IO:
3231 return getIo();
3232
3233 }
3234 throw new IllegalStateException();
3235 }
3236
3237
3238 public boolean isSet(_Fields field) {
3239 if (field == null) {
3240 throw new IllegalArgumentException();
3241 }
3242
3243 switch (field) {
3244 case SUCCESS:
3245 return isSetSuccess();
3246 case IO:
3247 return isSetIo();
3248 }
3249 throw new IllegalStateException();
3250 }
3251
3252 @Override
3253 public boolean equals(Object that) {
3254 if (that == null)
3255 return false;
3256 if (that instanceof get_result)
3257 return this.equals((get_result)that);
3258 return false;
3259 }
3260
3261 public boolean equals(get_result that) {
3262 if (that == null)
3263 return false;
3264
3265 boolean this_present_success = true && this.isSetSuccess();
3266 boolean that_present_success = true && that.isSetSuccess();
3267 if (this_present_success || that_present_success) {
3268 if (!(this_present_success && that_present_success))
3269 return false;
3270 if (!this.success.equals(that.success))
3271 return false;
3272 }
3273
3274 boolean this_present_io = true && this.isSetIo();
3275 boolean that_present_io = true && that.isSetIo();
3276 if (this_present_io || that_present_io) {
3277 if (!(this_present_io && that_present_io))
3278 return false;
3279 if (!this.io.equals(that.io))
3280 return false;
3281 }
3282
3283 return true;
3284 }
3285
3286 @Override
3287 public int hashCode() {
3288 HashCodeBuilder builder = new HashCodeBuilder();
3289
3290 boolean present_success = true && (isSetSuccess());
3291 builder.append(present_success);
3292 if (present_success)
3293 builder.append(success);
3294
3295 boolean present_io = true && (isSetIo());
3296 builder.append(present_io);
3297 if (present_io)
3298 builder.append(io);
3299
3300 return builder.toHashCode();
3301 }
3302
3303 public int compareTo(get_result other) {
3304 if (!getClass().equals(other.getClass())) {
3305 return getClass().getName().compareTo(other.getClass().getName());
3306 }
3307
3308 int lastComparison = 0;
3309 get_result typedOther = (get_result)other;
3310
3311 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
3312 if (lastComparison != 0) {
3313 return lastComparison;
3314 }
3315 if (isSetSuccess()) {
3316 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
3317 if (lastComparison != 0) {
3318 return lastComparison;
3319 }
3320 }
3321 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
3322 if (lastComparison != 0) {
3323 return lastComparison;
3324 }
3325 if (isSetIo()) {
3326 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
3327 if (lastComparison != 0) {
3328 return lastComparison;
3329 }
3330 }
3331 return 0;
3332 }
3333
3334 public _Fields fieldForId(int fieldId) {
3335 return _Fields.findByThriftId(fieldId);
3336 }
3337
3338 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3339 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3340 }
3341
3342 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3343 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3344 }
3345
3346 @Override
3347 public String toString() {
3348 StringBuilder sb = new StringBuilder("get_result(");
3349 boolean first = true;
3350
3351 sb.append("success:");
3352 if (this.success == null) {
3353 sb.append("null");
3354 } else {
3355 sb.append(this.success);
3356 }
3357 first = false;
3358 if (!first) sb.append(", ");
3359 sb.append("io:");
3360 if (this.io == null) {
3361 sb.append("null");
3362 } else {
3363 sb.append(this.io);
3364 }
3365 first = false;
3366 sb.append(")");
3367 return sb.toString();
3368 }
3369
3370 public void validate() throws org.apache.thrift.TException {
3371
3372 }
3373
3374 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3375 try {
3376 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3377 } catch (org.apache.thrift.TException te) {
3378 throw new java.io.IOException(te);
3379 }
3380 }
3381
3382 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3383 try {
3384 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3385 } catch (org.apache.thrift.TException te) {
3386 throw new java.io.IOException(te);
3387 }
3388 }
3389
3390 private static class get_resultStandardSchemeFactory implements SchemeFactory {
3391 public get_resultStandardScheme getScheme() {
3392 return new get_resultStandardScheme();
3393 }
3394 }
3395
3396 private static class get_resultStandardScheme extends StandardScheme<get_result> {
3397
3398 public void read(org.apache.thrift.protocol.TProtocol iprot, get_result struct) throws org.apache.thrift.TException {
3399 org.apache.thrift.protocol.TField schemeField;
3400 iprot.readStructBegin();
3401 while (true)
3402 {
3403 schemeField = iprot.readFieldBegin();
3404 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3405 break;
3406 }
3407 switch (schemeField.id) {
3408 case 0:
3409 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3410 struct.success = new TResult();
3411 struct.success.read(iprot);
3412 struct.setSuccessIsSet(true);
3413 } else {
3414 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3415 }
3416 break;
3417 case 1:
3418 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3419 struct.io = new TIOError();
3420 struct.io.read(iprot);
3421 struct.setIoIsSet(true);
3422 } else {
3423 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3424 }
3425 break;
3426 default:
3427 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3428 }
3429 iprot.readFieldEnd();
3430 }
3431 iprot.readStructEnd();
3432
3433
3434 struct.validate();
3435 }
3436
3437 public void write(org.apache.thrift.protocol.TProtocol oprot, get_result struct) throws org.apache.thrift.TException {
3438 struct.validate();
3439
3440 oprot.writeStructBegin(STRUCT_DESC);
3441 if (struct.success != null) {
3442 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3443 struct.success.write(oprot);
3444 oprot.writeFieldEnd();
3445 }
3446 if (struct.io != null) {
3447 oprot.writeFieldBegin(IO_FIELD_DESC);
3448 struct.io.write(oprot);
3449 oprot.writeFieldEnd();
3450 }
3451 oprot.writeFieldStop();
3452 oprot.writeStructEnd();
3453 }
3454
3455 }
3456
3457 private static class get_resultTupleSchemeFactory implements SchemeFactory {
3458 public get_resultTupleScheme getScheme() {
3459 return new get_resultTupleScheme();
3460 }
3461 }
3462
3463 private static class get_resultTupleScheme extends TupleScheme<get_result> {
3464
3465 @Override
3466 public void write(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3467 TTupleProtocol oprot = (TTupleProtocol) prot;
3468 BitSet optionals = new BitSet();
3469 if (struct.isSetSuccess()) {
3470 optionals.set(0);
3471 }
3472 if (struct.isSetIo()) {
3473 optionals.set(1);
3474 }
3475 oprot.writeBitSet(optionals, 2);
3476 if (struct.isSetSuccess()) {
3477 struct.success.write(oprot);
3478 }
3479 if (struct.isSetIo()) {
3480 struct.io.write(oprot);
3481 }
3482 }
3483
3484 @Override
3485 public void read(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3486 TTupleProtocol iprot = (TTupleProtocol) prot;
3487 BitSet incoming = iprot.readBitSet(2);
3488 if (incoming.get(0)) {
3489 struct.success = new TResult();
3490 struct.success.read(iprot);
3491 struct.setSuccessIsSet(true);
3492 }
3493 if (incoming.get(1)) {
3494 struct.io = new TIOError();
3495 struct.io.read(iprot);
3496 struct.setIoIsSet(true);
3497 }
3498 }
3499 }
3500
3501 }
3502
3503 public static class getMultiple_args implements org.apache.thrift.TBase<getMultiple_args, getMultiple_args._Fields>, java.io.Serializable, Cloneable {
3504 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_args");
3505
3506 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
3507 private static final org.apache.thrift.protocol.TField GETS_FIELD_DESC = new org.apache.thrift.protocol.TField("gets", org.apache.thrift.protocol.TType.LIST, (short)2);
3508
3509 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3510 static {
3511 schemes.put(StandardScheme.class, new getMultiple_argsStandardSchemeFactory());
3512 schemes.put(TupleScheme.class, new getMultiple_argsTupleSchemeFactory());
3513 }
3514
3515
3516
3517
3518 public ByteBuffer table;
3519
3520
3521
3522
3523
3524 public List<TGet> gets;
3525
3526
3527 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3528
3529
3530
3531 TABLE((short)1, "table"),
3532
3533
3534
3535
3536
3537 GETS((short)2, "gets");
3538
3539 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3540
3541 static {
3542 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3543 byName.put(field.getFieldName(), field);
3544 }
3545 }
3546
3547
3548
3549
3550 public static _Fields findByThriftId(int fieldId) {
3551 switch(fieldId) {
3552 case 1:
3553 return TABLE;
3554 case 2:
3555 return GETS;
3556 default:
3557 return null;
3558 }
3559 }
3560
3561
3562
3563
3564
3565 public static _Fields findByThriftIdOrThrow(int fieldId) {
3566 _Fields fields = findByThriftId(fieldId);
3567 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3568 return fields;
3569 }
3570
3571
3572
3573
3574 public static _Fields findByName(String name) {
3575 return byName.get(name);
3576 }
3577
3578 private final short _thriftId;
3579 private final String _fieldName;
3580
3581 _Fields(short thriftId, String fieldName) {
3582 _thriftId = thriftId;
3583 _fieldName = fieldName;
3584 }
3585
3586 public short getThriftFieldId() {
3587 return _thriftId;
3588 }
3589
3590 public String getFieldName() {
3591 return _fieldName;
3592 }
3593 }
3594
3595
3596 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3597 static {
3598 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3599 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
3600 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
3601 tmpMap.put(_Fields.GETS, new org.apache.thrift.meta_data.FieldMetaData("gets", org.apache.thrift.TFieldRequirementType.REQUIRED,
3602 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
3603 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class))));
3604 metaDataMap = Collections.unmodifiableMap(tmpMap);
3605 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_args.class, metaDataMap);
3606 }
3607
3608 public getMultiple_args() {
3609 }
3610
3611 public getMultiple_args(
3612 ByteBuffer table,
3613 List<TGet> gets)
3614 {
3615 this();
3616 this.table = table;
3617 this.gets = gets;
3618 }
3619
3620
3621
3622
3623 public getMultiple_args(getMultiple_args other) {
3624 if (other.isSetTable()) {
3625 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
3626 ;
3627 }
3628 if (other.isSetGets()) {
3629 List<TGet> __this__gets = new ArrayList<TGet>();
3630 for (TGet other_element : other.gets) {
3631 __this__gets.add(new TGet(other_element));
3632 }
3633 this.gets = __this__gets;
3634 }
3635 }
3636
3637 public getMultiple_args deepCopy() {
3638 return new getMultiple_args(this);
3639 }
3640
3641 @Override
3642 public void clear() {
3643 this.table = null;
3644 this.gets = null;
3645 }
3646
3647
3648
3649
3650 public byte[] getTable() {
3651 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
3652 return table == null ? null : table.array();
3653 }
3654
3655 public ByteBuffer bufferForTable() {
3656 return table;
3657 }
3658
3659
3660
3661
3662 public getMultiple_args setTable(byte[] table) {
3663 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
3664 return this;
3665 }
3666
3667 public getMultiple_args setTable(ByteBuffer table) {
3668 this.table = table;
3669 return this;
3670 }
3671
3672 public void unsetTable() {
3673 this.table = null;
3674 }
3675
3676
3677 public boolean isSetTable() {
3678 return this.table != null;
3679 }
3680
3681 public void setTableIsSet(boolean value) {
3682 if (!value) {
3683 this.table = null;
3684 }
3685 }
3686
3687 public int getGetsSize() {
3688 return (this.gets == null) ? 0 : this.gets.size();
3689 }
3690
3691 public java.util.Iterator<TGet> getGetsIterator() {
3692 return (this.gets == null) ? null : this.gets.iterator();
3693 }
3694
3695 public void addToGets(TGet elem) {
3696 if (this.gets == null) {
3697 this.gets = new ArrayList<TGet>();
3698 }
3699 this.gets.add(elem);
3700 }
3701
3702
3703
3704
3705
3706
3707 public List<TGet> getGets() {
3708 return this.gets;
3709 }
3710
3711
3712
3713
3714
3715
3716 public getMultiple_args setGets(List<TGet> gets) {
3717 this.gets = gets;
3718 return this;
3719 }
3720
3721 public void unsetGets() {
3722 this.gets = null;
3723 }
3724
3725
3726 public boolean isSetGets() {
3727 return this.gets != null;
3728 }
3729
3730 public void setGetsIsSet(boolean value) {
3731 if (!value) {
3732 this.gets = null;
3733 }
3734 }
3735
3736 public void setFieldValue(_Fields field, Object value) {
3737 switch (field) {
3738 case TABLE:
3739 if (value == null) {
3740 unsetTable();
3741 } else {
3742 setTable((ByteBuffer)value);
3743 }
3744 break;
3745
3746 case GETS:
3747 if (value == null) {
3748 unsetGets();
3749 } else {
3750 setGets((List<TGet>)value);
3751 }
3752 break;
3753
3754 }
3755 }
3756
3757 public Object getFieldValue(_Fields field) {
3758 switch (field) {
3759 case TABLE:
3760 return getTable();
3761
3762 case GETS:
3763 return getGets();
3764
3765 }
3766 throw new IllegalStateException();
3767 }
3768
3769
3770 public boolean isSet(_Fields field) {
3771 if (field == null) {
3772 throw new IllegalArgumentException();
3773 }
3774
3775 switch (field) {
3776 case TABLE:
3777 return isSetTable();
3778 case GETS:
3779 return isSetGets();
3780 }
3781 throw new IllegalStateException();
3782 }
3783
3784 @Override
3785 public boolean equals(Object that) {
3786 if (that == null)
3787 return false;
3788 if (that instanceof getMultiple_args)
3789 return this.equals((getMultiple_args)that);
3790 return false;
3791 }
3792
3793 public boolean equals(getMultiple_args that) {
3794 if (that == null)
3795 return false;
3796
3797 boolean this_present_table = true && this.isSetTable();
3798 boolean that_present_table = true && that.isSetTable();
3799 if (this_present_table || that_present_table) {
3800 if (!(this_present_table && that_present_table))
3801 return false;
3802 if (!this.table.equals(that.table))
3803 return false;
3804 }
3805
3806 boolean this_present_gets = true && this.isSetGets();
3807 boolean that_present_gets = true && that.isSetGets();
3808 if (this_present_gets || that_present_gets) {
3809 if (!(this_present_gets && that_present_gets))
3810 return false;
3811 if (!this.gets.equals(that.gets))
3812 return false;
3813 }
3814
3815 return true;
3816 }
3817
3818 @Override
3819 public int hashCode() {
3820 HashCodeBuilder builder = new HashCodeBuilder();
3821
3822 boolean present_table = true && (isSetTable());
3823 builder.append(present_table);
3824 if (present_table)
3825 builder.append(table);
3826
3827 boolean present_gets = true && (isSetGets());
3828 builder.append(present_gets);
3829 if (present_gets)
3830 builder.append(gets);
3831
3832 return builder.toHashCode();
3833 }
3834
3835 public int compareTo(getMultiple_args other) {
3836 if (!getClass().equals(other.getClass())) {
3837 return getClass().getName().compareTo(other.getClass().getName());
3838 }
3839
3840 int lastComparison = 0;
3841 getMultiple_args typedOther = (getMultiple_args)other;
3842
3843 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
3844 if (lastComparison != 0) {
3845 return lastComparison;
3846 }
3847 if (isSetTable()) {
3848 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
3849 if (lastComparison != 0) {
3850 return lastComparison;
3851 }
3852 }
3853 lastComparison = Boolean.valueOf(isSetGets()).compareTo(typedOther.isSetGets());
3854 if (lastComparison != 0) {
3855 return lastComparison;
3856 }
3857 if (isSetGets()) {
3858 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gets, typedOther.gets);
3859 if (lastComparison != 0) {
3860 return lastComparison;
3861 }
3862 }
3863 return 0;
3864 }
3865
3866 public _Fields fieldForId(int fieldId) {
3867 return _Fields.findByThriftId(fieldId);
3868 }
3869
3870 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3871 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3872 }
3873
3874 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3875 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3876 }
3877
3878 @Override
3879 public String toString() {
3880 StringBuilder sb = new StringBuilder("getMultiple_args(");
3881 boolean first = true;
3882
3883 sb.append("table:");
3884 if (this.table == null) {
3885 sb.append("null");
3886 } else {
3887 org.apache.thrift.TBaseHelper.toString(this.table, sb);
3888 }
3889 first = false;
3890 if (!first) sb.append(", ");
3891 sb.append("gets:");
3892 if (this.gets == null) {
3893 sb.append("null");
3894 } else {
3895 sb.append(this.gets);
3896 }
3897 first = false;
3898 sb.append(")");
3899 return sb.toString();
3900 }
3901
3902 public void validate() throws org.apache.thrift.TException {
3903
3904 if (table == null) {
3905 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
3906 }
3907 if (gets == null) {
3908 throw new org.apache.thrift.protocol.TProtocolException("Required field 'gets' was not present! Struct: " + toString());
3909 }
3910 }
3911
3912 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3913 try {
3914 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3915 } catch (org.apache.thrift.TException te) {
3916 throw new java.io.IOException(te);
3917 }
3918 }
3919
3920 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3921 try {
3922 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3923 } catch (org.apache.thrift.TException te) {
3924 throw new java.io.IOException(te);
3925 }
3926 }
3927
3928 private static class getMultiple_argsStandardSchemeFactory implements SchemeFactory {
3929 public getMultiple_argsStandardScheme getScheme() {
3930 return new getMultiple_argsStandardScheme();
3931 }
3932 }
3933
3934 private static class getMultiple_argsStandardScheme extends StandardScheme<getMultiple_args> {
3935
3936 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_args struct) throws org.apache.thrift.TException {
3937 org.apache.thrift.protocol.TField schemeField;
3938 iprot.readStructBegin();
3939 while (true)
3940 {
3941 schemeField = iprot.readFieldBegin();
3942 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3943 break;
3944 }
3945 switch (schemeField.id) {
3946 case 1:
3947 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
3948 struct.table = iprot.readBinary();
3949 struct.setTableIsSet(true);
3950 } else {
3951 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3952 }
3953 break;
3954 case 2:
3955 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
3956 {
3957 org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
3958 struct.gets = new ArrayList<TGet>(_list96.size);
3959 for (int _i97 = 0; _i97 < _list96.size; ++_i97)
3960 {
3961 TGet _elem98;
3962 _elem98 = new TGet();
3963 _elem98.read(iprot);
3964 struct.gets.add(_elem98);
3965 }
3966 iprot.readListEnd();
3967 }
3968 struct.setGetsIsSet(true);
3969 } else {
3970 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3971 }
3972 break;
3973 default:
3974 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3975 }
3976 iprot.readFieldEnd();
3977 }
3978 iprot.readStructEnd();
3979
3980
3981 struct.validate();
3982 }
3983
3984 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_args struct) throws org.apache.thrift.TException {
3985 struct.validate();
3986
3987 oprot.writeStructBegin(STRUCT_DESC);
3988 if (struct.table != null) {
3989 oprot.writeFieldBegin(TABLE_FIELD_DESC);
3990 oprot.writeBinary(struct.table);
3991 oprot.writeFieldEnd();
3992 }
3993 if (struct.gets != null) {
3994 oprot.writeFieldBegin(GETS_FIELD_DESC);
3995 {
3996 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.gets.size()));
3997 for (TGet _iter99 : struct.gets)
3998 {
3999 _iter99.write(oprot);
4000 }
4001 oprot.writeListEnd();
4002 }
4003 oprot.writeFieldEnd();
4004 }
4005 oprot.writeFieldStop();
4006 oprot.writeStructEnd();
4007 }
4008
4009 }
4010
4011 private static class getMultiple_argsTupleSchemeFactory implements SchemeFactory {
4012 public getMultiple_argsTupleScheme getScheme() {
4013 return new getMultiple_argsTupleScheme();
4014 }
4015 }
4016
4017 private static class getMultiple_argsTupleScheme extends TupleScheme<getMultiple_args> {
4018
4019 @Override
4020 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
4021 TTupleProtocol oprot = (TTupleProtocol) prot;
4022 oprot.writeBinary(struct.table);
4023 {
4024 oprot.writeI32(struct.gets.size());
4025 for (TGet _iter100 : struct.gets)
4026 {
4027 _iter100.write(oprot);
4028 }
4029 }
4030 }
4031
4032 @Override
4033 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
4034 TTupleProtocol iprot = (TTupleProtocol) prot;
4035 struct.table = iprot.readBinary();
4036 struct.setTableIsSet(true);
4037 {
4038 org.apache.thrift.protocol.TList _list101 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
4039 struct.gets = new ArrayList<TGet>(_list101.size);
4040 for (int _i102 = 0; _i102 < _list101.size; ++_i102)
4041 {
4042 TGet _elem103;
4043 _elem103 = new TGet();
4044 _elem103.read(iprot);
4045 struct.gets.add(_elem103);
4046 }
4047 }
4048 struct.setGetsIsSet(true);
4049 }
4050 }
4051
4052 }
4053
4054 public static class getMultiple_result implements org.apache.thrift.TBase<getMultiple_result, getMultiple_result._Fields>, java.io.Serializable, Cloneable {
4055 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_result");
4056
4057 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
4058 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
4059
4060 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4061 static {
4062 schemes.put(StandardScheme.class, new getMultiple_resultStandardSchemeFactory());
4063 schemes.put(TupleScheme.class, new getMultiple_resultTupleSchemeFactory());
4064 }
4065
4066 public List<TResult> success;
4067 public TIOError io;
4068
4069
4070 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4071 SUCCESS((short)0, "success"),
4072 IO((short)1, "io");
4073
4074 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4075
4076 static {
4077 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4078 byName.put(field.getFieldName(), field);
4079 }
4080 }
4081
4082
4083
4084
4085 public static _Fields findByThriftId(int fieldId) {
4086 switch(fieldId) {
4087 case 0:
4088 return SUCCESS;
4089 case 1:
4090 return IO;
4091 default:
4092 return null;
4093 }
4094 }
4095
4096
4097
4098
4099
4100 public static _Fields findByThriftIdOrThrow(int fieldId) {
4101 _Fields fields = findByThriftId(fieldId);
4102 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4103 return fields;
4104 }
4105
4106
4107
4108
4109 public static _Fields findByName(String name) {
4110 return byName.get(name);
4111 }
4112
4113 private final short _thriftId;
4114 private final String _fieldName;
4115
4116 _Fields(short thriftId, String fieldName) {
4117 _thriftId = thriftId;
4118 _fieldName = fieldName;
4119 }
4120
4121 public short getThriftFieldId() {
4122 return _thriftId;
4123 }
4124
4125 public String getFieldName() {
4126 return _fieldName;
4127 }
4128 }
4129
4130
4131 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4132 static {
4133 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4134 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
4135 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
4136 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
4137 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
4138 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
4139 metaDataMap = Collections.unmodifiableMap(tmpMap);
4140 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_result.class, metaDataMap);
4141 }
4142
4143 public getMultiple_result() {
4144 }
4145
4146 public getMultiple_result(
4147 List<TResult> success,
4148 TIOError io)
4149 {
4150 this();
4151 this.success = success;
4152 this.io = io;
4153 }
4154
4155
4156
4157
4158 public getMultiple_result(getMultiple_result other) {
4159 if (other.isSetSuccess()) {
4160 List<TResult> __this__success = new ArrayList<TResult>();
4161 for (TResult other_element : other.success) {
4162 __this__success.add(new TResult(other_element));
4163 }
4164 this.success = __this__success;
4165 }
4166 if (other.isSetIo()) {
4167 this.io = new TIOError(other.io);
4168 }
4169 }
4170
4171 public getMultiple_result deepCopy() {
4172 return new getMultiple_result(this);
4173 }
4174
4175 @Override
4176 public void clear() {
4177 this.success = null;
4178 this.io = null;
4179 }
4180
4181 public int getSuccessSize() {
4182 return (this.success == null) ? 0 : this.success.size();
4183 }
4184
4185 public java.util.Iterator<TResult> getSuccessIterator() {
4186 return (this.success == null) ? null : this.success.iterator();
4187 }
4188
4189 public void addToSuccess(TResult elem) {
4190 if (this.success == null) {
4191 this.success = new ArrayList<TResult>();
4192 }
4193 this.success.add(elem);
4194 }
4195
4196 public List<TResult> getSuccess() {
4197 return this.success;
4198 }
4199
4200 public getMultiple_result setSuccess(List<TResult> success) {
4201 this.success = success;
4202 return this;
4203 }
4204
4205 public void unsetSuccess() {
4206 this.success = null;
4207 }
4208
4209
4210 public boolean isSetSuccess() {
4211 return this.success != null;
4212 }
4213
4214 public void setSuccessIsSet(boolean value) {
4215 if (!value) {
4216 this.success = null;
4217 }
4218 }
4219
4220 public TIOError getIo() {
4221 return this.io;
4222 }
4223
4224 public getMultiple_result setIo(TIOError io) {
4225 this.io = io;
4226 return this;
4227 }
4228
4229 public void unsetIo() {
4230 this.io = null;
4231 }
4232
4233
4234 public boolean isSetIo() {
4235 return this.io != null;
4236 }
4237
4238 public void setIoIsSet(boolean value) {
4239 if (!value) {
4240 this.io = null;
4241 }
4242 }
4243
4244 public void setFieldValue(_Fields field, Object value) {
4245 switch (field) {
4246 case SUCCESS:
4247 if (value == null) {
4248 unsetSuccess();
4249 } else {
4250 setSuccess((List<TResult>)value);
4251 }
4252 break;
4253
4254 case IO:
4255 if (value == null) {
4256 unsetIo();
4257 } else {
4258 setIo((TIOError)value);
4259 }
4260 break;
4261
4262 }
4263 }
4264
4265 public Object getFieldValue(_Fields field) {
4266 switch (field) {
4267 case SUCCESS:
4268 return getSuccess();
4269
4270 case IO:
4271 return getIo();
4272
4273 }
4274 throw new IllegalStateException();
4275 }
4276
4277
4278 public boolean isSet(_Fields field) {
4279 if (field == null) {
4280 throw new IllegalArgumentException();
4281 }
4282
4283 switch (field) {
4284 case SUCCESS:
4285 return isSetSuccess();
4286 case IO:
4287 return isSetIo();
4288 }
4289 throw new IllegalStateException();
4290 }
4291
4292 @Override
4293 public boolean equals(Object that) {
4294 if (that == null)
4295 return false;
4296 if (that instanceof getMultiple_result)
4297 return this.equals((getMultiple_result)that);
4298 return false;
4299 }
4300
4301 public boolean equals(getMultiple_result that) {
4302 if (that == null)
4303 return false;
4304
4305 boolean this_present_success = true && this.isSetSuccess();
4306 boolean that_present_success = true && that.isSetSuccess();
4307 if (this_present_success || that_present_success) {
4308 if (!(this_present_success && that_present_success))
4309 return false;
4310 if (!this.success.equals(that.success))
4311 return false;
4312 }
4313
4314 boolean this_present_io = true && this.isSetIo();
4315 boolean that_present_io = true && that.isSetIo();
4316 if (this_present_io || that_present_io) {
4317 if (!(this_present_io && that_present_io))
4318 return false;
4319 if (!this.io.equals(that.io))
4320 return false;
4321 }
4322
4323 return true;
4324 }
4325
4326 @Override
4327 public int hashCode() {
4328 HashCodeBuilder builder = new HashCodeBuilder();
4329
4330 boolean present_success = true && (isSetSuccess());
4331 builder.append(present_success);
4332 if (present_success)
4333 builder.append(success);
4334
4335 boolean present_io = true && (isSetIo());
4336 builder.append(present_io);
4337 if (present_io)
4338 builder.append(io);
4339
4340 return builder.toHashCode();
4341 }
4342
4343 public int compareTo(getMultiple_result other) {
4344 if (!getClass().equals(other.getClass())) {
4345 return getClass().getName().compareTo(other.getClass().getName());
4346 }
4347
4348 int lastComparison = 0;
4349 getMultiple_result typedOther = (getMultiple_result)other;
4350
4351 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
4352 if (lastComparison != 0) {
4353 return lastComparison;
4354 }
4355 if (isSetSuccess()) {
4356 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
4357 if (lastComparison != 0) {
4358 return lastComparison;
4359 }
4360 }
4361 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
4362 if (lastComparison != 0) {
4363 return lastComparison;
4364 }
4365 if (isSetIo()) {
4366 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
4367 if (lastComparison != 0) {
4368 return lastComparison;
4369 }
4370 }
4371 return 0;
4372 }
4373
4374 public _Fields fieldForId(int fieldId) {
4375 return _Fields.findByThriftId(fieldId);
4376 }
4377
4378 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4379 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4380 }
4381
4382 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4383 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4384 }
4385
4386 @Override
4387 public String toString() {
4388 StringBuilder sb = new StringBuilder("getMultiple_result(");
4389 boolean first = true;
4390
4391 sb.append("success:");
4392 if (this.success == null) {
4393 sb.append("null");
4394 } else {
4395 sb.append(this.success);
4396 }
4397 first = false;
4398 if (!first) sb.append(", ");
4399 sb.append("io:");
4400 if (this.io == null) {
4401 sb.append("null");
4402 } else {
4403 sb.append(this.io);
4404 }
4405 first = false;
4406 sb.append(")");
4407 return sb.toString();
4408 }
4409
4410 public void validate() throws org.apache.thrift.TException {
4411
4412 }
4413
4414 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4415 try {
4416 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4417 } catch (org.apache.thrift.TException te) {
4418 throw new java.io.IOException(te);
4419 }
4420 }
4421
4422 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4423 try {
4424 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4425 } catch (org.apache.thrift.TException te) {
4426 throw new java.io.IOException(te);
4427 }
4428 }
4429
4430 private static class getMultiple_resultStandardSchemeFactory implements SchemeFactory {
4431 public getMultiple_resultStandardScheme getScheme() {
4432 return new getMultiple_resultStandardScheme();
4433 }
4434 }
4435
4436 private static class getMultiple_resultStandardScheme extends StandardScheme<getMultiple_result> {
4437
4438 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_result struct) throws org.apache.thrift.TException {
4439 org.apache.thrift.protocol.TField schemeField;
4440 iprot.readStructBegin();
4441 while (true)
4442 {
4443 schemeField = iprot.readFieldBegin();
4444 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4445 break;
4446 }
4447 switch (schemeField.id) {
4448 case 0:
4449 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
4450 {
4451 org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();
4452 struct.success = new ArrayList<TResult>(_list104.size);
4453 for (int _i105 = 0; _i105 < _list104.size; ++_i105)
4454 {
4455 TResult _elem106;
4456 _elem106 = new TResult();
4457 _elem106.read(iprot);
4458 struct.success.add(_elem106);
4459 }
4460 iprot.readListEnd();
4461 }
4462 struct.setSuccessIsSet(true);
4463 } else {
4464 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4465 }
4466 break;
4467 case 1:
4468 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4469 struct.io = new TIOError();
4470 struct.io.read(iprot);
4471 struct.setIoIsSet(true);
4472 } else {
4473 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4474 }
4475 break;
4476 default:
4477 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4478 }
4479 iprot.readFieldEnd();
4480 }
4481 iprot.readStructEnd();
4482
4483
4484 struct.validate();
4485 }
4486
4487 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_result struct) throws org.apache.thrift.TException {
4488 struct.validate();
4489
4490 oprot.writeStructBegin(STRUCT_DESC);
4491 if (struct.success != null) {
4492 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4493 {
4494 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
4495 for (TResult _iter107 : struct.success)
4496 {
4497 _iter107.write(oprot);
4498 }
4499 oprot.writeListEnd();
4500 }
4501 oprot.writeFieldEnd();
4502 }
4503 if (struct.io != null) {
4504 oprot.writeFieldBegin(IO_FIELD_DESC);
4505 struct.io.write(oprot);
4506 oprot.writeFieldEnd();
4507 }
4508 oprot.writeFieldStop();
4509 oprot.writeStructEnd();
4510 }
4511
4512 }
4513
4514 private static class getMultiple_resultTupleSchemeFactory implements SchemeFactory {
4515 public getMultiple_resultTupleScheme getScheme() {
4516 return new getMultiple_resultTupleScheme();
4517 }
4518 }
4519
4520 private static class getMultiple_resultTupleScheme extends TupleScheme<getMultiple_result> {
4521
4522 @Override
4523 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4524 TTupleProtocol oprot = (TTupleProtocol) prot;
4525 BitSet optionals = new BitSet();
4526 if (struct.isSetSuccess()) {
4527 optionals.set(0);
4528 }
4529 if (struct.isSetIo()) {
4530 optionals.set(1);
4531 }
4532 oprot.writeBitSet(optionals, 2);
4533 if (struct.isSetSuccess()) {
4534 {
4535 oprot.writeI32(struct.success.size());
4536 for (TResult _iter108 : struct.success)
4537 {
4538 _iter108.write(oprot);
4539 }
4540 }
4541 }
4542 if (struct.isSetIo()) {
4543 struct.io.write(oprot);
4544 }
4545 }
4546
4547 @Override
4548 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4549 TTupleProtocol iprot = (TTupleProtocol) prot;
4550 BitSet incoming = iprot.readBitSet(2);
4551 if (incoming.get(0)) {
4552 {
4553 org.apache.thrift.protocol.TList _list109 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
4554 struct.success = new ArrayList<TResult>(_list109.size);
4555 for (int _i110 = 0; _i110 < _list109.size; ++_i110)
4556 {
4557 TResult _elem111;
4558 _elem111 = new TResult();
4559 _elem111.read(iprot);
4560 struct.success.add(_elem111);
4561 }
4562 }
4563 struct.setSuccessIsSet(true);
4564 }
4565 if (incoming.get(1)) {
4566 struct.io = new TIOError();
4567 struct.io.read(iprot);
4568 struct.setIoIsSet(true);
4569 }
4570 }
4571 }
4572
4573 }
4574
4575 public static class put_args implements org.apache.thrift.TBase<put_args, put_args._Fields>, java.io.Serializable, Cloneable {
4576 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_args");
4577
4578 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
4579 private static final org.apache.thrift.protocol.TField PUT_FIELD_DESC = new org.apache.thrift.protocol.TField("put", org.apache.thrift.protocol.TType.STRUCT, (short)2);
4580
4581 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4582 static {
4583 schemes.put(StandardScheme.class, new put_argsStandardSchemeFactory());
4584 schemes.put(TupleScheme.class, new put_argsTupleSchemeFactory());
4585 }
4586
4587
4588
4589
4590 public ByteBuffer table;
4591
4592
4593
4594 public TPut put;
4595
4596
4597 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4598
4599
4600
4601 TABLE((short)1, "table"),
4602
4603
4604
4605 PUT((short)2, "put");
4606
4607 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4608
4609 static {
4610 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4611 byName.put(field.getFieldName(), field);
4612 }
4613 }
4614
4615
4616
4617
4618 public static _Fields findByThriftId(int fieldId) {
4619 switch(fieldId) {
4620 case 1:
4621 return TABLE;
4622 case 2:
4623 return PUT;
4624 default:
4625 return null;
4626 }
4627 }
4628
4629
4630
4631
4632
4633 public static _Fields findByThriftIdOrThrow(int fieldId) {
4634 _Fields fields = findByThriftId(fieldId);
4635 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4636 return fields;
4637 }
4638
4639
4640
4641
4642 public static _Fields findByName(String name) {
4643 return byName.get(name);
4644 }
4645
4646 private final short _thriftId;
4647 private final String _fieldName;
4648
4649 _Fields(short thriftId, String fieldName) {
4650 _thriftId = thriftId;
4651 _fieldName = fieldName;
4652 }
4653
4654 public short getThriftFieldId() {
4655 return _thriftId;
4656 }
4657
4658 public String getFieldName() {
4659 return _fieldName;
4660 }
4661 }
4662
4663
4664 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4665 static {
4666 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4667 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
4668 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
4669 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
4670 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
4671 metaDataMap = Collections.unmodifiableMap(tmpMap);
4672 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_args.class, metaDataMap);
4673 }
4674
4675 public put_args() {
4676 }
4677
4678 public put_args(
4679 ByteBuffer table,
4680 TPut put)
4681 {
4682 this();
4683 this.table = table;
4684 this.put = put;
4685 }
4686
4687
4688
4689
4690 public put_args(put_args other) {
4691 if (other.isSetTable()) {
4692 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
4693 ;
4694 }
4695 if (other.isSetPut()) {
4696 this.put = new TPut(other.put);
4697 }
4698 }
4699
4700 public put_args deepCopy() {
4701 return new put_args(this);
4702 }
4703
4704 @Override
4705 public void clear() {
4706 this.table = null;
4707 this.put = null;
4708 }
4709
4710
4711
4712
4713 public byte[] getTable() {
4714 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
4715 return table == null ? null : table.array();
4716 }
4717
4718 public ByteBuffer bufferForTable() {
4719 return table;
4720 }
4721
4722
4723
4724
4725 public put_args setTable(byte[] table) {
4726 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
4727 return this;
4728 }
4729
4730 public put_args setTable(ByteBuffer table) {
4731 this.table = table;
4732 return this;
4733 }
4734
4735 public void unsetTable() {
4736 this.table = null;
4737 }
4738
4739
4740 public boolean isSetTable() {
4741 return this.table != null;
4742 }
4743
4744 public void setTableIsSet(boolean value) {
4745 if (!value) {
4746 this.table = null;
4747 }
4748 }
4749
4750
4751
4752
4753 public TPut getPut() {
4754 return this.put;
4755 }
4756
4757
4758
4759
4760 public put_args setPut(TPut put) {
4761 this.put = put;
4762 return this;
4763 }
4764
4765 public void unsetPut() {
4766 this.put = null;
4767 }
4768
4769
4770 public boolean isSetPut() {
4771 return this.put != null;
4772 }
4773
4774 public void setPutIsSet(boolean value) {
4775 if (!value) {
4776 this.put = null;
4777 }
4778 }
4779
4780 public void setFieldValue(_Fields field, Object value) {
4781 switch (field) {
4782 case TABLE:
4783 if (value == null) {
4784 unsetTable();
4785 } else {
4786 setTable((ByteBuffer)value);
4787 }
4788 break;
4789
4790 case PUT:
4791 if (value == null) {
4792 unsetPut();
4793 } else {
4794 setPut((TPut)value);
4795 }
4796 break;
4797
4798 }
4799 }
4800
4801 public Object getFieldValue(_Fields field) {
4802 switch (field) {
4803 case TABLE:
4804 return getTable();
4805
4806 case PUT:
4807 return getPut();
4808
4809 }
4810 throw new IllegalStateException();
4811 }
4812
4813
4814 public boolean isSet(_Fields field) {
4815 if (field == null) {
4816 throw new IllegalArgumentException();
4817 }
4818
4819 switch (field) {
4820 case TABLE:
4821 return isSetTable();
4822 case PUT:
4823 return isSetPut();
4824 }
4825 throw new IllegalStateException();
4826 }
4827
4828 @Override
4829 public boolean equals(Object that) {
4830 if (that == null)
4831 return false;
4832 if (that instanceof put_args)
4833 return this.equals((put_args)that);
4834 return false;
4835 }
4836
4837 public boolean equals(put_args that) {
4838 if (that == null)
4839 return false;
4840
4841 boolean this_present_table = true && this.isSetTable();
4842 boolean that_present_table = true && that.isSetTable();
4843 if (this_present_table || that_present_table) {
4844 if (!(this_present_table && that_present_table))
4845 return false;
4846 if (!this.table.equals(that.table))
4847 return false;
4848 }
4849
4850 boolean this_present_put = true && this.isSetPut();
4851 boolean that_present_put = true && that.isSetPut();
4852 if (this_present_put || that_present_put) {
4853 if (!(this_present_put && that_present_put))
4854 return false;
4855 if (!this.put.equals(that.put))
4856 return false;
4857 }
4858
4859 return true;
4860 }
4861
4862 @Override
4863 public int hashCode() {
4864 HashCodeBuilder builder = new HashCodeBuilder();
4865
4866 boolean present_table = true && (isSetTable());
4867 builder.append(present_table);
4868 if (present_table)
4869 builder.append(table);
4870
4871 boolean present_put = true && (isSetPut());
4872 builder.append(present_put);
4873 if (present_put)
4874 builder.append(put);
4875
4876 return builder.toHashCode();
4877 }
4878
4879 public int compareTo(put_args other) {
4880 if (!getClass().equals(other.getClass())) {
4881 return getClass().getName().compareTo(other.getClass().getName());
4882 }
4883
4884 int lastComparison = 0;
4885 put_args typedOther = (put_args)other;
4886
4887 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
4888 if (lastComparison != 0) {
4889 return lastComparison;
4890 }
4891 if (isSetTable()) {
4892 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
4893 if (lastComparison != 0) {
4894 return lastComparison;
4895 }
4896 }
4897 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
4898 if (lastComparison != 0) {
4899 return lastComparison;
4900 }
4901 if (isSetPut()) {
4902 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
4903 if (lastComparison != 0) {
4904 return lastComparison;
4905 }
4906 }
4907 return 0;
4908 }
4909
4910 public _Fields fieldForId(int fieldId) {
4911 return _Fields.findByThriftId(fieldId);
4912 }
4913
4914 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4915 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4916 }
4917
4918 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4919 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4920 }
4921
4922 @Override
4923 public String toString() {
4924 StringBuilder sb = new StringBuilder("put_args(");
4925 boolean first = true;
4926
4927 sb.append("table:");
4928 if (this.table == null) {
4929 sb.append("null");
4930 } else {
4931 org.apache.thrift.TBaseHelper.toString(this.table, sb);
4932 }
4933 first = false;
4934 if (!first) sb.append(", ");
4935 sb.append("put:");
4936 if (this.put == null) {
4937 sb.append("null");
4938 } else {
4939 sb.append(this.put);
4940 }
4941 first = false;
4942 sb.append(")");
4943 return sb.toString();
4944 }
4945
4946 public void validate() throws org.apache.thrift.TException {
4947
4948 if (table == null) {
4949 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
4950 }
4951 if (put == null) {
4952 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
4953 }
4954 }
4955
4956 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4957 try {
4958 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4959 } catch (org.apache.thrift.TException te) {
4960 throw new java.io.IOException(te);
4961 }
4962 }
4963
4964 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4965 try {
4966 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4967 } catch (org.apache.thrift.TException te) {
4968 throw new java.io.IOException(te);
4969 }
4970 }
4971
4972 private static class put_argsStandardSchemeFactory implements SchemeFactory {
4973 public put_argsStandardScheme getScheme() {
4974 return new put_argsStandardScheme();
4975 }
4976 }
4977
4978 private static class put_argsStandardScheme extends StandardScheme<put_args> {
4979
4980 public void read(org.apache.thrift.protocol.TProtocol iprot, put_args struct) throws org.apache.thrift.TException {
4981 org.apache.thrift.protocol.TField schemeField;
4982 iprot.readStructBegin();
4983 while (true)
4984 {
4985 schemeField = iprot.readFieldBegin();
4986 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4987 break;
4988 }
4989 switch (schemeField.id) {
4990 case 1:
4991 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
4992 struct.table = iprot.readBinary();
4993 struct.setTableIsSet(true);
4994 } else {
4995 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4996 }
4997 break;
4998 case 2:
4999 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
5000 struct.put = new TPut();
5001 struct.put.read(iprot);
5002 struct.setPutIsSet(true);
5003 } else {
5004 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5005 }
5006 break;
5007 default:
5008 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5009 }
5010 iprot.readFieldEnd();
5011 }
5012 iprot.readStructEnd();
5013
5014
5015 struct.validate();
5016 }
5017
5018 public void write(org.apache.thrift.protocol.TProtocol oprot, put_args struct) throws org.apache.thrift.TException {
5019 struct.validate();
5020
5021 oprot.writeStructBegin(STRUCT_DESC);
5022 if (struct.table != null) {
5023 oprot.writeFieldBegin(TABLE_FIELD_DESC);
5024 oprot.writeBinary(struct.table);
5025 oprot.writeFieldEnd();
5026 }
5027 if (struct.put != null) {
5028 oprot.writeFieldBegin(PUT_FIELD_DESC);
5029 struct.put.write(oprot);
5030 oprot.writeFieldEnd();
5031 }
5032 oprot.writeFieldStop();
5033 oprot.writeStructEnd();
5034 }
5035
5036 }
5037
5038 private static class put_argsTupleSchemeFactory implements SchemeFactory {
5039 public put_argsTupleScheme getScheme() {
5040 return new put_argsTupleScheme();
5041 }
5042 }
5043
5044 private static class put_argsTupleScheme extends TupleScheme<put_args> {
5045
5046 @Override
5047 public void write(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
5048 TTupleProtocol oprot = (TTupleProtocol) prot;
5049 oprot.writeBinary(struct.table);
5050 struct.put.write(oprot);
5051 }
5052
5053 @Override
5054 public void read(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
5055 TTupleProtocol iprot = (TTupleProtocol) prot;
5056 struct.table = iprot.readBinary();
5057 struct.setTableIsSet(true);
5058 struct.put = new TPut();
5059 struct.put.read(iprot);
5060 struct.setPutIsSet(true);
5061 }
5062 }
5063
5064 }
5065
5066 public static class put_result implements org.apache.thrift.TBase<put_result, put_result._Fields>, java.io.Serializable, Cloneable {
5067 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_result");
5068
5069 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
5070
5071 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
5072 static {
5073 schemes.put(StandardScheme.class, new put_resultStandardSchemeFactory());
5074 schemes.put(TupleScheme.class, new put_resultTupleSchemeFactory());
5075 }
5076
5077 public TIOError io;
5078
5079
5080 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
5081 IO((short)1, "io");
5082
5083 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5084
5085 static {
5086 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5087 byName.put(field.getFieldName(), field);
5088 }
5089 }
5090
5091
5092
5093
5094 public static _Fields findByThriftId(int fieldId) {
5095 switch(fieldId) {
5096 case 1:
5097 return IO;
5098 default:
5099 return null;
5100 }
5101 }
5102
5103
5104
5105
5106
5107 public static _Fields findByThriftIdOrThrow(int fieldId) {
5108 _Fields fields = findByThriftId(fieldId);
5109 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5110 return fields;
5111 }
5112
5113
5114
5115
5116 public static _Fields findByName(String name) {
5117 return byName.get(name);
5118 }
5119
5120 private final short _thriftId;
5121 private final String _fieldName;
5122
5123 _Fields(short thriftId, String fieldName) {
5124 _thriftId = thriftId;
5125 _fieldName = fieldName;
5126 }
5127
5128 public short getThriftFieldId() {
5129 return _thriftId;
5130 }
5131
5132 public String getFieldName() {
5133 return _fieldName;
5134 }
5135 }
5136
5137
5138 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
5139 static {
5140 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
5141 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
5142 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
5143 metaDataMap = Collections.unmodifiableMap(tmpMap);
5144 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_result.class, metaDataMap);
5145 }
5146
5147 public put_result() {
5148 }
5149
5150 public put_result(
5151 TIOError io)
5152 {
5153 this();
5154 this.io = io;
5155 }
5156
5157
5158
5159
5160 public put_result(put_result other) {
5161 if (other.isSetIo()) {
5162 this.io = new TIOError(other.io);
5163 }
5164 }
5165
5166 public put_result deepCopy() {
5167 return new put_result(this);
5168 }
5169
5170 @Override
5171 public void clear() {
5172 this.io = null;
5173 }
5174
5175 public TIOError getIo() {
5176 return this.io;
5177 }
5178
5179 public put_result setIo(TIOError io) {
5180 this.io = io;
5181 return this;
5182 }
5183
5184 public void unsetIo() {
5185 this.io = null;
5186 }
5187
5188
5189 public boolean isSetIo() {
5190 return this.io != null;
5191 }
5192
5193 public void setIoIsSet(boolean value) {
5194 if (!value) {
5195 this.io = null;
5196 }
5197 }
5198
5199 public void setFieldValue(_Fields field, Object value) {
5200 switch (field) {
5201 case IO:
5202 if (value == null) {
5203 unsetIo();
5204 } else {
5205 setIo((TIOError)value);
5206 }
5207 break;
5208
5209 }
5210 }
5211
5212 public Object getFieldValue(_Fields field) {
5213 switch (field) {
5214 case IO:
5215 return getIo();
5216
5217 }
5218 throw new IllegalStateException();
5219 }
5220
5221
5222 public boolean isSet(_Fields field) {
5223 if (field == null) {
5224 throw new IllegalArgumentException();
5225 }
5226
5227 switch (field) {
5228 case IO:
5229 return isSetIo();
5230 }
5231 throw new IllegalStateException();
5232 }
5233
5234 @Override
5235 public boolean equals(Object that) {
5236 if (that == null)
5237 return false;
5238 if (that instanceof put_result)
5239 return this.equals((put_result)that);
5240 return false;
5241 }
5242
5243 public boolean equals(put_result that) {
5244 if (that == null)
5245 return false;
5246
5247 boolean this_present_io = true && this.isSetIo();
5248 boolean that_present_io = true && that.isSetIo();
5249 if (this_present_io || that_present_io) {
5250 if (!(this_present_io && that_present_io))
5251 return false;
5252 if (!this.io.equals(that.io))
5253 return false;
5254 }
5255
5256 return true;
5257 }
5258
5259 @Override
5260 public int hashCode() {
5261 HashCodeBuilder builder = new HashCodeBuilder();
5262
5263 boolean present_io = true && (isSetIo());
5264 builder.append(present_io);
5265 if (present_io)
5266 builder.append(io);
5267
5268 return builder.toHashCode();
5269 }
5270
5271 public int compareTo(put_result other) {
5272 if (!getClass().equals(other.getClass())) {
5273 return getClass().getName().compareTo(other.getClass().getName());
5274 }
5275
5276 int lastComparison = 0;
5277 put_result typedOther = (put_result)other;
5278
5279 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
5280 if (lastComparison != 0) {
5281 return lastComparison;
5282 }
5283 if (isSetIo()) {
5284 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
5285 if (lastComparison != 0) {
5286 return lastComparison;
5287 }
5288 }
5289 return 0;
5290 }
5291
5292 public _Fields fieldForId(int fieldId) {
5293 return _Fields.findByThriftId(fieldId);
5294 }
5295
5296 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
5297 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
5298 }
5299
5300 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
5301 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
5302 }
5303
5304 @Override
5305 public String toString() {
5306 StringBuilder sb = new StringBuilder("put_result(");
5307 boolean first = true;
5308
5309 sb.append("io:");
5310 if (this.io == null) {
5311 sb.append("null");
5312 } else {
5313 sb.append(this.io);
5314 }
5315 first = false;
5316 sb.append(")");
5317 return sb.toString();
5318 }
5319
5320 public void validate() throws org.apache.thrift.TException {
5321
5322 }
5323
5324 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
5325 try {
5326 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
5327 } catch (org.apache.thrift.TException te) {
5328 throw new java.io.IOException(te);
5329 }
5330 }
5331
5332 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
5333 try {
5334 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
5335 } catch (org.apache.thrift.TException te) {
5336 throw new java.io.IOException(te);
5337 }
5338 }
5339
5340 private static class put_resultStandardSchemeFactory implements SchemeFactory {
5341 public put_resultStandardScheme getScheme() {
5342 return new put_resultStandardScheme();
5343 }
5344 }
5345
5346 private static class put_resultStandardScheme extends StandardScheme<put_result> {
5347
5348 public void read(org.apache.thrift.protocol.TProtocol iprot, put_result struct) throws org.apache.thrift.TException {
5349 org.apache.thrift.protocol.TField schemeField;
5350 iprot.readStructBegin();
5351 while (true)
5352 {
5353 schemeField = iprot.readFieldBegin();
5354 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
5355 break;
5356 }
5357 switch (schemeField.id) {
5358 case 1:
5359 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
5360 struct.io = new TIOError();
5361 struct.io.read(iprot);
5362 struct.setIoIsSet(true);
5363 } else {
5364 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5365 }
5366 break;
5367 default:
5368 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5369 }
5370 iprot.readFieldEnd();
5371 }
5372 iprot.readStructEnd();
5373
5374
5375 struct.validate();
5376 }
5377
5378 public void write(org.apache.thrift.protocol.TProtocol oprot, put_result struct) throws org.apache.thrift.TException {
5379 struct.validate();
5380
5381 oprot.writeStructBegin(STRUCT_DESC);
5382 if (struct.io != null) {
5383 oprot.writeFieldBegin(IO_FIELD_DESC);
5384 struct.io.write(oprot);
5385 oprot.writeFieldEnd();
5386 }
5387 oprot.writeFieldStop();
5388 oprot.writeStructEnd();
5389 }
5390
5391 }
5392
5393 private static class put_resultTupleSchemeFactory implements SchemeFactory {
5394 public put_resultTupleScheme getScheme() {
5395 return new put_resultTupleScheme();
5396 }
5397 }
5398
5399 private static class put_resultTupleScheme extends TupleScheme<put_result> {
5400
5401 @Override
5402 public void write(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5403 TTupleProtocol oprot = (TTupleProtocol) prot;
5404 BitSet optionals = new BitSet();
5405 if (struct.isSetIo()) {
5406 optionals.set(0);
5407 }
5408 oprot.writeBitSet(optionals, 1);
5409 if (struct.isSetIo()) {
5410 struct.io.write(oprot);
5411 }
5412 }
5413
5414 @Override
5415 public void read(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5416 TTupleProtocol iprot = (TTupleProtocol) prot;
5417 BitSet incoming = iprot.readBitSet(1);
5418 if (incoming.get(0)) {
5419 struct.io = new TIOError();
5420 struct.io.read(iprot);
5421 struct.setIoIsSet(true);
5422 }
5423 }
5424 }
5425
5426 }
5427
5428 public static class checkAndPut_args implements org.apache.thrift.TBase<checkAndPut_args, checkAndPut_args._Fields>, java.io.Serializable, Cloneable {
5429 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_args");
5430
5431 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
5432 private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2);
5433 private static final org.apache.thrift.protocol.TField FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)3);
5434 private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)4);
5435 private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)5);
5436 private static final org.apache.thrift.protocol.TField PUT_FIELD_DESC = new org.apache.thrift.protocol.TField("put", org.apache.thrift.protocol.TType.STRUCT, (short)6);
5437
5438 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
5439 static {
5440 schemes.put(StandardScheme.class, new checkAndPut_argsStandardSchemeFactory());
5441 schemes.put(TupleScheme.class, new checkAndPut_argsTupleSchemeFactory());
5442 }
5443
5444
5445
5446
5447 public ByteBuffer table;
5448
5449
5450
5451 public ByteBuffer row;
5452
5453
5454
5455 public ByteBuffer family;
5456
5457
5458
5459 public ByteBuffer qualifier;
5460
5461
5462
5463
5464
5465 public ByteBuffer value;
5466
5467
5468
5469 public TPut put;
5470
5471
5472 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
5473
5474
5475
5476 TABLE((short)1, "table"),
5477
5478
5479
5480 ROW((short)2, "row"),
5481
5482
5483
5484 FAMILY((short)3, "family"),
5485
5486
5487
5488 QUALIFIER((short)4, "qualifier"),
5489
5490
5491
5492
5493
5494 VALUE((short)5, "value"),
5495
5496
5497
5498 PUT((short)6, "put");
5499
5500 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5501
5502 static {
5503 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5504 byName.put(field.getFieldName(), field);
5505 }
5506 }
5507
5508
5509
5510
5511 public static _Fields findByThriftId(int fieldId) {
5512 switch(fieldId) {
5513 case 1:
5514 return TABLE;
5515 case 2:
5516 return ROW;
5517 case 3:
5518 return FAMILY;
5519 case 4:
5520 return QUALIFIER;
5521 case 5:
5522 return VALUE;
5523 case 6:
5524 return PUT;
5525 default:
5526 return null;
5527 }
5528 }
5529
5530
5531
5532
5533
5534 public static _Fields findByThriftIdOrThrow(int fieldId) {
5535 _Fields fields = findByThriftId(fieldId);
5536 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5537 return fields;
5538 }
5539
5540
5541
5542
5543 public static _Fields findByName(String name) {
5544 return byName.get(name);
5545 }
5546
5547 private final short _thriftId;
5548 private final String _fieldName;
5549
5550 _Fields(short thriftId, String fieldName) {
5551 _thriftId = thriftId;
5552 _fieldName = fieldName;
5553 }
5554
5555 public short getThriftFieldId() {
5556 return _thriftId;
5557 }
5558
5559 public String getFieldName() {
5560 return _fieldName;
5561 }
5562 }
5563
5564
5565 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
5566 static {
5567 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
5568 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
5569 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5570 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
5571 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5572 tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
5573 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5574 tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
5575 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5576 tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT,
5577 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5578 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
5579 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
5580 metaDataMap = Collections.unmodifiableMap(tmpMap);
5581 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_args.class, metaDataMap);
5582 }
5583
5584 public checkAndPut_args() {
5585 }
5586
5587 public checkAndPut_args(
5588 ByteBuffer table,
5589 ByteBuffer row,
5590 ByteBuffer family,
5591 ByteBuffer qualifier,
5592 ByteBuffer value,
5593 TPut put)
5594 {
5595 this();
5596 this.table = table;
5597 this.row = row;
5598 this.family = family;
5599 this.qualifier = qualifier;
5600 this.value = value;
5601 this.put = put;
5602 }
5603
5604
5605
5606
5607 public checkAndPut_args(checkAndPut_args other) {
5608 if (other.isSetTable()) {
5609 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
5610 ;
5611 }
5612 if (other.isSetRow()) {
5613 this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
5614 ;
5615 }
5616 if (other.isSetFamily()) {
5617 this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
5618 ;
5619 }
5620 if (other.isSetQualifier()) {
5621 this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
5622 ;
5623 }
5624 if (other.isSetValue()) {
5625 this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
5626 ;
5627 }
5628 if (other.isSetPut()) {
5629 this.put = new TPut(other.put);
5630 }
5631 }
5632
5633 public checkAndPut_args deepCopy() {
5634 return new checkAndPut_args(this);
5635 }
5636
5637 @Override
5638 public void clear() {
5639 this.table = null;
5640 this.row = null;
5641 this.family = null;
5642 this.qualifier = null;
5643 this.value = null;
5644 this.put = null;
5645 }
5646
5647
5648
5649
5650 public byte[] getTable() {
5651 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
5652 return table == null ? null : table.array();
5653 }
5654
5655 public ByteBuffer bufferForTable() {
5656 return table;
5657 }
5658
5659
5660
5661
5662 public checkAndPut_args setTable(byte[] table) {
5663 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
5664 return this;
5665 }
5666
5667 public checkAndPut_args setTable(ByteBuffer table) {
5668 this.table = table;
5669 return this;
5670 }
5671
5672 public void unsetTable() {
5673 this.table = null;
5674 }
5675
5676
5677 public boolean isSetTable() {
5678 return this.table != null;
5679 }
5680
5681 public void setTableIsSet(boolean value) {
5682 if (!value) {
5683 this.table = null;
5684 }
5685 }
5686
5687
5688
5689
5690 public byte[] getRow() {
5691 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
5692 return row == null ? null : row.array();
5693 }
5694
5695 public ByteBuffer bufferForRow() {
5696 return row;
5697 }
5698
5699
5700
5701
5702 public checkAndPut_args setRow(byte[] row) {
5703 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
5704 return this;
5705 }
5706
5707 public checkAndPut_args setRow(ByteBuffer row) {
5708 this.row = row;
5709 return this;
5710 }
5711
5712 public void unsetRow() {
5713 this.row = null;
5714 }
5715
5716
5717 public boolean isSetRow() {
5718 return this.row != null;
5719 }
5720
5721 public void setRowIsSet(boolean value) {
5722 if (!value) {
5723 this.row = null;
5724 }
5725 }
5726
5727
5728
5729
5730 public byte[] getFamily() {
5731 setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
5732 return family == null ? null : family.array();
5733 }
5734
5735 public ByteBuffer bufferForFamily() {
5736 return family;
5737 }
5738
5739
5740
5741
5742 public checkAndPut_args setFamily(byte[] family) {
5743 setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
5744 return this;
5745 }
5746
5747 public checkAndPut_args setFamily(ByteBuffer family) {
5748 this.family = family;
5749 return this;
5750 }
5751
5752 public void unsetFamily() {
5753 this.family = null;
5754 }
5755
5756
5757 public boolean isSetFamily() {
5758 return this.family != null;
5759 }
5760
5761 public void setFamilyIsSet(boolean value) {
5762 if (!value) {
5763 this.family = null;
5764 }
5765 }
5766
5767
5768
5769
5770 public byte[] getQualifier() {
5771 setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
5772 return qualifier == null ? null : qualifier.array();
5773 }
5774
5775 public ByteBuffer bufferForQualifier() {
5776 return qualifier;
5777 }
5778
5779
5780
5781
5782 public checkAndPut_args setQualifier(byte[] qualifier) {
5783 setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
5784 return this;
5785 }
5786
5787 public checkAndPut_args setQualifier(ByteBuffer qualifier) {
5788 this.qualifier = qualifier;
5789 return this;
5790 }
5791
5792 public void unsetQualifier() {
5793 this.qualifier = null;
5794 }
5795
5796
5797 public boolean isSetQualifier() {
5798 return this.qualifier != null;
5799 }
5800
5801 public void setQualifierIsSet(boolean value) {
5802 if (!value) {
5803 this.qualifier = null;
5804 }
5805 }
5806
5807
5808
5809
5810
5811
5812 public byte[] getValue() {
5813 setValue(org.apache.thrift.TBaseHelper.rightSize(value));
5814 return value == null ? null : value.array();
5815 }
5816
5817 public ByteBuffer bufferForValue() {
5818 return value;
5819 }
5820
5821
5822
5823
5824
5825
5826 public checkAndPut_args setValue(byte[] value) {
5827 setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
5828 return this;
5829 }
5830
5831 public checkAndPut_args setValue(ByteBuffer value) {
5832 this.value = value;
5833 return this;
5834 }
5835
5836 public void unsetValue() {
5837 this.value = null;
5838 }
5839
5840
5841 public boolean isSetValue() {
5842 return this.value != null;
5843 }
5844
5845 public void setValueIsSet(boolean value) {
5846 if (!value) {
5847 this.value = null;
5848 }
5849 }
5850
5851
5852
5853
5854 public TPut getPut() {
5855 return this.put;
5856 }
5857
5858
5859
5860
5861 public checkAndPut_args setPut(TPut put) {
5862 this.put = put;
5863 return this;
5864 }
5865
5866 public void unsetPut() {
5867 this.put = null;
5868 }
5869
5870
5871 public boolean isSetPut() {
5872 return this.put != null;
5873 }
5874
5875 public void setPutIsSet(boolean value) {
5876 if (!value) {
5877 this.put = null;
5878 }
5879 }
5880
5881 public void setFieldValue(_Fields field, Object value) {
5882 switch (field) {
5883 case TABLE:
5884 if (value == null) {
5885 unsetTable();
5886 } else {
5887 setTable((ByteBuffer)value);
5888 }
5889 break;
5890
5891 case ROW:
5892 if (value == null) {
5893 unsetRow();
5894 } else {
5895 setRow((ByteBuffer)value);
5896 }
5897 break;
5898
5899 case FAMILY:
5900 if (value == null) {
5901 unsetFamily();
5902 } else {
5903 setFamily((ByteBuffer)value);
5904 }
5905 break;
5906
5907 case QUALIFIER:
5908 if (value == null) {
5909 unsetQualifier();
5910 } else {
5911 setQualifier((ByteBuffer)value);
5912 }
5913 break;
5914
5915 case VALUE:
5916 if (value == null) {
5917 unsetValue();
5918 } else {
5919 setValue((ByteBuffer)value);
5920 }
5921 break;
5922
5923 case PUT:
5924 if (value == null) {
5925 unsetPut();
5926 } else {
5927 setPut((TPut)value);
5928 }
5929 break;
5930
5931 }
5932 }
5933
5934 public Object getFieldValue(_Fields field) {
5935 switch (field) {
5936 case TABLE:
5937 return getTable();
5938
5939 case ROW:
5940 return getRow();
5941
5942 case FAMILY:
5943 return getFamily();
5944
5945 case QUALIFIER:
5946 return getQualifier();
5947
5948 case VALUE:
5949 return getValue();
5950
5951 case PUT:
5952 return getPut();
5953
5954 }
5955 throw new IllegalStateException();
5956 }
5957
5958
5959 public boolean isSet(_Fields field) {
5960 if (field == null) {
5961 throw new IllegalArgumentException();
5962 }
5963
5964 switch (field) {
5965 case TABLE:
5966 return isSetTable();
5967 case ROW:
5968 return isSetRow();
5969 case FAMILY:
5970 return isSetFamily();
5971 case QUALIFIER:
5972 return isSetQualifier();
5973 case VALUE:
5974 return isSetValue();
5975 case PUT:
5976 return isSetPut();
5977 }
5978 throw new IllegalStateException();
5979 }
5980
5981 @Override
5982 public boolean equals(Object that) {
5983 if (that == null)
5984 return false;
5985 if (that instanceof checkAndPut_args)
5986 return this.equals((checkAndPut_args)that);
5987 return false;
5988 }
5989
5990 public boolean equals(checkAndPut_args that) {
5991 if (that == null)
5992 return false;
5993
5994 boolean this_present_table = true && this.isSetTable();
5995 boolean that_present_table = true && that.isSetTable();
5996 if (this_present_table || that_present_table) {
5997 if (!(this_present_table && that_present_table))
5998 return false;
5999 if (!this.table.equals(that.table))
6000 return false;
6001 }
6002
6003 boolean this_present_row = true && this.isSetRow();
6004 boolean that_present_row = true && that.isSetRow();
6005 if (this_present_row || that_present_row) {
6006 if (!(this_present_row && that_present_row))
6007 return false;
6008 if (!this.row.equals(that.row))
6009 return false;
6010 }
6011
6012 boolean this_present_family = true && this.isSetFamily();
6013 boolean that_present_family = true && that.isSetFamily();
6014 if (this_present_family || that_present_family) {
6015 if (!(this_present_family && that_present_family))
6016 return false;
6017 if (!this.family.equals(that.family))
6018 return false;
6019 }
6020
6021 boolean this_present_qualifier = true && this.isSetQualifier();
6022 boolean that_present_qualifier = true && that.isSetQualifier();
6023 if (this_present_qualifier || that_present_qualifier) {
6024 if (!(this_present_qualifier && that_present_qualifier))
6025 return false;
6026 if (!this.qualifier.equals(that.qualifier))
6027 return false;
6028 }
6029
6030 boolean this_present_value = true && this.isSetValue();
6031 boolean that_present_value = true && that.isSetValue();
6032 if (this_present_value || that_present_value) {
6033 if (!(this_present_value && that_present_value))
6034 return false;
6035 if (!this.value.equals(that.value))
6036 return false;
6037 }
6038
6039 boolean this_present_put = true && this.isSetPut();
6040 boolean that_present_put = true && that.isSetPut();
6041 if (this_present_put || that_present_put) {
6042 if (!(this_present_put && that_present_put))
6043 return false;
6044 if (!this.put.equals(that.put))
6045 return false;
6046 }
6047
6048 return true;
6049 }
6050
6051 @Override
6052 public int hashCode() {
6053 HashCodeBuilder builder = new HashCodeBuilder();
6054
6055 boolean present_table = true && (isSetTable());
6056 builder.append(present_table);
6057 if (present_table)
6058 builder.append(table);
6059
6060 boolean present_row = true && (isSetRow());
6061 builder.append(present_row);
6062 if (present_row)
6063 builder.append(row);
6064
6065 boolean present_family = true && (isSetFamily());
6066 builder.append(present_family);
6067 if (present_family)
6068 builder.append(family);
6069
6070 boolean present_qualifier = true && (isSetQualifier());
6071 builder.append(present_qualifier);
6072 if (present_qualifier)
6073 builder.append(qualifier);
6074
6075 boolean present_value = true && (isSetValue());
6076 builder.append(present_value);
6077 if (present_value)
6078 builder.append(value);
6079
6080 boolean present_put = true && (isSetPut());
6081 builder.append(present_put);
6082 if (present_put)
6083 builder.append(put);
6084
6085 return builder.toHashCode();
6086 }
6087
6088 public int compareTo(checkAndPut_args other) {
6089 if (!getClass().equals(other.getClass())) {
6090 return getClass().getName().compareTo(other.getClass().getName());
6091 }
6092
6093 int lastComparison = 0;
6094 checkAndPut_args typedOther = (checkAndPut_args)other;
6095
6096 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
6097 if (lastComparison != 0) {
6098 return lastComparison;
6099 }
6100 if (isSetTable()) {
6101 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
6102 if (lastComparison != 0) {
6103 return lastComparison;
6104 }
6105 }
6106 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
6107 if (lastComparison != 0) {
6108 return lastComparison;
6109 }
6110 if (isSetRow()) {
6111 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
6112 if (lastComparison != 0) {
6113 return lastComparison;
6114 }
6115 }
6116 lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
6117 if (lastComparison != 0) {
6118 return lastComparison;
6119 }
6120 if (isSetFamily()) {
6121 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
6122 if (lastComparison != 0) {
6123 return lastComparison;
6124 }
6125 }
6126 lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
6127 if (lastComparison != 0) {
6128 return lastComparison;
6129 }
6130 if (isSetQualifier()) {
6131 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
6132 if (lastComparison != 0) {
6133 return lastComparison;
6134 }
6135 }
6136 lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
6137 if (lastComparison != 0) {
6138 return lastComparison;
6139 }
6140 if (isSetValue()) {
6141 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
6142 if (lastComparison != 0) {
6143 return lastComparison;
6144 }
6145 }
6146 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
6147 if (lastComparison != 0) {
6148 return lastComparison;
6149 }
6150 if (isSetPut()) {
6151 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
6152 if (lastComparison != 0) {
6153 return lastComparison;
6154 }
6155 }
6156 return 0;
6157 }
6158
6159 public _Fields fieldForId(int fieldId) {
6160 return _Fields.findByThriftId(fieldId);
6161 }
6162
6163 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6164 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6165 }
6166
6167 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6168 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6169 }
6170
6171 @Override
6172 public String toString() {
6173 StringBuilder sb = new StringBuilder("checkAndPut_args(");
6174 boolean first = true;
6175
6176 sb.append("table:");
6177 if (this.table == null) {
6178 sb.append("null");
6179 } else {
6180 org.apache.thrift.TBaseHelper.toString(this.table, sb);
6181 }
6182 first = false;
6183 if (!first) sb.append(", ");
6184 sb.append("row:");
6185 if (this.row == null) {
6186 sb.append("null");
6187 } else {
6188 org.apache.thrift.TBaseHelper.toString(this.row, sb);
6189 }
6190 first = false;
6191 if (!first) sb.append(", ");
6192 sb.append("family:");
6193 if (this.family == null) {
6194 sb.append("null");
6195 } else {
6196 org.apache.thrift.TBaseHelper.toString(this.family, sb);
6197 }
6198 first = false;
6199 if (!first) sb.append(", ");
6200 sb.append("qualifier:");
6201 if (this.qualifier == null) {
6202 sb.append("null");
6203 } else {
6204 org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
6205 }
6206 first = false;
6207 if (!first) sb.append(", ");
6208 sb.append("value:");
6209 if (this.value == null) {
6210 sb.append("null");
6211 } else {
6212 org.apache.thrift.TBaseHelper.toString(this.value, sb);
6213 }
6214 first = false;
6215 if (!first) sb.append(", ");
6216 sb.append("put:");
6217 if (this.put == null) {
6218 sb.append("null");
6219 } else {
6220 sb.append(this.put);
6221 }
6222 first = false;
6223 sb.append(")");
6224 return sb.toString();
6225 }
6226
6227 public void validate() throws org.apache.thrift.TException {
6228
6229 if (table == null) {
6230 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
6231 }
6232 if (row == null) {
6233 throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
6234 }
6235 if (family == null) {
6236 throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
6237 }
6238 if (qualifier == null) {
6239 throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
6240 }
6241 if (put == null) {
6242 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
6243 }
6244 }
6245
6246 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6247 try {
6248 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6249 } catch (org.apache.thrift.TException te) {
6250 throw new java.io.IOException(te);
6251 }
6252 }
6253
6254 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6255 try {
6256 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6257 } catch (org.apache.thrift.TException te) {
6258 throw new java.io.IOException(te);
6259 }
6260 }
6261
6262 private static class checkAndPut_argsStandardSchemeFactory implements SchemeFactory {
6263 public checkAndPut_argsStandardScheme getScheme() {
6264 return new checkAndPut_argsStandardScheme();
6265 }
6266 }
6267
6268 private static class checkAndPut_argsStandardScheme extends StandardScheme<checkAndPut_args> {
6269
6270 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6271 org.apache.thrift.protocol.TField schemeField;
6272 iprot.readStructBegin();
6273 while (true)
6274 {
6275 schemeField = iprot.readFieldBegin();
6276 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6277 break;
6278 }
6279 switch (schemeField.id) {
6280 case 1:
6281 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6282 struct.table = iprot.readBinary();
6283 struct.setTableIsSet(true);
6284 } else {
6285 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6286 }
6287 break;
6288 case 2:
6289 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6290 struct.row = iprot.readBinary();
6291 struct.setRowIsSet(true);
6292 } else {
6293 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6294 }
6295 break;
6296 case 3:
6297 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6298 struct.family = iprot.readBinary();
6299 struct.setFamilyIsSet(true);
6300 } else {
6301 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6302 }
6303 break;
6304 case 4:
6305 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6306 struct.qualifier = iprot.readBinary();
6307 struct.setQualifierIsSet(true);
6308 } else {
6309 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6310 }
6311 break;
6312 case 5:
6313 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6314 struct.value = iprot.readBinary();
6315 struct.setValueIsSet(true);
6316 } else {
6317 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6318 }
6319 break;
6320 case 6:
6321 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6322 struct.put = new TPut();
6323 struct.put.read(iprot);
6324 struct.setPutIsSet(true);
6325 } else {
6326 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6327 }
6328 break;
6329 default:
6330 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6331 }
6332 iprot.readFieldEnd();
6333 }
6334 iprot.readStructEnd();
6335
6336
6337 struct.validate();
6338 }
6339
6340 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6341 struct.validate();
6342
6343 oprot.writeStructBegin(STRUCT_DESC);
6344 if (struct.table != null) {
6345 oprot.writeFieldBegin(TABLE_FIELD_DESC);
6346 oprot.writeBinary(struct.table);
6347 oprot.writeFieldEnd();
6348 }
6349 if (struct.row != null) {
6350 oprot.writeFieldBegin(ROW_FIELD_DESC);
6351 oprot.writeBinary(struct.row);
6352 oprot.writeFieldEnd();
6353 }
6354 if (struct.family != null) {
6355 oprot.writeFieldBegin(FAMILY_FIELD_DESC);
6356 oprot.writeBinary(struct.family);
6357 oprot.writeFieldEnd();
6358 }
6359 if (struct.qualifier != null) {
6360 oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
6361 oprot.writeBinary(struct.qualifier);
6362 oprot.writeFieldEnd();
6363 }
6364 if (struct.value != null) {
6365 oprot.writeFieldBegin(VALUE_FIELD_DESC);
6366 oprot.writeBinary(struct.value);
6367 oprot.writeFieldEnd();
6368 }
6369 if (struct.put != null) {
6370 oprot.writeFieldBegin(PUT_FIELD_DESC);
6371 struct.put.write(oprot);
6372 oprot.writeFieldEnd();
6373 }
6374 oprot.writeFieldStop();
6375 oprot.writeStructEnd();
6376 }
6377
6378 }
6379
6380 private static class checkAndPut_argsTupleSchemeFactory implements SchemeFactory {
6381 public checkAndPut_argsTupleScheme getScheme() {
6382 return new checkAndPut_argsTupleScheme();
6383 }
6384 }
6385
6386 private static class checkAndPut_argsTupleScheme extends TupleScheme<checkAndPut_args> {
6387
6388 @Override
6389 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6390 TTupleProtocol oprot = (TTupleProtocol) prot;
6391 oprot.writeBinary(struct.table);
6392 oprot.writeBinary(struct.row);
6393 oprot.writeBinary(struct.family);
6394 oprot.writeBinary(struct.qualifier);
6395 struct.put.write(oprot);
6396 BitSet optionals = new BitSet();
6397 if (struct.isSetValue()) {
6398 optionals.set(0);
6399 }
6400 oprot.writeBitSet(optionals, 1);
6401 if (struct.isSetValue()) {
6402 oprot.writeBinary(struct.value);
6403 }
6404 }
6405
6406 @Override
6407 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6408 TTupleProtocol iprot = (TTupleProtocol) prot;
6409 struct.table = iprot.readBinary();
6410 struct.setTableIsSet(true);
6411 struct.row = iprot.readBinary();
6412 struct.setRowIsSet(true);
6413 struct.family = iprot.readBinary();
6414 struct.setFamilyIsSet(true);
6415 struct.qualifier = iprot.readBinary();
6416 struct.setQualifierIsSet(true);
6417 struct.put = new TPut();
6418 struct.put.read(iprot);
6419 struct.setPutIsSet(true);
6420 BitSet incoming = iprot.readBitSet(1);
6421 if (incoming.get(0)) {
6422 struct.value = iprot.readBinary();
6423 struct.setValueIsSet(true);
6424 }
6425 }
6426 }
6427
6428 }
6429
6430 public static class checkAndPut_result implements org.apache.thrift.TBase<checkAndPut_result, checkAndPut_result._Fields>, java.io.Serializable, Cloneable {
6431 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_result");
6432
6433 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0);
6434 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
6435
6436 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6437 static {
6438 schemes.put(StandardScheme.class, new checkAndPut_resultStandardSchemeFactory());
6439 schemes.put(TupleScheme.class, new checkAndPut_resultTupleSchemeFactory());
6440 }
6441
6442 public boolean success;
6443 public TIOError io;
6444
6445
6446 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6447 SUCCESS((short)0, "success"),
6448 IO((short)1, "io");
6449
6450 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6451
6452 static {
6453 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6454 byName.put(field.getFieldName(), field);
6455 }
6456 }
6457
6458
6459
6460
6461 public static _Fields findByThriftId(int fieldId) {
6462 switch(fieldId) {
6463 case 0:
6464 return SUCCESS;
6465 case 1:
6466 return IO;
6467 default:
6468 return null;
6469 }
6470 }
6471
6472
6473
6474
6475
6476 public static _Fields findByThriftIdOrThrow(int fieldId) {
6477 _Fields fields = findByThriftId(fieldId);
6478 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6479 return fields;
6480 }
6481
6482
6483
6484
6485 public static _Fields findByName(String name) {
6486 return byName.get(name);
6487 }
6488
6489 private final short _thriftId;
6490 private final String _fieldName;
6491
6492 _Fields(short thriftId, String fieldName) {
6493 _thriftId = thriftId;
6494 _fieldName = fieldName;
6495 }
6496
6497 public short getThriftFieldId() {
6498 return _thriftId;
6499 }
6500
6501 public String getFieldName() {
6502 return _fieldName;
6503 }
6504 }
6505
6506
6507 private static final int __SUCCESS_ISSET_ID = 0;
6508 private BitSet __isset_bit_vector = new BitSet(1);
6509 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6510 static {
6511 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6512 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
6513 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
6514 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
6515 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
6516 metaDataMap = Collections.unmodifiableMap(tmpMap);
6517 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_result.class, metaDataMap);
6518 }
6519
6520 public checkAndPut_result() {
6521 }
6522
6523 public checkAndPut_result(
6524 boolean success,
6525 TIOError io)
6526 {
6527 this();
6528 this.success = success;
6529 setSuccessIsSet(true);
6530 this.io = io;
6531 }
6532
6533
6534
6535
6536 public checkAndPut_result(checkAndPut_result other) {
6537 __isset_bit_vector.clear();
6538 __isset_bit_vector.or(other.__isset_bit_vector);
6539 this.success = other.success;
6540 if (other.isSetIo()) {
6541 this.io = new TIOError(other.io);
6542 }
6543 }
6544
6545 public checkAndPut_result deepCopy() {
6546 return new checkAndPut_result(this);
6547 }
6548
6549 @Override
6550 public void clear() {
6551 setSuccessIsSet(false);
6552 this.success = false;
6553 this.io = null;
6554 }
6555
6556 public boolean isSuccess() {
6557 return this.success;
6558 }
6559
6560 public checkAndPut_result setSuccess(boolean success) {
6561 this.success = success;
6562 setSuccessIsSet(true);
6563 return this;
6564 }
6565
6566 public void unsetSuccess() {
6567 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
6568 }
6569
6570
6571 public boolean isSetSuccess() {
6572 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
6573 }
6574
6575 public void setSuccessIsSet(boolean value) {
6576 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
6577 }
6578
6579 public TIOError getIo() {
6580 return this.io;
6581 }
6582
6583 public checkAndPut_result setIo(TIOError io) {
6584 this.io = io;
6585 return this;
6586 }
6587
6588 public void unsetIo() {
6589 this.io = null;
6590 }
6591
6592
6593 public boolean isSetIo() {
6594 return this.io != null;
6595 }
6596
6597 public void setIoIsSet(boolean value) {
6598 if (!value) {
6599 this.io = null;
6600 }
6601 }
6602
6603 public void setFieldValue(_Fields field, Object value) {
6604 switch (field) {
6605 case SUCCESS:
6606 if (value == null) {
6607 unsetSuccess();
6608 } else {
6609 setSuccess((Boolean)value);
6610 }
6611 break;
6612
6613 case IO:
6614 if (value == null) {
6615 unsetIo();
6616 } else {
6617 setIo((TIOError)value);
6618 }
6619 break;
6620
6621 }
6622 }
6623
6624 public Object getFieldValue(_Fields field) {
6625 switch (field) {
6626 case SUCCESS:
6627 return Boolean.valueOf(isSuccess());
6628
6629 case IO:
6630 return getIo();
6631
6632 }
6633 throw new IllegalStateException();
6634 }
6635
6636
6637 public boolean isSet(_Fields field) {
6638 if (field == null) {
6639 throw new IllegalArgumentException();
6640 }
6641
6642 switch (field) {
6643 case SUCCESS:
6644 return isSetSuccess();
6645 case IO:
6646 return isSetIo();
6647 }
6648 throw new IllegalStateException();
6649 }
6650
6651 @Override
6652 public boolean equals(Object that) {
6653 if (that == null)
6654 return false;
6655 if (that instanceof checkAndPut_result)
6656 return this.equals((checkAndPut_result)that);
6657 return false;
6658 }
6659
6660 public boolean equals(checkAndPut_result that) {
6661 if (that == null)
6662 return false;
6663
6664 boolean this_present_success = true;
6665 boolean that_present_success = true;
6666 if (this_present_success || that_present_success) {
6667 if (!(this_present_success && that_present_success))
6668 return false;
6669 if (this.success != that.success)
6670 return false;
6671 }
6672
6673 boolean this_present_io = true && this.isSetIo();
6674 boolean that_present_io = true && that.isSetIo();
6675 if (this_present_io || that_present_io) {
6676 if (!(this_present_io && that_present_io))
6677 return false;
6678 if (!this.io.equals(that.io))
6679 return false;
6680 }
6681
6682 return true;
6683 }
6684
6685 @Override
6686 public int hashCode() {
6687 HashCodeBuilder builder = new HashCodeBuilder();
6688
6689 boolean present_success = true;
6690 builder.append(present_success);
6691 if (present_success)
6692 builder.append(success);
6693
6694 boolean present_io = true && (isSetIo());
6695 builder.append(present_io);
6696 if (present_io)
6697 builder.append(io);
6698
6699 return builder.toHashCode();
6700 }
6701
6702 public int compareTo(checkAndPut_result other) {
6703 if (!getClass().equals(other.getClass())) {
6704 return getClass().getName().compareTo(other.getClass().getName());
6705 }
6706
6707 int lastComparison = 0;
6708 checkAndPut_result typedOther = (checkAndPut_result)other;
6709
6710 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
6711 if (lastComparison != 0) {
6712 return lastComparison;
6713 }
6714 if (isSetSuccess()) {
6715 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
6716 if (lastComparison != 0) {
6717 return lastComparison;
6718 }
6719 }
6720 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
6721 if (lastComparison != 0) {
6722 return lastComparison;
6723 }
6724 if (isSetIo()) {
6725 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
6726 if (lastComparison != 0) {
6727 return lastComparison;
6728 }
6729 }
6730 return 0;
6731 }
6732
6733 public _Fields fieldForId(int fieldId) {
6734 return _Fields.findByThriftId(fieldId);
6735 }
6736
6737 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6738 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6739 }
6740
6741 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6742 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6743 }
6744
6745 @Override
6746 public String toString() {
6747 StringBuilder sb = new StringBuilder("checkAndPut_result(");
6748 boolean first = true;
6749
6750 sb.append("success:");
6751 sb.append(this.success);
6752 first = false;
6753 if (!first) sb.append(", ");
6754 sb.append("io:");
6755 if (this.io == null) {
6756 sb.append("null");
6757 } else {
6758 sb.append(this.io);
6759 }
6760 first = false;
6761 sb.append(")");
6762 return sb.toString();
6763 }
6764
6765 public void validate() throws org.apache.thrift.TException {
6766
6767 }
6768
6769 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6770 try {
6771 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6772 } catch (org.apache.thrift.TException te) {
6773 throw new java.io.IOException(te);
6774 }
6775 }
6776
6777 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6778 try {
6779 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6780 } catch (org.apache.thrift.TException te) {
6781 throw new java.io.IOException(te);
6782 }
6783 }
6784
6785 private static class checkAndPut_resultStandardSchemeFactory implements SchemeFactory {
6786 public checkAndPut_resultStandardScheme getScheme() {
6787 return new checkAndPut_resultStandardScheme();
6788 }
6789 }
6790
6791 private static class checkAndPut_resultStandardScheme extends StandardScheme<checkAndPut_result> {
6792
6793 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6794 org.apache.thrift.protocol.TField schemeField;
6795 iprot.readStructBegin();
6796 while (true)
6797 {
6798 schemeField = iprot.readFieldBegin();
6799 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6800 break;
6801 }
6802 switch (schemeField.id) {
6803 case 0:
6804 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
6805 struct.success = iprot.readBool();
6806 struct.setSuccessIsSet(true);
6807 } else {
6808 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6809 }
6810 break;
6811 case 1:
6812 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6813 struct.io = new TIOError();
6814 struct.io.read(iprot);
6815 struct.setIoIsSet(true);
6816 } else {
6817 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6818 }
6819 break;
6820 default:
6821 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6822 }
6823 iprot.readFieldEnd();
6824 }
6825 iprot.readStructEnd();
6826
6827
6828 struct.validate();
6829 }
6830
6831 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6832 struct.validate();
6833
6834 oprot.writeStructBegin(STRUCT_DESC);
6835 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6836 oprot.writeBool(struct.success);
6837 oprot.writeFieldEnd();
6838 if (struct.io != null) {
6839 oprot.writeFieldBegin(IO_FIELD_DESC);
6840 struct.io.write(oprot);
6841 oprot.writeFieldEnd();
6842 }
6843 oprot.writeFieldStop();
6844 oprot.writeStructEnd();
6845 }
6846
6847 }
6848
6849 private static class checkAndPut_resultTupleSchemeFactory implements SchemeFactory {
6850 public checkAndPut_resultTupleScheme getScheme() {
6851 return new checkAndPut_resultTupleScheme();
6852 }
6853 }
6854
6855 private static class checkAndPut_resultTupleScheme extends TupleScheme<checkAndPut_result> {
6856
6857 @Override
6858 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6859 TTupleProtocol oprot = (TTupleProtocol) prot;
6860 BitSet optionals = new BitSet();
6861 if (struct.isSetSuccess()) {
6862 optionals.set(0);
6863 }
6864 if (struct.isSetIo()) {
6865 optionals.set(1);
6866 }
6867 oprot.writeBitSet(optionals, 2);
6868 if (struct.isSetSuccess()) {
6869 oprot.writeBool(struct.success);
6870 }
6871 if (struct.isSetIo()) {
6872 struct.io.write(oprot);
6873 }
6874 }
6875
6876 @Override
6877 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6878 TTupleProtocol iprot = (TTupleProtocol) prot;
6879 BitSet incoming = iprot.readBitSet(2);
6880 if (incoming.get(0)) {
6881 struct.success = iprot.readBool();
6882 struct.setSuccessIsSet(true);
6883 }
6884 if (incoming.get(1)) {
6885 struct.io = new TIOError();
6886 struct.io.read(iprot);
6887 struct.setIoIsSet(true);
6888 }
6889 }
6890 }
6891
6892 }
6893
6894 public static class putMultiple_args implements org.apache.thrift.TBase<putMultiple_args, putMultiple_args._Fields>, java.io.Serializable, Cloneable {
6895 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_args");
6896
6897 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
6898 private static final org.apache.thrift.protocol.TField PUTS_FIELD_DESC = new org.apache.thrift.protocol.TField("puts", org.apache.thrift.protocol.TType.LIST, (short)2);
6899
6900 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6901 static {
6902 schemes.put(StandardScheme.class, new putMultiple_argsStandardSchemeFactory());
6903 schemes.put(TupleScheme.class, new putMultiple_argsTupleSchemeFactory());
6904 }
6905
6906
6907
6908
6909 public ByteBuffer table;
6910
6911
6912
6913 public List<TPut> puts;
6914
6915
6916 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6917
6918
6919
6920 TABLE((short)1, "table"),
6921
6922
6923
6924 PUTS((short)2, "puts");
6925
6926 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6927
6928 static {
6929 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6930 byName.put(field.getFieldName(), field);
6931 }
6932 }
6933
6934
6935
6936
6937 public static _Fields findByThriftId(int fieldId) {
6938 switch(fieldId) {
6939 case 1:
6940 return TABLE;
6941 case 2:
6942 return PUTS;
6943 default:
6944 return null;
6945 }
6946 }
6947
6948
6949
6950
6951
6952 public static _Fields findByThriftIdOrThrow(int fieldId) {
6953 _Fields fields = findByThriftId(fieldId);
6954 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6955 return fields;
6956 }
6957
6958
6959
6960
6961 public static _Fields findByName(String name) {
6962 return byName.get(name);
6963 }
6964
6965 private final short _thriftId;
6966 private final String _fieldName;
6967
6968 _Fields(short thriftId, String fieldName) {
6969 _thriftId = thriftId;
6970 _fieldName = fieldName;
6971 }
6972
6973 public short getThriftFieldId() {
6974 return _thriftId;
6975 }
6976
6977 public String getFieldName() {
6978 return _fieldName;
6979 }
6980 }
6981
6982
6983 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6984 static {
6985 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6986 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
6987 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
6988 tmpMap.put(_Fields.PUTS, new org.apache.thrift.meta_data.FieldMetaData("puts", org.apache.thrift.TFieldRequirementType.REQUIRED,
6989 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
6990 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class))));
6991 metaDataMap = Collections.unmodifiableMap(tmpMap);
6992 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_args.class, metaDataMap);
6993 }
6994
6995 public putMultiple_args() {
6996 }
6997
6998 public putMultiple_args(
6999 ByteBuffer table,
7000 List<TPut> puts)
7001 {
7002 this();
7003 this.table = table;
7004 this.puts = puts;
7005 }
7006
7007
7008
7009
7010 public putMultiple_args(putMultiple_args other) {
7011 if (other.isSetTable()) {
7012 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
7013 ;
7014 }
7015 if (other.isSetPuts()) {
7016 List<TPut> __this__puts = new ArrayList<TPut>();
7017 for (TPut other_element : other.puts) {
7018 __this__puts.add(new TPut(other_element));
7019 }
7020 this.puts = __this__puts;
7021 }
7022 }
7023
7024 public putMultiple_args deepCopy() {
7025 return new putMultiple_args(this);
7026 }
7027
7028 @Override
7029 public void clear() {
7030 this.table = null;
7031 this.puts = null;
7032 }
7033
7034
7035
7036
7037 public byte[] getTable() {
7038 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
7039 return table == null ? null : table.array();
7040 }
7041
7042 public ByteBuffer bufferForTable() {
7043 return table;
7044 }
7045
7046
7047
7048
7049 public putMultiple_args setTable(byte[] table) {
7050 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
7051 return this;
7052 }
7053
7054 public putMultiple_args setTable(ByteBuffer table) {
7055 this.table = table;
7056 return this;
7057 }
7058
7059 public void unsetTable() {
7060 this.table = null;
7061 }
7062
7063
7064 public boolean isSetTable() {
7065 return this.table != null;
7066 }
7067
7068 public void setTableIsSet(boolean value) {
7069 if (!value) {
7070 this.table = null;
7071 }
7072 }
7073
7074 public int getPutsSize() {
7075 return (this.puts == null) ? 0 : this.puts.size();
7076 }
7077
7078 public java.util.Iterator<TPut> getPutsIterator() {
7079 return (this.puts == null) ? null : this.puts.iterator();
7080 }
7081
7082 public void addToPuts(TPut elem) {
7083 if (this.puts == null) {
7084 this.puts = new ArrayList<TPut>();
7085 }
7086 this.puts.add(elem);
7087 }
7088
7089
7090
7091
7092 public List<TPut> getPuts() {
7093 return this.puts;
7094 }
7095
7096
7097
7098
7099 public putMultiple_args setPuts(List<TPut> puts) {
7100 this.puts = puts;
7101 return this;
7102 }
7103
7104 public void unsetPuts() {
7105 this.puts = null;
7106 }
7107
7108
7109 public boolean isSetPuts() {
7110 return this.puts != null;
7111 }
7112
7113 public void setPutsIsSet(boolean value) {
7114 if (!value) {
7115 this.puts = null;
7116 }
7117 }
7118
7119 public void setFieldValue(_Fields field, Object value) {
7120 switch (field) {
7121 case TABLE:
7122 if (value == null) {
7123 unsetTable();
7124 } else {
7125 setTable((ByteBuffer)value);
7126 }
7127 break;
7128
7129 case PUTS:
7130 if (value == null) {
7131 unsetPuts();
7132 } else {
7133 setPuts((List<TPut>)value);
7134 }
7135 break;
7136
7137 }
7138 }
7139
7140 public Object getFieldValue(_Fields field) {
7141 switch (field) {
7142 case TABLE:
7143 return getTable();
7144
7145 case PUTS:
7146 return getPuts();
7147
7148 }
7149 throw new IllegalStateException();
7150 }
7151
7152
7153 public boolean isSet(_Fields field) {
7154 if (field == null) {
7155 throw new IllegalArgumentException();
7156 }
7157
7158 switch (field) {
7159 case TABLE:
7160 return isSetTable();
7161 case PUTS:
7162 return isSetPuts();
7163 }
7164 throw new IllegalStateException();
7165 }
7166
7167 @Override
7168 public boolean equals(Object that) {
7169 if (that == null)
7170 return false;
7171 if (that instanceof putMultiple_args)
7172 return this.equals((putMultiple_args)that);
7173 return false;
7174 }
7175
7176 public boolean equals(putMultiple_args that) {
7177 if (that == null)
7178 return false;
7179
7180 boolean this_present_table = true && this.isSetTable();
7181 boolean that_present_table = true && that.isSetTable();
7182 if (this_present_table || that_present_table) {
7183 if (!(this_present_table && that_present_table))
7184 return false;
7185 if (!this.table.equals(that.table))
7186 return false;
7187 }
7188
7189 boolean this_present_puts = true && this.isSetPuts();
7190 boolean that_present_puts = true && that.isSetPuts();
7191 if (this_present_puts || that_present_puts) {
7192 if (!(this_present_puts && that_present_puts))
7193 return false;
7194 if (!this.puts.equals(that.puts))
7195 return false;
7196 }
7197
7198 return true;
7199 }
7200
7201 @Override
7202 public int hashCode() {
7203 HashCodeBuilder builder = new HashCodeBuilder();
7204
7205 boolean present_table = true && (isSetTable());
7206 builder.append(present_table);
7207 if (present_table)
7208 builder.append(table);
7209
7210 boolean present_puts = true && (isSetPuts());
7211 builder.append(present_puts);
7212 if (present_puts)
7213 builder.append(puts);
7214
7215 return builder.toHashCode();
7216 }
7217
7218 public int compareTo(putMultiple_args other) {
7219 if (!getClass().equals(other.getClass())) {
7220 return getClass().getName().compareTo(other.getClass().getName());
7221 }
7222
7223 int lastComparison = 0;
7224 putMultiple_args typedOther = (putMultiple_args)other;
7225
7226 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
7227 if (lastComparison != 0) {
7228 return lastComparison;
7229 }
7230 if (isSetTable()) {
7231 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
7232 if (lastComparison != 0) {
7233 return lastComparison;
7234 }
7235 }
7236 lastComparison = Boolean.valueOf(isSetPuts()).compareTo(typedOther.isSetPuts());
7237 if (lastComparison != 0) {
7238 return lastComparison;
7239 }
7240 if (isSetPuts()) {
7241 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.puts, typedOther.puts);
7242 if (lastComparison != 0) {
7243 return lastComparison;
7244 }
7245 }
7246 return 0;
7247 }
7248
7249 public _Fields fieldForId(int fieldId) {
7250 return _Fields.findByThriftId(fieldId);
7251 }
7252
7253 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7254 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7255 }
7256
7257 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7258 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7259 }
7260
7261 @Override
7262 public String toString() {
7263 StringBuilder sb = new StringBuilder("putMultiple_args(");
7264 boolean first = true;
7265
7266 sb.append("table:");
7267 if (this.table == null) {
7268 sb.append("null");
7269 } else {
7270 org.apache.thrift.TBaseHelper.toString(this.table, sb);
7271 }
7272 first = false;
7273 if (!first) sb.append(", ");
7274 sb.append("puts:");
7275 if (this.puts == null) {
7276 sb.append("null");
7277 } else {
7278 sb.append(this.puts);
7279 }
7280 first = false;
7281 sb.append(")");
7282 return sb.toString();
7283 }
7284
7285 public void validate() throws org.apache.thrift.TException {
7286
7287 if (table == null) {
7288 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
7289 }
7290 if (puts == null) {
7291 throw new org.apache.thrift.protocol.TProtocolException("Required field 'puts' was not present! Struct: " + toString());
7292 }
7293 }
7294
7295 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7296 try {
7297 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7298 } catch (org.apache.thrift.TException te) {
7299 throw new java.io.IOException(te);
7300 }
7301 }
7302
7303 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7304 try {
7305 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7306 } catch (org.apache.thrift.TException te) {
7307 throw new java.io.IOException(te);
7308 }
7309 }
7310
7311 private static class putMultiple_argsStandardSchemeFactory implements SchemeFactory {
7312 public putMultiple_argsStandardScheme getScheme() {
7313 return new putMultiple_argsStandardScheme();
7314 }
7315 }
7316
7317 private static class putMultiple_argsStandardScheme extends StandardScheme<putMultiple_args> {
7318
7319 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_args struct) throws org.apache.thrift.TException {
7320 org.apache.thrift.protocol.TField schemeField;
7321 iprot.readStructBegin();
7322 while (true)
7323 {
7324 schemeField = iprot.readFieldBegin();
7325 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7326 break;
7327 }
7328 switch (schemeField.id) {
7329 case 1:
7330 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
7331 struct.table = iprot.readBinary();
7332 struct.setTableIsSet(true);
7333 } else {
7334 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7335 }
7336 break;
7337 case 2:
7338 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
7339 {
7340 org.apache.thrift.protocol.TList _list112 = iprot.readListBegin();
7341 struct.puts = new ArrayList<TPut>(_list112.size);
7342 for (int _i113 = 0; _i113 < _list112.size; ++_i113)
7343 {
7344 TPut _elem114;
7345 _elem114 = new TPut();
7346 _elem114.read(iprot);
7347 struct.puts.add(_elem114);
7348 }
7349 iprot.readListEnd();
7350 }
7351 struct.setPutsIsSet(true);
7352 } else {
7353 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7354 }
7355 break;
7356 default:
7357 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7358 }
7359 iprot.readFieldEnd();
7360 }
7361 iprot.readStructEnd();
7362
7363
7364 struct.validate();
7365 }
7366
7367 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_args struct) throws org.apache.thrift.TException {
7368 struct.validate();
7369
7370 oprot.writeStructBegin(STRUCT_DESC);
7371 if (struct.table != null) {
7372 oprot.writeFieldBegin(TABLE_FIELD_DESC);
7373 oprot.writeBinary(struct.table);
7374 oprot.writeFieldEnd();
7375 }
7376 if (struct.puts != null) {
7377 oprot.writeFieldBegin(PUTS_FIELD_DESC);
7378 {
7379 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.puts.size()));
7380 for (TPut _iter115 : struct.puts)
7381 {
7382 _iter115.write(oprot);
7383 }
7384 oprot.writeListEnd();
7385 }
7386 oprot.writeFieldEnd();
7387 }
7388 oprot.writeFieldStop();
7389 oprot.writeStructEnd();
7390 }
7391
7392 }
7393
7394 private static class putMultiple_argsTupleSchemeFactory implements SchemeFactory {
7395 public putMultiple_argsTupleScheme getScheme() {
7396 return new putMultiple_argsTupleScheme();
7397 }
7398 }
7399
7400 private static class putMultiple_argsTupleScheme extends TupleScheme<putMultiple_args> {
7401
7402 @Override
7403 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7404 TTupleProtocol oprot = (TTupleProtocol) prot;
7405 oprot.writeBinary(struct.table);
7406 {
7407 oprot.writeI32(struct.puts.size());
7408 for (TPut _iter116 : struct.puts)
7409 {
7410 _iter116.write(oprot);
7411 }
7412 }
7413 }
7414
7415 @Override
7416 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7417 TTupleProtocol iprot = (TTupleProtocol) prot;
7418 struct.table = iprot.readBinary();
7419 struct.setTableIsSet(true);
7420 {
7421 org.apache.thrift.protocol.TList _list117 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
7422 struct.puts = new ArrayList<TPut>(_list117.size);
7423 for (int _i118 = 0; _i118 < _list117.size; ++_i118)
7424 {
7425 TPut _elem119;
7426 _elem119 = new TPut();
7427 _elem119.read(iprot);
7428 struct.puts.add(_elem119);
7429 }
7430 }
7431 struct.setPutsIsSet(true);
7432 }
7433 }
7434
7435 }
7436
7437 public static class putMultiple_result implements org.apache.thrift.TBase<putMultiple_result, putMultiple_result._Fields>, java.io.Serializable, Cloneable {
7438 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_result");
7439
7440 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
7441
7442 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7443 static {
7444 schemes.put(StandardScheme.class, new putMultiple_resultStandardSchemeFactory());
7445 schemes.put(TupleScheme.class, new putMultiple_resultTupleSchemeFactory());
7446 }
7447
7448 public TIOError io;
7449
7450
7451 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7452 IO((short)1, "io");
7453
7454 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7455
7456 static {
7457 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7458 byName.put(field.getFieldName(), field);
7459 }
7460 }
7461
7462
7463
7464
7465 public static _Fields findByThriftId(int fieldId) {
7466 switch(fieldId) {
7467 case 1:
7468 return IO;
7469 default:
7470 return null;
7471 }
7472 }
7473
7474
7475
7476
7477
7478 public static _Fields findByThriftIdOrThrow(int fieldId) {
7479 _Fields fields = findByThriftId(fieldId);
7480 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7481 return fields;
7482 }
7483
7484
7485
7486
7487 public static _Fields findByName(String name) {
7488 return byName.get(name);
7489 }
7490
7491 private final short _thriftId;
7492 private final String _fieldName;
7493
7494 _Fields(short thriftId, String fieldName) {
7495 _thriftId = thriftId;
7496 _fieldName = fieldName;
7497 }
7498
7499 public short getThriftFieldId() {
7500 return _thriftId;
7501 }
7502
7503 public String getFieldName() {
7504 return _fieldName;
7505 }
7506 }
7507
7508
7509 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7510 static {
7511 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7512 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
7513 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
7514 metaDataMap = Collections.unmodifiableMap(tmpMap);
7515 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_result.class, metaDataMap);
7516 }
7517
7518 public putMultiple_result() {
7519 }
7520
7521 public putMultiple_result(
7522 TIOError io)
7523 {
7524 this();
7525 this.io = io;
7526 }
7527
7528
7529
7530
7531 public putMultiple_result(putMultiple_result other) {
7532 if (other.isSetIo()) {
7533 this.io = new TIOError(other.io);
7534 }
7535 }
7536
7537 public putMultiple_result deepCopy() {
7538 return new putMultiple_result(this);
7539 }
7540
7541 @Override
7542 public void clear() {
7543 this.io = null;
7544 }
7545
7546 public TIOError getIo() {
7547 return this.io;
7548 }
7549
7550 public putMultiple_result setIo(TIOError io) {
7551 this.io = io;
7552 return this;
7553 }
7554
7555 public void unsetIo() {
7556 this.io = null;
7557 }
7558
7559
7560 public boolean isSetIo() {
7561 return this.io != null;
7562 }
7563
7564 public void setIoIsSet(boolean value) {
7565 if (!value) {
7566 this.io = null;
7567 }
7568 }
7569
7570 public void setFieldValue(_Fields field, Object value) {
7571 switch (field) {
7572 case IO:
7573 if (value == null) {
7574 unsetIo();
7575 } else {
7576 setIo((TIOError)value);
7577 }
7578 break;
7579
7580 }
7581 }
7582
7583 public Object getFieldValue(_Fields field) {
7584 switch (field) {
7585 case IO:
7586 return getIo();
7587
7588 }
7589 throw new IllegalStateException();
7590 }
7591
7592
7593 public boolean isSet(_Fields field) {
7594 if (field == null) {
7595 throw new IllegalArgumentException();
7596 }
7597
7598 switch (field) {
7599 case IO:
7600 return isSetIo();
7601 }
7602 throw new IllegalStateException();
7603 }
7604
7605 @Override
7606 public boolean equals(Object that) {
7607 if (that == null)
7608 return false;
7609 if (that instanceof putMultiple_result)
7610 return this.equals((putMultiple_result)that);
7611 return false;
7612 }
7613
7614 public boolean equals(putMultiple_result that) {
7615 if (that == null)
7616 return false;
7617
7618 boolean this_present_io = true && this.isSetIo();
7619 boolean that_present_io = true && that.isSetIo();
7620 if (this_present_io || that_present_io) {
7621 if (!(this_present_io && that_present_io))
7622 return false;
7623 if (!this.io.equals(that.io))
7624 return false;
7625 }
7626
7627 return true;
7628 }
7629
7630 @Override
7631 public int hashCode() {
7632 HashCodeBuilder builder = new HashCodeBuilder();
7633
7634 boolean present_io = true && (isSetIo());
7635 builder.append(present_io);
7636 if (present_io)
7637 builder.append(io);
7638
7639 return builder.toHashCode();
7640 }
7641
7642 public int compareTo(putMultiple_result other) {
7643 if (!getClass().equals(other.getClass())) {
7644 return getClass().getName().compareTo(other.getClass().getName());
7645 }
7646
7647 int lastComparison = 0;
7648 putMultiple_result typedOther = (putMultiple_result)other;
7649
7650 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
7651 if (lastComparison != 0) {
7652 return lastComparison;
7653 }
7654 if (isSetIo()) {
7655 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
7656 if (lastComparison != 0) {
7657 return lastComparison;
7658 }
7659 }
7660 return 0;
7661 }
7662
7663 public _Fields fieldForId(int fieldId) {
7664 return _Fields.findByThriftId(fieldId);
7665 }
7666
7667 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7668 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7669 }
7670
7671 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7672 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7673 }
7674
7675 @Override
7676 public String toString() {
7677 StringBuilder sb = new StringBuilder("putMultiple_result(");
7678 boolean first = true;
7679
7680 sb.append("io:");
7681 if (this.io == null) {
7682 sb.append("null");
7683 } else {
7684 sb.append(this.io);
7685 }
7686 first = false;
7687 sb.append(")");
7688 return sb.toString();
7689 }
7690
7691 public void validate() throws org.apache.thrift.TException {
7692
7693 }
7694
7695 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7696 try {
7697 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7698 } catch (org.apache.thrift.TException te) {
7699 throw new java.io.IOException(te);
7700 }
7701 }
7702
7703 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7704 try {
7705 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7706 } catch (org.apache.thrift.TException te) {
7707 throw new java.io.IOException(te);
7708 }
7709 }
7710
7711 private static class putMultiple_resultStandardSchemeFactory implements SchemeFactory {
7712 public putMultiple_resultStandardScheme getScheme() {
7713 return new putMultiple_resultStandardScheme();
7714 }
7715 }
7716
7717 private static class putMultiple_resultStandardScheme extends StandardScheme<putMultiple_result> {
7718
7719 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_result struct) throws org.apache.thrift.TException {
7720 org.apache.thrift.protocol.TField schemeField;
7721 iprot.readStructBegin();
7722 while (true)
7723 {
7724 schemeField = iprot.readFieldBegin();
7725 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7726 break;
7727 }
7728 switch (schemeField.id) {
7729 case 1:
7730 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
7731 struct.io = new TIOError();
7732 struct.io.read(iprot);
7733 struct.setIoIsSet(true);
7734 } else {
7735 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7736 }
7737 break;
7738 default:
7739 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7740 }
7741 iprot.readFieldEnd();
7742 }
7743 iprot.readStructEnd();
7744
7745
7746 struct.validate();
7747 }
7748
7749 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_result struct) throws org.apache.thrift.TException {
7750 struct.validate();
7751
7752 oprot.writeStructBegin(STRUCT_DESC);
7753 if (struct.io != null) {
7754 oprot.writeFieldBegin(IO_FIELD_DESC);
7755 struct.io.write(oprot);
7756 oprot.writeFieldEnd();
7757 }
7758 oprot.writeFieldStop();
7759 oprot.writeStructEnd();
7760 }
7761
7762 }
7763
7764 private static class putMultiple_resultTupleSchemeFactory implements SchemeFactory {
7765 public putMultiple_resultTupleScheme getScheme() {
7766 return new putMultiple_resultTupleScheme();
7767 }
7768 }
7769
7770 private static class putMultiple_resultTupleScheme extends TupleScheme<putMultiple_result> {
7771
7772 @Override
7773 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7774 TTupleProtocol oprot = (TTupleProtocol) prot;
7775 BitSet optionals = new BitSet();
7776 if (struct.isSetIo()) {
7777 optionals.set(0);
7778 }
7779 oprot.writeBitSet(optionals, 1);
7780 if (struct.isSetIo()) {
7781 struct.io.write(oprot);
7782 }
7783 }
7784
7785 @Override
7786 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7787 TTupleProtocol iprot = (TTupleProtocol) prot;
7788 BitSet incoming = iprot.readBitSet(1);
7789 if (incoming.get(0)) {
7790 struct.io = new TIOError();
7791 struct.io.read(iprot);
7792 struct.setIoIsSet(true);
7793 }
7794 }
7795 }
7796
7797 }
7798
7799 public static class deleteSingle_args implements org.apache.thrift.TBase<deleteSingle_args, deleteSingle_args._Fields>, java.io.Serializable, Cloneable {
7800 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_args");
7801
7802 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
7803 private static final org.apache.thrift.protocol.TField DELETE_SINGLE_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteSingle", org.apache.thrift.protocol.TType.STRUCT, (short)2);
7804
7805 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7806 static {
7807 schemes.put(StandardScheme.class, new deleteSingle_argsStandardSchemeFactory());
7808 schemes.put(TupleScheme.class, new deleteSingle_argsTupleSchemeFactory());
7809 }
7810
7811
7812
7813
7814 public ByteBuffer table;
7815
7816
7817
7818 public TDelete deleteSingle;
7819
7820
7821 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7822
7823
7824
7825 TABLE((short)1, "table"),
7826
7827
7828
7829 DELETE_SINGLE((short)2, "deleteSingle");
7830
7831 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7832
7833 static {
7834 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7835 byName.put(field.getFieldName(), field);
7836 }
7837 }
7838
7839
7840
7841
7842 public static _Fields findByThriftId(int fieldId) {
7843 switch(fieldId) {
7844 case 1:
7845 return TABLE;
7846 case 2:
7847 return DELETE_SINGLE;
7848 default:
7849 return null;
7850 }
7851 }
7852
7853
7854
7855
7856
7857 public static _Fields findByThriftIdOrThrow(int fieldId) {
7858 _Fields fields = findByThriftId(fieldId);
7859 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7860 return fields;
7861 }
7862
7863
7864
7865
7866 public static _Fields findByName(String name) {
7867 return byName.get(name);
7868 }
7869
7870 private final short _thriftId;
7871 private final String _fieldName;
7872
7873 _Fields(short thriftId, String fieldName) {
7874 _thriftId = thriftId;
7875 _fieldName = fieldName;
7876 }
7877
7878 public short getThriftFieldId() {
7879 return _thriftId;
7880 }
7881
7882 public String getFieldName() {
7883 return _fieldName;
7884 }
7885 }
7886
7887
7888 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7889 static {
7890 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7891 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
7892 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
7893 tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED,
7894 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
7895 metaDataMap = Collections.unmodifiableMap(tmpMap);
7896 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_args.class, metaDataMap);
7897 }
7898
7899 public deleteSingle_args() {
7900 }
7901
7902 public deleteSingle_args(
7903 ByteBuffer table,
7904 TDelete deleteSingle)
7905 {
7906 this();
7907 this.table = table;
7908 this.deleteSingle = deleteSingle;
7909 }
7910
7911
7912
7913
7914 public deleteSingle_args(deleteSingle_args other) {
7915 if (other.isSetTable()) {
7916 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
7917 ;
7918 }
7919 if (other.isSetDeleteSingle()) {
7920 this.deleteSingle = new TDelete(other.deleteSingle);
7921 }
7922 }
7923
7924 public deleteSingle_args deepCopy() {
7925 return new deleteSingle_args(this);
7926 }
7927
7928 @Override
7929 public void clear() {
7930 this.table = null;
7931 this.deleteSingle = null;
7932 }
7933
7934
7935
7936
7937 public byte[] getTable() {
7938 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
7939 return table == null ? null : table.array();
7940 }
7941
7942 public ByteBuffer bufferForTable() {
7943 return table;
7944 }
7945
7946
7947
7948
7949 public deleteSingle_args setTable(byte[] table) {
7950 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
7951 return this;
7952 }
7953
7954 public deleteSingle_args setTable(ByteBuffer table) {
7955 this.table = table;
7956 return this;
7957 }
7958
7959 public void unsetTable() {
7960 this.table = null;
7961 }
7962
7963
7964 public boolean isSetTable() {
7965 return this.table != null;
7966 }
7967
7968 public void setTableIsSet(boolean value) {
7969 if (!value) {
7970 this.table = null;
7971 }
7972 }
7973
7974
7975
7976
7977 public TDelete getDeleteSingle() {
7978 return this.deleteSingle;
7979 }
7980
7981
7982
7983
7984 public deleteSingle_args setDeleteSingle(TDelete deleteSingle) {
7985 this.deleteSingle = deleteSingle;
7986 return this;
7987 }
7988
7989 public void unsetDeleteSingle() {
7990 this.deleteSingle = null;
7991 }
7992
7993
7994 public boolean isSetDeleteSingle() {
7995 return this.deleteSingle != null;
7996 }
7997
7998 public void setDeleteSingleIsSet(boolean value) {
7999 if (!value) {
8000 this.deleteSingle = null;
8001 }
8002 }
8003
8004 public void setFieldValue(_Fields field, Object value) {
8005 switch (field) {
8006 case TABLE:
8007 if (value == null) {
8008 unsetTable();
8009 } else {
8010 setTable((ByteBuffer)value);
8011 }
8012 break;
8013
8014 case DELETE_SINGLE:
8015 if (value == null) {
8016 unsetDeleteSingle();
8017 } else {
8018 setDeleteSingle((TDelete)value);
8019 }
8020 break;
8021
8022 }
8023 }
8024
8025 public Object getFieldValue(_Fields field) {
8026 switch (field) {
8027 case TABLE:
8028 return getTable();
8029
8030 case DELETE_SINGLE:
8031 return getDeleteSingle();
8032
8033 }
8034 throw new IllegalStateException();
8035 }
8036
8037
8038 public boolean isSet(_Fields field) {
8039 if (field == null) {
8040 throw new IllegalArgumentException();
8041 }
8042
8043 switch (field) {
8044 case TABLE:
8045 return isSetTable();
8046 case DELETE_SINGLE:
8047 return isSetDeleteSingle();
8048 }
8049 throw new IllegalStateException();
8050 }
8051
8052 @Override
8053 public boolean equals(Object that) {
8054 if (that == null)
8055 return false;
8056 if (that instanceof deleteSingle_args)
8057 return this.equals((deleteSingle_args)that);
8058 return false;
8059 }
8060
8061 public boolean equals(deleteSingle_args that) {
8062 if (that == null)
8063 return false;
8064
8065 boolean this_present_table = true && this.isSetTable();
8066 boolean that_present_table = true && that.isSetTable();
8067 if (this_present_table || that_present_table) {
8068 if (!(this_present_table && that_present_table))
8069 return false;
8070 if (!this.table.equals(that.table))
8071 return false;
8072 }
8073
8074 boolean this_present_deleteSingle = true && this.isSetDeleteSingle();
8075 boolean that_present_deleteSingle = true && that.isSetDeleteSingle();
8076 if (this_present_deleteSingle || that_present_deleteSingle) {
8077 if (!(this_present_deleteSingle && that_present_deleteSingle))
8078 return false;
8079 if (!this.deleteSingle.equals(that.deleteSingle))
8080 return false;
8081 }
8082
8083 return true;
8084 }
8085
8086 @Override
8087 public int hashCode() {
8088 HashCodeBuilder builder = new HashCodeBuilder();
8089
8090 boolean present_table = true && (isSetTable());
8091 builder.append(present_table);
8092 if (present_table)
8093 builder.append(table);
8094
8095 boolean present_deleteSingle = true && (isSetDeleteSingle());
8096 builder.append(present_deleteSingle);
8097 if (present_deleteSingle)
8098 builder.append(deleteSingle);
8099
8100 return builder.toHashCode();
8101 }
8102
8103 public int compareTo(deleteSingle_args other) {
8104 if (!getClass().equals(other.getClass())) {
8105 return getClass().getName().compareTo(other.getClass().getName());
8106 }
8107
8108 int lastComparison = 0;
8109 deleteSingle_args typedOther = (deleteSingle_args)other;
8110
8111 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
8112 if (lastComparison != 0) {
8113 return lastComparison;
8114 }
8115 if (isSetTable()) {
8116 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
8117 if (lastComparison != 0) {
8118 return lastComparison;
8119 }
8120 }
8121 lastComparison = Boolean.valueOf(isSetDeleteSingle()).compareTo(typedOther.isSetDeleteSingle());
8122 if (lastComparison != 0) {
8123 return lastComparison;
8124 }
8125 if (isSetDeleteSingle()) {
8126 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteSingle, typedOther.deleteSingle);
8127 if (lastComparison != 0) {
8128 return lastComparison;
8129 }
8130 }
8131 return 0;
8132 }
8133
8134 public _Fields fieldForId(int fieldId) {
8135 return _Fields.findByThriftId(fieldId);
8136 }
8137
8138 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8139 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8140 }
8141
8142 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8143 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8144 }
8145
8146 @Override
8147 public String toString() {
8148 StringBuilder sb = new StringBuilder("deleteSingle_args(");
8149 boolean first = true;
8150
8151 sb.append("table:");
8152 if (this.table == null) {
8153 sb.append("null");
8154 } else {
8155 org.apache.thrift.TBaseHelper.toString(this.table, sb);
8156 }
8157 first = false;
8158 if (!first) sb.append(", ");
8159 sb.append("deleteSingle:");
8160 if (this.deleteSingle == null) {
8161 sb.append("null");
8162 } else {
8163 sb.append(this.deleteSingle);
8164 }
8165 first = false;
8166 sb.append(")");
8167 return sb.toString();
8168 }
8169
8170 public void validate() throws org.apache.thrift.TException {
8171
8172 if (table == null) {
8173 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
8174 }
8175 if (deleteSingle == null) {
8176 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deleteSingle' was not present! Struct: " + toString());
8177 }
8178 }
8179
8180 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8181 try {
8182 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8183 } catch (org.apache.thrift.TException te) {
8184 throw new java.io.IOException(te);
8185 }
8186 }
8187
8188 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8189 try {
8190 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8191 } catch (org.apache.thrift.TException te) {
8192 throw new java.io.IOException(te);
8193 }
8194 }
8195
8196 private static class deleteSingle_argsStandardSchemeFactory implements SchemeFactory {
8197 public deleteSingle_argsStandardScheme getScheme() {
8198 return new deleteSingle_argsStandardScheme();
8199 }
8200 }
8201
8202 private static class deleteSingle_argsStandardScheme extends StandardScheme<deleteSingle_args> {
8203
8204 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_args struct) throws org.apache.thrift.TException {
8205 org.apache.thrift.protocol.TField schemeField;
8206 iprot.readStructBegin();
8207 while (true)
8208 {
8209 schemeField = iprot.readFieldBegin();
8210 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
8211 break;
8212 }
8213 switch (schemeField.id) {
8214 case 1:
8215 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
8216 struct.table = iprot.readBinary();
8217 struct.setTableIsSet(true);
8218 } else {
8219 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8220 }
8221 break;
8222 case 2:
8223 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
8224 struct.deleteSingle = new TDelete();
8225 struct.deleteSingle.read(iprot);
8226 struct.setDeleteSingleIsSet(true);
8227 } else {
8228 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8229 }
8230 break;
8231 default:
8232 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8233 }
8234 iprot.readFieldEnd();
8235 }
8236 iprot.readStructEnd();
8237
8238
8239 struct.validate();
8240 }
8241
8242 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_args struct) throws org.apache.thrift.TException {
8243 struct.validate();
8244
8245 oprot.writeStructBegin(STRUCT_DESC);
8246 if (struct.table != null) {
8247 oprot.writeFieldBegin(TABLE_FIELD_DESC);
8248 oprot.writeBinary(struct.table);
8249 oprot.writeFieldEnd();
8250 }
8251 if (struct.deleteSingle != null) {
8252 oprot.writeFieldBegin(DELETE_SINGLE_FIELD_DESC);
8253 struct.deleteSingle.write(oprot);
8254 oprot.writeFieldEnd();
8255 }
8256 oprot.writeFieldStop();
8257 oprot.writeStructEnd();
8258 }
8259
8260 }
8261
8262 private static class deleteSingle_argsTupleSchemeFactory implements SchemeFactory {
8263 public deleteSingle_argsTupleScheme getScheme() {
8264 return new deleteSingle_argsTupleScheme();
8265 }
8266 }
8267
8268 private static class deleteSingle_argsTupleScheme extends TupleScheme<deleteSingle_args> {
8269
8270 @Override
8271 public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
8272 TTupleProtocol oprot = (TTupleProtocol) prot;
8273 oprot.writeBinary(struct.table);
8274 struct.deleteSingle.write(oprot);
8275 }
8276
8277 @Override
8278 public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
8279 TTupleProtocol iprot = (TTupleProtocol) prot;
8280 struct.table = iprot.readBinary();
8281 struct.setTableIsSet(true);
8282 struct.deleteSingle = new TDelete();
8283 struct.deleteSingle.read(iprot);
8284 struct.setDeleteSingleIsSet(true);
8285 }
8286 }
8287
8288 }
8289
8290 public static class deleteSingle_result implements org.apache.thrift.TBase<deleteSingle_result, deleteSingle_result._Fields>, java.io.Serializable, Cloneable {
8291 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_result");
8292
8293 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
8294
8295 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8296 static {
8297 schemes.put(StandardScheme.class, new deleteSingle_resultStandardSchemeFactory());
8298 schemes.put(TupleScheme.class, new deleteSingle_resultTupleSchemeFactory());
8299 }
8300
8301 public TIOError io;
8302
8303
8304 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8305 IO((short)1, "io");
8306
8307 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8308
8309 static {
8310 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8311 byName.put(field.getFieldName(), field);
8312 }
8313 }
8314
8315
8316
8317
8318 public static _Fields findByThriftId(int fieldId) {
8319 switch(fieldId) {
8320 case 1:
8321 return IO;
8322 default:
8323 return null;
8324 }
8325 }
8326
8327
8328
8329
8330
8331 public static _Fields findByThriftIdOrThrow(int fieldId) {
8332 _Fields fields = findByThriftId(fieldId);
8333 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8334 return fields;
8335 }
8336
8337
8338
8339
8340 public static _Fields findByName(String name) {
8341 return byName.get(name);
8342 }
8343
8344 private final short _thriftId;
8345 private final String _fieldName;
8346
8347 _Fields(short thriftId, String fieldName) {
8348 _thriftId = thriftId;
8349 _fieldName = fieldName;
8350 }
8351
8352 public short getThriftFieldId() {
8353 return _thriftId;
8354 }
8355
8356 public String getFieldName() {
8357 return _fieldName;
8358 }
8359 }
8360
8361
8362 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8363 static {
8364 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8365 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
8366 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
8367 metaDataMap = Collections.unmodifiableMap(tmpMap);
8368 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_result.class, metaDataMap);
8369 }
8370
8371 public deleteSingle_result() {
8372 }
8373
8374 public deleteSingle_result(
8375 TIOError io)
8376 {
8377 this();
8378 this.io = io;
8379 }
8380
8381
8382
8383
8384 public deleteSingle_result(deleteSingle_result other) {
8385 if (other.isSetIo()) {
8386 this.io = new TIOError(other.io);
8387 }
8388 }
8389
8390 public deleteSingle_result deepCopy() {
8391 return new deleteSingle_result(this);
8392 }
8393
8394 @Override
8395 public void clear() {
8396 this.io = null;
8397 }
8398
8399 public TIOError getIo() {
8400 return this.io;
8401 }
8402
8403 public deleteSingle_result setIo(TIOError io) {
8404 this.io = io;
8405 return this;
8406 }
8407
8408 public void unsetIo() {
8409 this.io = null;
8410 }
8411
8412
8413 public boolean isSetIo() {
8414 return this.io != null;
8415 }
8416
8417 public void setIoIsSet(boolean value) {
8418 if (!value) {
8419 this.io = null;
8420 }
8421 }
8422
8423 public void setFieldValue(_Fields field, Object value) {
8424 switch (field) {
8425 case IO:
8426 if (value == null) {
8427 unsetIo();
8428 } else {
8429 setIo((TIOError)value);
8430 }
8431 break;
8432
8433 }
8434 }
8435
8436 public Object getFieldValue(_Fields field) {
8437 switch (field) {
8438 case IO:
8439 return getIo();
8440
8441 }
8442 throw new IllegalStateException();
8443 }
8444
8445
8446 public boolean isSet(_Fields field) {
8447 if (field == null) {
8448 throw new IllegalArgumentException();
8449 }
8450
8451 switch (field) {
8452 case IO:
8453 return isSetIo();
8454 }
8455 throw new IllegalStateException();
8456 }
8457
8458 @Override
8459 public boolean equals(Object that) {
8460 if (that == null)
8461 return false;
8462 if (that instanceof deleteSingle_result)
8463 return this.equals((deleteSingle_result)that);
8464 return false;
8465 }
8466
8467 public boolean equals(deleteSingle_result that) {
8468 if (that == null)
8469 return false;
8470
8471 boolean this_present_io = true && this.isSetIo();
8472 boolean that_present_io = true && that.isSetIo();
8473 if (this_present_io || that_present_io) {
8474 if (!(this_present_io && that_present_io))
8475 return false;
8476 if (!this.io.equals(that.io))
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_io = true && (isSetIo());
8488 builder.append(present_io);
8489 if (present_io)
8490 builder.append(io);
8491
8492 return builder.toHashCode();
8493 }
8494
8495 public int compareTo(deleteSingle_result other) {
8496 if (!getClass().equals(other.getClass())) {
8497 return getClass().getName().compareTo(other.getClass().getName());
8498 }
8499
8500 int lastComparison = 0;
8501 deleteSingle_result typedOther = (deleteSingle_result)other;
8502
8503 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
8504 if (lastComparison != 0) {
8505 return lastComparison;
8506 }
8507 if (isSetIo()) {
8508 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
8509 if (lastComparison != 0) {
8510 return lastComparison;
8511 }
8512 }
8513 return 0;
8514 }
8515
8516 public _Fields fieldForId(int fieldId) {
8517 return _Fields.findByThriftId(fieldId);
8518 }
8519
8520 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8521 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8522 }
8523
8524 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8525 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8526 }
8527
8528 @Override
8529 public String toString() {
8530 StringBuilder sb = new StringBuilder("deleteSingle_result(");
8531 boolean first = true;
8532
8533 sb.append("io:");
8534 if (this.io == null) {
8535 sb.append("null");
8536 } else {
8537 sb.append(this.io);
8538 }
8539 first = false;
8540 sb.append(")");
8541 return sb.toString();
8542 }
8543
8544 public void validate() throws org.apache.thrift.TException {
8545
8546 }
8547
8548 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8549 try {
8550 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8551 } catch (org.apache.thrift.TException te) {
8552 throw new java.io.IOException(te);
8553 }
8554 }
8555
8556 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8557 try {
8558 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8559 } catch (org.apache.thrift.TException te) {
8560 throw new java.io.IOException(te);
8561 }
8562 }
8563
8564 private static class deleteSingle_resultStandardSchemeFactory implements SchemeFactory {
8565 public deleteSingle_resultStandardScheme getScheme() {
8566 return new deleteSingle_resultStandardScheme();
8567 }
8568 }
8569
8570 private static class deleteSingle_resultStandardScheme extends StandardScheme<deleteSingle_result> {
8571
8572 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8573 org.apache.thrift.protocol.TField schemeField;
8574 iprot.readStructBegin();
8575 while (true)
8576 {
8577 schemeField = iprot.readFieldBegin();
8578 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
8579 break;
8580 }
8581 switch (schemeField.id) {
8582 case 1:
8583 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
8584 struct.io = new TIOError();
8585 struct.io.read(iprot);
8586 struct.setIoIsSet(true);
8587 } else {
8588 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8589 }
8590 break;
8591 default:
8592 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8593 }
8594 iprot.readFieldEnd();
8595 }
8596 iprot.readStructEnd();
8597
8598
8599 struct.validate();
8600 }
8601
8602 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8603 struct.validate();
8604
8605 oprot.writeStructBegin(STRUCT_DESC);
8606 if (struct.io != null) {
8607 oprot.writeFieldBegin(IO_FIELD_DESC);
8608 struct.io.write(oprot);
8609 oprot.writeFieldEnd();
8610 }
8611 oprot.writeFieldStop();
8612 oprot.writeStructEnd();
8613 }
8614
8615 }
8616
8617 private static class deleteSingle_resultTupleSchemeFactory implements SchemeFactory {
8618 public deleteSingle_resultTupleScheme getScheme() {
8619 return new deleteSingle_resultTupleScheme();
8620 }
8621 }
8622
8623 private static class deleteSingle_resultTupleScheme extends TupleScheme<deleteSingle_result> {
8624
8625 @Override
8626 public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8627 TTupleProtocol oprot = (TTupleProtocol) prot;
8628 BitSet optionals = new BitSet();
8629 if (struct.isSetIo()) {
8630 optionals.set(0);
8631 }
8632 oprot.writeBitSet(optionals, 1);
8633 if (struct.isSetIo()) {
8634 struct.io.write(oprot);
8635 }
8636 }
8637
8638 @Override
8639 public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8640 TTupleProtocol iprot = (TTupleProtocol) prot;
8641 BitSet incoming = iprot.readBitSet(1);
8642 if (incoming.get(0)) {
8643 struct.io = new TIOError();
8644 struct.io.read(iprot);
8645 struct.setIoIsSet(true);
8646 }
8647 }
8648 }
8649
8650 }
8651
8652 public static class deleteMultiple_args implements org.apache.thrift.TBase<deleteMultiple_args, deleteMultiple_args._Fields>, java.io.Serializable, Cloneable {
8653 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_args");
8654
8655 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
8656 private static final org.apache.thrift.protocol.TField DELETES_FIELD_DESC = new org.apache.thrift.protocol.TField("deletes", org.apache.thrift.protocol.TType.LIST, (short)2);
8657
8658 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8659 static {
8660 schemes.put(StandardScheme.class, new deleteMultiple_argsStandardSchemeFactory());
8661 schemes.put(TupleScheme.class, new deleteMultiple_argsTupleSchemeFactory());
8662 }
8663
8664
8665
8666
8667 public ByteBuffer table;
8668
8669
8670
8671 public List<TDelete> deletes;
8672
8673
8674 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8675
8676
8677
8678 TABLE((short)1, "table"),
8679
8680
8681
8682 DELETES((short)2, "deletes");
8683
8684 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8685
8686 static {
8687 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8688 byName.put(field.getFieldName(), field);
8689 }
8690 }
8691
8692
8693
8694
8695 public static _Fields findByThriftId(int fieldId) {
8696 switch(fieldId) {
8697 case 1:
8698 return TABLE;
8699 case 2:
8700 return DELETES;
8701 default:
8702 return null;
8703 }
8704 }
8705
8706
8707
8708
8709
8710 public static _Fields findByThriftIdOrThrow(int fieldId) {
8711 _Fields fields = findByThriftId(fieldId);
8712 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8713 return fields;
8714 }
8715
8716
8717
8718
8719 public static _Fields findByName(String name) {
8720 return byName.get(name);
8721 }
8722
8723 private final short _thriftId;
8724 private final String _fieldName;
8725
8726 _Fields(short thriftId, String fieldName) {
8727 _thriftId = thriftId;
8728 _fieldName = fieldName;
8729 }
8730
8731 public short getThriftFieldId() {
8732 return _thriftId;
8733 }
8734
8735 public String getFieldName() {
8736 return _fieldName;
8737 }
8738 }
8739
8740
8741 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8742 static {
8743 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8744 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
8745 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
8746 tmpMap.put(_Fields.DELETES, new org.apache.thrift.meta_data.FieldMetaData("deletes", org.apache.thrift.TFieldRequirementType.REQUIRED,
8747 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
8748 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
8749 metaDataMap = Collections.unmodifiableMap(tmpMap);
8750 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_args.class, metaDataMap);
8751 }
8752
8753 public deleteMultiple_args() {
8754 }
8755
8756 public deleteMultiple_args(
8757 ByteBuffer table,
8758 List<TDelete> deletes)
8759 {
8760 this();
8761 this.table = table;
8762 this.deletes = deletes;
8763 }
8764
8765
8766
8767
8768 public deleteMultiple_args(deleteMultiple_args other) {
8769 if (other.isSetTable()) {
8770 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
8771 ;
8772 }
8773 if (other.isSetDeletes()) {
8774 List<TDelete> __this__deletes = new ArrayList<TDelete>();
8775 for (TDelete other_element : other.deletes) {
8776 __this__deletes.add(new TDelete(other_element));
8777 }
8778 this.deletes = __this__deletes;
8779 }
8780 }
8781
8782 public deleteMultiple_args deepCopy() {
8783 return new deleteMultiple_args(this);
8784 }
8785
8786 @Override
8787 public void clear() {
8788 this.table = null;
8789 this.deletes = null;
8790 }
8791
8792
8793
8794
8795 public byte[] getTable() {
8796 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
8797 return table == null ? null : table.array();
8798 }
8799
8800 public ByteBuffer bufferForTable() {
8801 return table;
8802 }
8803
8804
8805
8806
8807 public deleteMultiple_args setTable(byte[] table) {
8808 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
8809 return this;
8810 }
8811
8812 public deleteMultiple_args setTable(ByteBuffer table) {
8813 this.table = table;
8814 return this;
8815 }
8816
8817 public void unsetTable() {
8818 this.table = null;
8819 }
8820
8821
8822 public boolean isSetTable() {
8823 return this.table != null;
8824 }
8825
8826 public void setTableIsSet(boolean value) {
8827 if (!value) {
8828 this.table = null;
8829 }
8830 }
8831
8832 public int getDeletesSize() {
8833 return (this.deletes == null) ? 0 : this.deletes.size();
8834 }
8835
8836 public java.util.Iterator<TDelete> getDeletesIterator() {
8837 return (this.deletes == null) ? null : this.deletes.iterator();
8838 }
8839
8840 public void addToDeletes(TDelete elem) {
8841 if (this.deletes == null) {
8842 this.deletes = new ArrayList<TDelete>();
8843 }
8844 this.deletes.add(elem);
8845 }
8846
8847
8848
8849
8850 public List<TDelete> getDeletes() {
8851 return this.deletes;
8852 }
8853
8854
8855
8856
8857 public deleteMultiple_args setDeletes(List<TDelete> deletes) {
8858 this.deletes = deletes;
8859 return this;
8860 }
8861
8862 public void unsetDeletes() {
8863 this.deletes = null;
8864 }
8865
8866
8867 public boolean isSetDeletes() {
8868 return this.deletes != null;
8869 }
8870
8871 public void setDeletesIsSet(boolean value) {
8872 if (!value) {
8873 this.deletes = null;
8874 }
8875 }
8876
8877 public void setFieldValue(_Fields field, Object value) {
8878 switch (field) {
8879 case TABLE:
8880 if (value == null) {
8881 unsetTable();
8882 } else {
8883 setTable((ByteBuffer)value);
8884 }
8885 break;
8886
8887 case DELETES:
8888 if (value == null) {
8889 unsetDeletes();
8890 } else {
8891 setDeletes((List<TDelete>)value);
8892 }
8893 break;
8894
8895 }
8896 }
8897
8898 public Object getFieldValue(_Fields field) {
8899 switch (field) {
8900 case TABLE:
8901 return getTable();
8902
8903 case DELETES:
8904 return getDeletes();
8905
8906 }
8907 throw new IllegalStateException();
8908 }
8909
8910
8911 public boolean isSet(_Fields field) {
8912 if (field == null) {
8913 throw new IllegalArgumentException();
8914 }
8915
8916 switch (field) {
8917 case TABLE:
8918 return isSetTable();
8919 case DELETES:
8920 return isSetDeletes();
8921 }
8922 throw new IllegalStateException();
8923 }
8924
8925 @Override
8926 public boolean equals(Object that) {
8927 if (that == null)
8928 return false;
8929 if (that instanceof deleteMultiple_args)
8930 return this.equals((deleteMultiple_args)that);
8931 return false;
8932 }
8933
8934 public boolean equals(deleteMultiple_args that) {
8935 if (that == null)
8936 return false;
8937
8938 boolean this_present_table = true && this.isSetTable();
8939 boolean that_present_table = true && that.isSetTable();
8940 if (this_present_table || that_present_table) {
8941 if (!(this_present_table && that_present_table))
8942 return false;
8943 if (!this.table.equals(that.table))
8944 return false;
8945 }
8946
8947 boolean this_present_deletes = true && this.isSetDeletes();
8948 boolean that_present_deletes = true && that.isSetDeletes();
8949 if (this_present_deletes || that_present_deletes) {
8950 if (!(this_present_deletes && that_present_deletes))
8951 return false;
8952 if (!this.deletes.equals(that.deletes))
8953 return false;
8954 }
8955
8956 return true;
8957 }
8958
8959 @Override
8960 public int hashCode() {
8961 HashCodeBuilder builder = new HashCodeBuilder();
8962
8963 boolean present_table = true && (isSetTable());
8964 builder.append(present_table);
8965 if (present_table)
8966 builder.append(table);
8967
8968 boolean present_deletes = true && (isSetDeletes());
8969 builder.append(present_deletes);
8970 if (present_deletes)
8971 builder.append(deletes);
8972
8973 return builder.toHashCode();
8974 }
8975
8976 public int compareTo(deleteMultiple_args other) {
8977 if (!getClass().equals(other.getClass())) {
8978 return getClass().getName().compareTo(other.getClass().getName());
8979 }
8980
8981 int lastComparison = 0;
8982 deleteMultiple_args typedOther = (deleteMultiple_args)other;
8983
8984 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
8985 if (lastComparison != 0) {
8986 return lastComparison;
8987 }
8988 if (isSetTable()) {
8989 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
8990 if (lastComparison != 0) {
8991 return lastComparison;
8992 }
8993 }
8994 lastComparison = Boolean.valueOf(isSetDeletes()).compareTo(typedOther.isSetDeletes());
8995 if (lastComparison != 0) {
8996 return lastComparison;
8997 }
8998 if (isSetDeletes()) {
8999 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deletes, typedOther.deletes);
9000 if (lastComparison != 0) {
9001 return lastComparison;
9002 }
9003 }
9004 return 0;
9005 }
9006
9007 public _Fields fieldForId(int fieldId) {
9008 return _Fields.findByThriftId(fieldId);
9009 }
9010
9011 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
9012 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
9013 }
9014
9015 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
9016 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
9017 }
9018
9019 @Override
9020 public String toString() {
9021 StringBuilder sb = new StringBuilder("deleteMultiple_args(");
9022 boolean first = true;
9023
9024 sb.append("table:");
9025 if (this.table == null) {
9026 sb.append("null");
9027 } else {
9028 org.apache.thrift.TBaseHelper.toString(this.table, sb);
9029 }
9030 first = false;
9031 if (!first) sb.append(", ");
9032 sb.append("deletes:");
9033 if (this.deletes == null) {
9034 sb.append("null");
9035 } else {
9036 sb.append(this.deletes);
9037 }
9038 first = false;
9039 sb.append(")");
9040 return sb.toString();
9041 }
9042
9043 public void validate() throws org.apache.thrift.TException {
9044
9045 if (table == null) {
9046 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
9047 }
9048 if (deletes == null) {
9049 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deletes' was not present! Struct: " + toString());
9050 }
9051 }
9052
9053 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
9054 try {
9055 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
9056 } catch (org.apache.thrift.TException te) {
9057 throw new java.io.IOException(te);
9058 }
9059 }
9060
9061 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
9062 try {
9063 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
9064 } catch (org.apache.thrift.TException te) {
9065 throw new java.io.IOException(te);
9066 }
9067 }
9068
9069 private static class deleteMultiple_argsStandardSchemeFactory implements SchemeFactory {
9070 public deleteMultiple_argsStandardScheme getScheme() {
9071 return new deleteMultiple_argsStandardScheme();
9072 }
9073 }
9074
9075 private static class deleteMultiple_argsStandardScheme extends StandardScheme<deleteMultiple_args> {
9076
9077 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
9078 org.apache.thrift.protocol.TField schemeField;
9079 iprot.readStructBegin();
9080 while (true)
9081 {
9082 schemeField = iprot.readFieldBegin();
9083 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
9084 break;
9085 }
9086 switch (schemeField.id) {
9087 case 1:
9088 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
9089 struct.table = iprot.readBinary();
9090 struct.setTableIsSet(true);
9091 } else {
9092 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9093 }
9094 break;
9095 case 2:
9096 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
9097 {
9098 org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
9099 struct.deletes = new ArrayList<TDelete>(_list120.size);
9100 for (int _i121 = 0; _i121 < _list120.size; ++_i121)
9101 {
9102 TDelete _elem122;
9103 _elem122 = new TDelete();
9104 _elem122.read(iprot);
9105 struct.deletes.add(_elem122);
9106 }
9107 iprot.readListEnd();
9108 }
9109 struct.setDeletesIsSet(true);
9110 } else {
9111 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9112 }
9113 break;
9114 default:
9115 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9116 }
9117 iprot.readFieldEnd();
9118 }
9119 iprot.readStructEnd();
9120
9121
9122 struct.validate();
9123 }
9124
9125 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
9126 struct.validate();
9127
9128 oprot.writeStructBegin(STRUCT_DESC);
9129 if (struct.table != null) {
9130 oprot.writeFieldBegin(TABLE_FIELD_DESC);
9131 oprot.writeBinary(struct.table);
9132 oprot.writeFieldEnd();
9133 }
9134 if (struct.deletes != null) {
9135 oprot.writeFieldBegin(DELETES_FIELD_DESC);
9136 {
9137 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.deletes.size()));
9138 for (TDelete _iter123 : struct.deletes)
9139 {
9140 _iter123.write(oprot);
9141 }
9142 oprot.writeListEnd();
9143 }
9144 oprot.writeFieldEnd();
9145 }
9146 oprot.writeFieldStop();
9147 oprot.writeStructEnd();
9148 }
9149
9150 }
9151
9152 private static class deleteMultiple_argsTupleSchemeFactory implements SchemeFactory {
9153 public deleteMultiple_argsTupleScheme getScheme() {
9154 return new deleteMultiple_argsTupleScheme();
9155 }
9156 }
9157
9158 private static class deleteMultiple_argsTupleScheme extends TupleScheme<deleteMultiple_args> {
9159
9160 @Override
9161 public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
9162 TTupleProtocol oprot = (TTupleProtocol) prot;
9163 oprot.writeBinary(struct.table);
9164 {
9165 oprot.writeI32(struct.deletes.size());
9166 for (TDelete _iter124 : struct.deletes)
9167 {
9168 _iter124.write(oprot);
9169 }
9170 }
9171 }
9172
9173 @Override
9174 public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
9175 TTupleProtocol iprot = (TTupleProtocol) prot;
9176 struct.table = iprot.readBinary();
9177 struct.setTableIsSet(true);
9178 {
9179 org.apache.thrift.protocol.TList _list125 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
9180 struct.deletes = new ArrayList<TDelete>(_list125.size);
9181 for (int _i126 = 0; _i126 < _list125.size; ++_i126)
9182 {
9183 TDelete _elem127;
9184 _elem127 = new TDelete();
9185 _elem127.read(iprot);
9186 struct.deletes.add(_elem127);
9187 }
9188 }
9189 struct.setDeletesIsSet(true);
9190 }
9191 }
9192
9193 }
9194
9195 public static class deleteMultiple_result implements org.apache.thrift.TBase<deleteMultiple_result, deleteMultiple_result._Fields>, java.io.Serializable, Cloneable {
9196 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_result");
9197
9198 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
9199 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
9200
9201 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
9202 static {
9203 schemes.put(StandardScheme.class, new deleteMultiple_resultStandardSchemeFactory());
9204 schemes.put(TupleScheme.class, new deleteMultiple_resultTupleSchemeFactory());
9205 }
9206
9207 public List<TDelete> success;
9208 public TIOError io;
9209
9210
9211 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
9212 SUCCESS((short)0, "success"),
9213 IO((short)1, "io");
9214
9215 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9216
9217 static {
9218 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9219 byName.put(field.getFieldName(), field);
9220 }
9221 }
9222
9223
9224
9225
9226 public static _Fields findByThriftId(int fieldId) {
9227 switch(fieldId) {
9228 case 0:
9229 return SUCCESS;
9230 case 1:
9231 return IO;
9232 default:
9233 return null;
9234 }
9235 }
9236
9237
9238
9239
9240
9241 public static _Fields findByThriftIdOrThrow(int fieldId) {
9242 _Fields fields = findByThriftId(fieldId);
9243 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9244 return fields;
9245 }
9246
9247
9248
9249
9250 public static _Fields findByName(String name) {
9251 return byName.get(name);
9252 }
9253
9254 private final short _thriftId;
9255 private final String _fieldName;
9256
9257 _Fields(short thriftId, String fieldName) {
9258 _thriftId = thriftId;
9259 _fieldName = fieldName;
9260 }
9261
9262 public short getThriftFieldId() {
9263 return _thriftId;
9264 }
9265
9266 public String getFieldName() {
9267 return _fieldName;
9268 }
9269 }
9270
9271
9272 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
9273 static {
9274 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
9275 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
9276 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
9277 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
9278 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
9279 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
9280 metaDataMap = Collections.unmodifiableMap(tmpMap);
9281 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_result.class, metaDataMap);
9282 }
9283
9284 public deleteMultiple_result() {
9285 }
9286
9287 public deleteMultiple_result(
9288 List<TDelete> success,
9289 TIOError io)
9290 {
9291 this();
9292 this.success = success;
9293 this.io = io;
9294 }
9295
9296
9297
9298
9299 public deleteMultiple_result(deleteMultiple_result other) {
9300 if (other.isSetSuccess()) {
9301 List<TDelete> __this__success = new ArrayList<TDelete>();
9302 for (TDelete other_element : other.success) {
9303 __this__success.add(new TDelete(other_element));
9304 }
9305 this.success = __this__success;
9306 }
9307 if (other.isSetIo()) {
9308 this.io = new TIOError(other.io);
9309 }
9310 }
9311
9312 public deleteMultiple_result deepCopy() {
9313 return new deleteMultiple_result(this);
9314 }
9315
9316 @Override
9317 public void clear() {
9318 this.success = null;
9319 this.io = null;
9320 }
9321
9322 public int getSuccessSize() {
9323 return (this.success == null) ? 0 : this.success.size();
9324 }
9325
9326 public java.util.Iterator<TDelete> getSuccessIterator() {
9327 return (this.success == null) ? null : this.success.iterator();
9328 }
9329
9330 public void addToSuccess(TDelete elem) {
9331 if (this.success == null) {
9332 this.success = new ArrayList<TDelete>();
9333 }
9334 this.success.add(elem);
9335 }
9336
9337 public List<TDelete> getSuccess() {
9338 return this.success;
9339 }
9340
9341 public deleteMultiple_result setSuccess(List<TDelete> success) {
9342 this.success = success;
9343 return this;
9344 }
9345
9346 public void unsetSuccess() {
9347 this.success = null;
9348 }
9349
9350
9351 public boolean isSetSuccess() {
9352 return this.success != null;
9353 }
9354
9355 public void setSuccessIsSet(boolean value) {
9356 if (!value) {
9357 this.success = null;
9358 }
9359 }
9360
9361 public TIOError getIo() {
9362 return this.io;
9363 }
9364
9365 public deleteMultiple_result setIo(TIOError io) {
9366 this.io = io;
9367 return this;
9368 }
9369
9370 public void unsetIo() {
9371 this.io = null;
9372 }
9373
9374
9375 public boolean isSetIo() {
9376 return this.io != null;
9377 }
9378
9379 public void setIoIsSet(boolean value) {
9380 if (!value) {
9381 this.io = null;
9382 }
9383 }
9384
9385 public void setFieldValue(_Fields field, Object value) {
9386 switch (field) {
9387 case SUCCESS:
9388 if (value == null) {
9389 unsetSuccess();
9390 } else {
9391 setSuccess((List<TDelete>)value);
9392 }
9393 break;
9394
9395 case IO:
9396 if (value == null) {
9397 unsetIo();
9398 } else {
9399 setIo((TIOError)value);
9400 }
9401 break;
9402
9403 }
9404 }
9405
9406 public Object getFieldValue(_Fields field) {
9407 switch (field) {
9408 case SUCCESS:
9409 return getSuccess();
9410
9411 case IO:
9412 return getIo();
9413
9414 }
9415 throw new IllegalStateException();
9416 }
9417
9418
9419 public boolean isSet(_Fields field) {
9420 if (field == null) {
9421 throw new IllegalArgumentException();
9422 }
9423
9424 switch (field) {
9425 case SUCCESS:
9426 return isSetSuccess();
9427 case IO:
9428 return isSetIo();
9429 }
9430 throw new IllegalStateException();
9431 }
9432
9433 @Override
9434 public boolean equals(Object that) {
9435 if (that == null)
9436 return false;
9437 if (that instanceof deleteMultiple_result)
9438 return this.equals((deleteMultiple_result)that);
9439 return false;
9440 }
9441
9442 public boolean equals(deleteMultiple_result that) {
9443 if (that == null)
9444 return false;
9445
9446 boolean this_present_success = true && this.isSetSuccess();
9447 boolean that_present_success = true && that.isSetSuccess();
9448 if (this_present_success || that_present_success) {
9449 if (!(this_present_success && that_present_success))
9450 return false;
9451 if (!this.success.equals(that.success))
9452 return false;
9453 }
9454
9455 boolean this_present_io = true && this.isSetIo();
9456 boolean that_present_io = true && that.isSetIo();
9457 if (this_present_io || that_present_io) {
9458 if (!(this_present_io && that_present_io))
9459 return false;
9460 if (!this.io.equals(that.io))
9461 return false;
9462 }
9463
9464 return true;
9465 }
9466
9467 @Override
9468 public int hashCode() {
9469 HashCodeBuilder builder = new HashCodeBuilder();
9470
9471 boolean present_success = true && (isSetSuccess());
9472 builder.append(present_success);
9473 if (present_success)
9474 builder.append(success);
9475
9476 boolean present_io = true && (isSetIo());
9477 builder.append(present_io);
9478 if (present_io)
9479 builder.append(io);
9480
9481 return builder.toHashCode();
9482 }
9483
9484 public int compareTo(deleteMultiple_result other) {
9485 if (!getClass().equals(other.getClass())) {
9486 return getClass().getName().compareTo(other.getClass().getName());
9487 }
9488
9489 int lastComparison = 0;
9490 deleteMultiple_result typedOther = (deleteMultiple_result)other;
9491
9492 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
9493 if (lastComparison != 0) {
9494 return lastComparison;
9495 }
9496 if (isSetSuccess()) {
9497 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
9498 if (lastComparison != 0) {
9499 return lastComparison;
9500 }
9501 }
9502 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
9503 if (lastComparison != 0) {
9504 return lastComparison;
9505 }
9506 if (isSetIo()) {
9507 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
9508 if (lastComparison != 0) {
9509 return lastComparison;
9510 }
9511 }
9512 return 0;
9513 }
9514
9515 public _Fields fieldForId(int fieldId) {
9516 return _Fields.findByThriftId(fieldId);
9517 }
9518
9519 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
9520 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
9521 }
9522
9523 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
9524 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
9525 }
9526
9527 @Override
9528 public String toString() {
9529 StringBuilder sb = new StringBuilder("deleteMultiple_result(");
9530 boolean first = true;
9531
9532 sb.append("success:");
9533 if (this.success == null) {
9534 sb.append("null");
9535 } else {
9536 sb.append(this.success);
9537 }
9538 first = false;
9539 if (!first) sb.append(", ");
9540 sb.append("io:");
9541 if (this.io == null) {
9542 sb.append("null");
9543 } else {
9544 sb.append(this.io);
9545 }
9546 first = false;
9547 sb.append(")");
9548 return sb.toString();
9549 }
9550
9551 public void validate() throws org.apache.thrift.TException {
9552
9553 }
9554
9555 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
9556 try {
9557 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
9558 } catch (org.apache.thrift.TException te) {
9559 throw new java.io.IOException(te);
9560 }
9561 }
9562
9563 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
9564 try {
9565 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
9566 } catch (org.apache.thrift.TException te) {
9567 throw new java.io.IOException(te);
9568 }
9569 }
9570
9571 private static class deleteMultiple_resultStandardSchemeFactory implements SchemeFactory {
9572 public deleteMultiple_resultStandardScheme getScheme() {
9573 return new deleteMultiple_resultStandardScheme();
9574 }
9575 }
9576
9577 private static class deleteMultiple_resultStandardScheme extends StandardScheme<deleteMultiple_result> {
9578
9579 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9580 org.apache.thrift.protocol.TField schemeField;
9581 iprot.readStructBegin();
9582 while (true)
9583 {
9584 schemeField = iprot.readFieldBegin();
9585 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
9586 break;
9587 }
9588 switch (schemeField.id) {
9589 case 0:
9590 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
9591 {
9592 org.apache.thrift.protocol.TList _list128 = iprot.readListBegin();
9593 struct.success = new ArrayList<TDelete>(_list128.size);
9594 for (int _i129 = 0; _i129 < _list128.size; ++_i129)
9595 {
9596 TDelete _elem130;
9597 _elem130 = new TDelete();
9598 _elem130.read(iprot);
9599 struct.success.add(_elem130);
9600 }
9601 iprot.readListEnd();
9602 }
9603 struct.setSuccessIsSet(true);
9604 } else {
9605 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9606 }
9607 break;
9608 case 1:
9609 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
9610 struct.io = new TIOError();
9611 struct.io.read(iprot);
9612 struct.setIoIsSet(true);
9613 } else {
9614 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9615 }
9616 break;
9617 default:
9618 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9619 }
9620 iprot.readFieldEnd();
9621 }
9622 iprot.readStructEnd();
9623
9624
9625 struct.validate();
9626 }
9627
9628 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9629 struct.validate();
9630
9631 oprot.writeStructBegin(STRUCT_DESC);
9632 if (struct.success != null) {
9633 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
9634 {
9635 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
9636 for (TDelete _iter131 : struct.success)
9637 {
9638 _iter131.write(oprot);
9639 }
9640 oprot.writeListEnd();
9641 }
9642 oprot.writeFieldEnd();
9643 }
9644 if (struct.io != null) {
9645 oprot.writeFieldBegin(IO_FIELD_DESC);
9646 struct.io.write(oprot);
9647 oprot.writeFieldEnd();
9648 }
9649 oprot.writeFieldStop();
9650 oprot.writeStructEnd();
9651 }
9652
9653 }
9654
9655 private static class deleteMultiple_resultTupleSchemeFactory implements SchemeFactory {
9656 public deleteMultiple_resultTupleScheme getScheme() {
9657 return new deleteMultiple_resultTupleScheme();
9658 }
9659 }
9660
9661 private static class deleteMultiple_resultTupleScheme extends TupleScheme<deleteMultiple_result> {
9662
9663 @Override
9664 public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9665 TTupleProtocol oprot = (TTupleProtocol) prot;
9666 BitSet optionals = new BitSet();
9667 if (struct.isSetSuccess()) {
9668 optionals.set(0);
9669 }
9670 if (struct.isSetIo()) {
9671 optionals.set(1);
9672 }
9673 oprot.writeBitSet(optionals, 2);
9674 if (struct.isSetSuccess()) {
9675 {
9676 oprot.writeI32(struct.success.size());
9677 for (TDelete _iter132 : struct.success)
9678 {
9679 _iter132.write(oprot);
9680 }
9681 }
9682 }
9683 if (struct.isSetIo()) {
9684 struct.io.write(oprot);
9685 }
9686 }
9687
9688 @Override
9689 public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9690 TTupleProtocol iprot = (TTupleProtocol) prot;
9691 BitSet incoming = iprot.readBitSet(2);
9692 if (incoming.get(0)) {
9693 {
9694 org.apache.thrift.protocol.TList _list133 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
9695 struct.success = new ArrayList<TDelete>(_list133.size);
9696 for (int _i134 = 0; _i134 < _list133.size; ++_i134)
9697 {
9698 TDelete _elem135;
9699 _elem135 = new TDelete();
9700 _elem135.read(iprot);
9701 struct.success.add(_elem135);
9702 }
9703 }
9704 struct.setSuccessIsSet(true);
9705 }
9706 if (incoming.get(1)) {
9707 struct.io = new TIOError();
9708 struct.io.read(iprot);
9709 struct.setIoIsSet(true);
9710 }
9711 }
9712 }
9713
9714 }
9715
9716 public static class checkAndDelete_args implements org.apache.thrift.TBase<checkAndDelete_args, checkAndDelete_args._Fields>, java.io.Serializable, Cloneable {
9717 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_args");
9718
9719 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
9720 private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2);
9721 private static final org.apache.thrift.protocol.TField FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)3);
9722 private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)4);
9723 private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)5);
9724 private static final org.apache.thrift.protocol.TField DELETE_SINGLE_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteSingle", org.apache.thrift.protocol.TType.STRUCT, (short)6);
9725
9726 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
9727 static {
9728 schemes.put(StandardScheme.class, new checkAndDelete_argsStandardSchemeFactory());
9729 schemes.put(TupleScheme.class, new checkAndDelete_argsTupleSchemeFactory());
9730 }
9731
9732
9733
9734
9735 public ByteBuffer table;
9736
9737
9738
9739 public ByteBuffer row;
9740
9741
9742
9743 public ByteBuffer family;
9744
9745
9746
9747 public ByteBuffer qualifier;
9748
9749
9750
9751
9752
9753 public ByteBuffer value;
9754
9755
9756
9757 public TDelete deleteSingle;
9758
9759
9760 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
9761
9762
9763
9764 TABLE((short)1, "table"),
9765
9766
9767
9768 ROW((short)2, "row"),
9769
9770
9771
9772 FAMILY((short)3, "family"),
9773
9774
9775
9776 QUALIFIER((short)4, "qualifier"),
9777
9778
9779
9780
9781
9782 VALUE((short)5, "value"),
9783
9784
9785
9786 DELETE_SINGLE((short)6, "deleteSingle");
9787
9788 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9789
9790 static {
9791 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9792 byName.put(field.getFieldName(), field);
9793 }
9794 }
9795
9796
9797
9798
9799 public static _Fields findByThriftId(int fieldId) {
9800 switch(fieldId) {
9801 case 1:
9802 return TABLE;
9803 case 2:
9804 return ROW;
9805 case 3:
9806 return FAMILY;
9807 case 4:
9808 return QUALIFIER;
9809 case 5:
9810 return VALUE;
9811 case 6:
9812 return DELETE_SINGLE;
9813 default:
9814 return null;
9815 }
9816 }
9817
9818
9819
9820
9821
9822 public static _Fields findByThriftIdOrThrow(int fieldId) {
9823 _Fields fields = findByThriftId(fieldId);
9824 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9825 return fields;
9826 }
9827
9828
9829
9830
9831 public static _Fields findByName(String name) {
9832 return byName.get(name);
9833 }
9834
9835 private final short _thriftId;
9836 private final String _fieldName;
9837
9838 _Fields(short thriftId, String fieldName) {
9839 _thriftId = thriftId;
9840 _fieldName = fieldName;
9841 }
9842
9843 public short getThriftFieldId() {
9844 return _thriftId;
9845 }
9846
9847 public String getFieldName() {
9848 return _fieldName;
9849 }
9850 }
9851
9852
9853 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
9854 static {
9855 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
9856 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
9857 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9858 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
9859 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9860 tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
9861 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9862 tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
9863 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9864 tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT,
9865 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9866 tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED,
9867 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
9868 metaDataMap = Collections.unmodifiableMap(tmpMap);
9869 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_args.class, metaDataMap);
9870 }
9871
9872 public checkAndDelete_args() {
9873 }
9874
9875 public checkAndDelete_args(
9876 ByteBuffer table,
9877 ByteBuffer row,
9878 ByteBuffer family,
9879 ByteBuffer qualifier,
9880 ByteBuffer value,
9881 TDelete deleteSingle)
9882 {
9883 this();
9884 this.table = table;
9885 this.row = row;
9886 this.family = family;
9887 this.qualifier = qualifier;
9888 this.value = value;
9889 this.deleteSingle = deleteSingle;
9890 }
9891
9892
9893
9894
9895 public checkAndDelete_args(checkAndDelete_args other) {
9896 if (other.isSetTable()) {
9897 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
9898 ;
9899 }
9900 if (other.isSetRow()) {
9901 this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
9902 ;
9903 }
9904 if (other.isSetFamily()) {
9905 this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
9906 ;
9907 }
9908 if (other.isSetQualifier()) {
9909 this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
9910 ;
9911 }
9912 if (other.isSetValue()) {
9913 this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
9914 ;
9915 }
9916 if (other.isSetDeleteSingle()) {
9917 this.deleteSingle = new TDelete(other.deleteSingle);
9918 }
9919 }
9920
9921 public checkAndDelete_args deepCopy() {
9922 return new checkAndDelete_args(this);
9923 }
9924
9925 @Override
9926 public void clear() {
9927 this.table = null;
9928 this.row = null;
9929 this.family = null;
9930 this.qualifier = null;
9931 this.value = null;
9932 this.deleteSingle = null;
9933 }
9934
9935
9936
9937
9938 public byte[] getTable() {
9939 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
9940 return table == null ? null : table.array();
9941 }
9942
9943 public ByteBuffer bufferForTable() {
9944 return table;
9945 }
9946
9947
9948
9949
9950 public checkAndDelete_args setTable(byte[] table) {
9951 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
9952 return this;
9953 }
9954
9955 public checkAndDelete_args setTable(ByteBuffer table) {
9956 this.table = table;
9957 return this;
9958 }
9959
9960 public void unsetTable() {
9961 this.table = null;
9962 }
9963
9964
9965 public boolean isSetTable() {
9966 return this.table != null;
9967 }
9968
9969 public void setTableIsSet(boolean value) {
9970 if (!value) {
9971 this.table = null;
9972 }
9973 }
9974
9975
9976
9977
9978 public byte[] getRow() {
9979 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
9980 return row == null ? null : row.array();
9981 }
9982
9983 public ByteBuffer bufferForRow() {
9984 return row;
9985 }
9986
9987
9988
9989
9990 public checkAndDelete_args setRow(byte[] row) {
9991 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
9992 return this;
9993 }
9994
9995 public checkAndDelete_args setRow(ByteBuffer row) {
9996 this.row = row;
9997 return this;
9998 }
9999
10000 public void unsetRow() {
10001 this.row = null;
10002 }
10003
10004
10005 public boolean isSetRow() {
10006 return this.row != null;
10007 }
10008
10009 public void setRowIsSet(boolean value) {
10010 if (!value) {
10011 this.row = null;
10012 }
10013 }
10014
10015
10016
10017
10018 public byte[] getFamily() {
10019 setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
10020 return family == null ? null : family.array();
10021 }
10022
10023 public ByteBuffer bufferForFamily() {
10024 return family;
10025 }
10026
10027
10028
10029
10030 public checkAndDelete_args setFamily(byte[] family) {
10031 setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
10032 return this;
10033 }
10034
10035 public checkAndDelete_args setFamily(ByteBuffer family) {
10036 this.family = family;
10037 return this;
10038 }
10039
10040 public void unsetFamily() {
10041 this.family = null;
10042 }
10043
10044
10045 public boolean isSetFamily() {
10046 return this.family != null;
10047 }
10048
10049 public void setFamilyIsSet(boolean value) {
10050 if (!value) {
10051 this.family = null;
10052 }
10053 }
10054
10055
10056
10057
10058 public byte[] getQualifier() {
10059 setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
10060 return qualifier == null ? null : qualifier.array();
10061 }
10062
10063 public ByteBuffer bufferForQualifier() {
10064 return qualifier;
10065 }
10066
10067
10068
10069
10070 public checkAndDelete_args setQualifier(byte[] qualifier) {
10071 setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
10072 return this;
10073 }
10074
10075 public checkAndDelete_args setQualifier(ByteBuffer qualifier) {
10076 this.qualifier = qualifier;
10077 return this;
10078 }
10079
10080 public void unsetQualifier() {
10081 this.qualifier = null;
10082 }
10083
10084
10085 public boolean isSetQualifier() {
10086 return this.qualifier != null;
10087 }
10088
10089 public void setQualifierIsSet(boolean value) {
10090 if (!value) {
10091 this.qualifier = null;
10092 }
10093 }
10094
10095
10096
10097
10098
10099
10100 public byte[] getValue() {
10101 setValue(org.apache.thrift.TBaseHelper.rightSize(value));
10102 return value == null ? null : value.array();
10103 }
10104
10105 public ByteBuffer bufferForValue() {
10106 return value;
10107 }
10108
10109
10110
10111
10112
10113
10114 public checkAndDelete_args setValue(byte[] value) {
10115 setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
10116 return this;
10117 }
10118
10119 public checkAndDelete_args setValue(ByteBuffer value) {
10120 this.value = value;
10121 return this;
10122 }
10123
10124 public void unsetValue() {
10125 this.value = null;
10126 }
10127
10128
10129 public boolean isSetValue() {
10130 return this.value != null;
10131 }
10132
10133 public void setValueIsSet(boolean value) {
10134 if (!value) {
10135 this.value = null;
10136 }
10137 }
10138
10139
10140
10141
10142 public TDelete getDeleteSingle() {
10143 return this.deleteSingle;
10144 }
10145
10146
10147
10148
10149 public checkAndDelete_args setDeleteSingle(TDelete deleteSingle) {
10150 this.deleteSingle = deleteSingle;
10151 return this;
10152 }
10153
10154 public void unsetDeleteSingle() {
10155 this.deleteSingle = null;
10156 }
10157
10158
10159 public boolean isSetDeleteSingle() {
10160 return this.deleteSingle != null;
10161 }
10162
10163 public void setDeleteSingleIsSet(boolean value) {
10164 if (!value) {
10165 this.deleteSingle = null;
10166 }
10167 }
10168
10169 public void setFieldValue(_Fields field, Object value) {
10170 switch (field) {
10171 case TABLE:
10172 if (value == null) {
10173 unsetTable();
10174 } else {
10175 setTable((ByteBuffer)value);
10176 }
10177 break;
10178
10179 case ROW:
10180 if (value == null) {
10181 unsetRow();
10182 } else {
10183 setRow((ByteBuffer)value);
10184 }
10185 break;
10186
10187 case FAMILY:
10188 if (value == null) {
10189 unsetFamily();
10190 } else {
10191 setFamily((ByteBuffer)value);
10192 }
10193 break;
10194
10195 case QUALIFIER:
10196 if (value == null) {
10197 unsetQualifier();
10198 } else {
10199 setQualifier((ByteBuffer)value);
10200 }
10201 break;
10202
10203 case VALUE:
10204 if (value == null) {
10205 unsetValue();
10206 } else {
10207 setValue((ByteBuffer)value);
10208 }
10209 break;
10210
10211 case DELETE_SINGLE:
10212 if (value == null) {
10213 unsetDeleteSingle();
10214 } else {
10215 setDeleteSingle((TDelete)value);
10216 }
10217 break;
10218
10219 }
10220 }
10221
10222 public Object getFieldValue(_Fields field) {
10223 switch (field) {
10224 case TABLE:
10225 return getTable();
10226
10227 case ROW:
10228 return getRow();
10229
10230 case FAMILY:
10231 return getFamily();
10232
10233 case QUALIFIER:
10234 return getQualifier();
10235
10236 case VALUE:
10237 return getValue();
10238
10239 case DELETE_SINGLE:
10240 return getDeleteSingle();
10241
10242 }
10243 throw new IllegalStateException();
10244 }
10245
10246
10247 public boolean isSet(_Fields field) {
10248 if (field == null) {
10249 throw new IllegalArgumentException();
10250 }
10251
10252 switch (field) {
10253 case TABLE:
10254 return isSetTable();
10255 case ROW:
10256 return isSetRow();
10257 case FAMILY:
10258 return isSetFamily();
10259 case QUALIFIER:
10260 return isSetQualifier();
10261 case VALUE:
10262 return isSetValue();
10263 case DELETE_SINGLE:
10264 return isSetDeleteSingle();
10265 }
10266 throw new IllegalStateException();
10267 }
10268
10269 @Override
10270 public boolean equals(Object that) {
10271 if (that == null)
10272 return false;
10273 if (that instanceof checkAndDelete_args)
10274 return this.equals((checkAndDelete_args)that);
10275 return false;
10276 }
10277
10278 public boolean equals(checkAndDelete_args that) {
10279 if (that == null)
10280 return false;
10281
10282 boolean this_present_table = true && this.isSetTable();
10283 boolean that_present_table = true && that.isSetTable();
10284 if (this_present_table || that_present_table) {
10285 if (!(this_present_table && that_present_table))
10286 return false;
10287 if (!this.table.equals(that.table))
10288 return false;
10289 }
10290
10291 boolean this_present_row = true && this.isSetRow();
10292 boolean that_present_row = true && that.isSetRow();
10293 if (this_present_row || that_present_row) {
10294 if (!(this_present_row && that_present_row))
10295 return false;
10296 if (!this.row.equals(that.row))
10297 return false;
10298 }
10299
10300 boolean this_present_family = true && this.isSetFamily();
10301 boolean that_present_family = true && that.isSetFamily();
10302 if (this_present_family || that_present_family) {
10303 if (!(this_present_family && that_present_family))
10304 return false;
10305 if (!this.family.equals(that.family))
10306 return false;
10307 }
10308
10309 boolean this_present_qualifier = true && this.isSetQualifier();
10310 boolean that_present_qualifier = true && that.isSetQualifier();
10311 if (this_present_qualifier || that_present_qualifier) {
10312 if (!(this_present_qualifier && that_present_qualifier))
10313 return false;
10314 if (!this.qualifier.equals(that.qualifier))
10315 return false;
10316 }
10317
10318 boolean this_present_value = true && this.isSetValue();
10319 boolean that_present_value = true && that.isSetValue();
10320 if (this_present_value || that_present_value) {
10321 if (!(this_present_value && that_present_value))
10322 return false;
10323 if (!this.value.equals(that.value))
10324 return false;
10325 }
10326
10327 boolean this_present_deleteSingle = true && this.isSetDeleteSingle();
10328 boolean that_present_deleteSingle = true && that.isSetDeleteSingle();
10329 if (this_present_deleteSingle || that_present_deleteSingle) {
10330 if (!(this_present_deleteSingle && that_present_deleteSingle))
10331 return false;
10332 if (!this.deleteSingle.equals(that.deleteSingle))
10333 return false;
10334 }
10335
10336 return true;
10337 }
10338
10339 @Override
10340 public int hashCode() {
10341 HashCodeBuilder builder = new HashCodeBuilder();
10342
10343 boolean present_table = true && (isSetTable());
10344 builder.append(present_table);
10345 if (present_table)
10346 builder.append(table);
10347
10348 boolean present_row = true && (isSetRow());
10349 builder.append(present_row);
10350 if (present_row)
10351 builder.append(row);
10352
10353 boolean present_family = true && (isSetFamily());
10354 builder.append(present_family);
10355 if (present_family)
10356 builder.append(family);
10357
10358 boolean present_qualifier = true && (isSetQualifier());
10359 builder.append(present_qualifier);
10360 if (present_qualifier)
10361 builder.append(qualifier);
10362
10363 boolean present_value = true && (isSetValue());
10364 builder.append(present_value);
10365 if (present_value)
10366 builder.append(value);
10367
10368 boolean present_deleteSingle = true && (isSetDeleteSingle());
10369 builder.append(present_deleteSingle);
10370 if (present_deleteSingle)
10371 builder.append(deleteSingle);
10372
10373 return builder.toHashCode();
10374 }
10375
10376 public int compareTo(checkAndDelete_args other) {
10377 if (!getClass().equals(other.getClass())) {
10378 return getClass().getName().compareTo(other.getClass().getName());
10379 }
10380
10381 int lastComparison = 0;
10382 checkAndDelete_args typedOther = (checkAndDelete_args)other;
10383
10384 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
10385 if (lastComparison != 0) {
10386 return lastComparison;
10387 }
10388 if (isSetTable()) {
10389 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
10390 if (lastComparison != 0) {
10391 return lastComparison;
10392 }
10393 }
10394 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
10395 if (lastComparison != 0) {
10396 return lastComparison;
10397 }
10398 if (isSetRow()) {
10399 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
10400 if (lastComparison != 0) {
10401 return lastComparison;
10402 }
10403 }
10404 lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
10405 if (lastComparison != 0) {
10406 return lastComparison;
10407 }
10408 if (isSetFamily()) {
10409 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
10410 if (lastComparison != 0) {
10411 return lastComparison;
10412 }
10413 }
10414 lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
10415 if (lastComparison != 0) {
10416 return lastComparison;
10417 }
10418 if (isSetQualifier()) {
10419 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
10420 if (lastComparison != 0) {
10421 return lastComparison;
10422 }
10423 }
10424 lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
10425 if (lastComparison != 0) {
10426 return lastComparison;
10427 }
10428 if (isSetValue()) {
10429 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
10430 if (lastComparison != 0) {
10431 return lastComparison;
10432 }
10433 }
10434 lastComparison = Boolean.valueOf(isSetDeleteSingle()).compareTo(typedOther.isSetDeleteSingle());
10435 if (lastComparison != 0) {
10436 return lastComparison;
10437 }
10438 if (isSetDeleteSingle()) {
10439 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteSingle, typedOther.deleteSingle);
10440 if (lastComparison != 0) {
10441 return lastComparison;
10442 }
10443 }
10444 return 0;
10445 }
10446
10447 public _Fields fieldForId(int fieldId) {
10448 return _Fields.findByThriftId(fieldId);
10449 }
10450
10451 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
10452 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
10453 }
10454
10455 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
10456 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
10457 }
10458
10459 @Override
10460 public String toString() {
10461 StringBuilder sb = new StringBuilder("checkAndDelete_args(");
10462 boolean first = true;
10463
10464 sb.append("table:");
10465 if (this.table == null) {
10466 sb.append("null");
10467 } else {
10468 org.apache.thrift.TBaseHelper.toString(this.table, sb);
10469 }
10470 first = false;
10471 if (!first) sb.append(", ");
10472 sb.append("row:");
10473 if (this.row == null) {
10474 sb.append("null");
10475 } else {
10476 org.apache.thrift.TBaseHelper.toString(this.row, sb);
10477 }
10478 first = false;
10479 if (!first) sb.append(", ");
10480 sb.append("family:");
10481 if (this.family == null) {
10482 sb.append("null");
10483 } else {
10484 org.apache.thrift.TBaseHelper.toString(this.family, sb);
10485 }
10486 first = false;
10487 if (!first) sb.append(", ");
10488 sb.append("qualifier:");
10489 if (this.qualifier == null) {
10490 sb.append("null");
10491 } else {
10492 org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
10493 }
10494 first = false;
10495 if (!first) sb.append(", ");
10496 sb.append("value:");
10497 if (this.value == null) {
10498 sb.append("null");
10499 } else {
10500 org.apache.thrift.TBaseHelper.toString(this.value, sb);
10501 }
10502 first = false;
10503 if (!first) sb.append(", ");
10504 sb.append("deleteSingle:");
10505 if (this.deleteSingle == null) {
10506 sb.append("null");
10507 } else {
10508 sb.append(this.deleteSingle);
10509 }
10510 first = false;
10511 sb.append(")");
10512 return sb.toString();
10513 }
10514
10515 public void validate() throws org.apache.thrift.TException {
10516
10517 if (table == null) {
10518 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
10519 }
10520 if (row == null) {
10521 throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
10522 }
10523 if (family == null) {
10524 throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
10525 }
10526 if (qualifier == null) {
10527 throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
10528 }
10529 if (deleteSingle == null) {
10530 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deleteSingle' was not present! Struct: " + toString());
10531 }
10532 }
10533
10534 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
10535 try {
10536 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
10537 } catch (org.apache.thrift.TException te) {
10538 throw new java.io.IOException(te);
10539 }
10540 }
10541
10542 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
10543 try {
10544 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
10545 } catch (org.apache.thrift.TException te) {
10546 throw new java.io.IOException(te);
10547 }
10548 }
10549
10550 private static class checkAndDelete_argsStandardSchemeFactory implements SchemeFactory {
10551 public checkAndDelete_argsStandardScheme getScheme() {
10552 return new checkAndDelete_argsStandardScheme();
10553 }
10554 }
10555
10556 private static class checkAndDelete_argsStandardScheme extends StandardScheme<checkAndDelete_args> {
10557
10558 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10559 org.apache.thrift.protocol.TField schemeField;
10560 iprot.readStructBegin();
10561 while (true)
10562 {
10563 schemeField = iprot.readFieldBegin();
10564 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
10565 break;
10566 }
10567 switch (schemeField.id) {
10568 case 1:
10569 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10570 struct.table = iprot.readBinary();
10571 struct.setTableIsSet(true);
10572 } else {
10573 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10574 }
10575 break;
10576 case 2:
10577 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10578 struct.row = iprot.readBinary();
10579 struct.setRowIsSet(true);
10580 } else {
10581 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10582 }
10583 break;
10584 case 3:
10585 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10586 struct.family = iprot.readBinary();
10587 struct.setFamilyIsSet(true);
10588 } else {
10589 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10590 }
10591 break;
10592 case 4:
10593 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10594 struct.qualifier = iprot.readBinary();
10595 struct.setQualifierIsSet(true);
10596 } else {
10597 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10598 }
10599 break;
10600 case 5:
10601 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10602 struct.value = iprot.readBinary();
10603 struct.setValueIsSet(true);
10604 } else {
10605 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10606 }
10607 break;
10608 case 6:
10609 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
10610 struct.deleteSingle = new TDelete();
10611 struct.deleteSingle.read(iprot);
10612 struct.setDeleteSingleIsSet(true);
10613 } else {
10614 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10615 }
10616 break;
10617 default:
10618 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10619 }
10620 iprot.readFieldEnd();
10621 }
10622 iprot.readStructEnd();
10623
10624
10625 struct.validate();
10626 }
10627
10628 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10629 struct.validate();
10630
10631 oprot.writeStructBegin(STRUCT_DESC);
10632 if (struct.table != null) {
10633 oprot.writeFieldBegin(TABLE_FIELD_DESC);
10634 oprot.writeBinary(struct.table);
10635 oprot.writeFieldEnd();
10636 }
10637 if (struct.row != null) {
10638 oprot.writeFieldBegin(ROW_FIELD_DESC);
10639 oprot.writeBinary(struct.row);
10640 oprot.writeFieldEnd();
10641 }
10642 if (struct.family != null) {
10643 oprot.writeFieldBegin(FAMILY_FIELD_DESC);
10644 oprot.writeBinary(struct.family);
10645 oprot.writeFieldEnd();
10646 }
10647 if (struct.qualifier != null) {
10648 oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
10649 oprot.writeBinary(struct.qualifier);
10650 oprot.writeFieldEnd();
10651 }
10652 if (struct.value != null) {
10653 oprot.writeFieldBegin(VALUE_FIELD_DESC);
10654 oprot.writeBinary(struct.value);
10655 oprot.writeFieldEnd();
10656 }
10657 if (struct.deleteSingle != null) {
10658 oprot.writeFieldBegin(DELETE_SINGLE_FIELD_DESC);
10659 struct.deleteSingle.write(oprot);
10660 oprot.writeFieldEnd();
10661 }
10662 oprot.writeFieldStop();
10663 oprot.writeStructEnd();
10664 }
10665
10666 }
10667
10668 private static class checkAndDelete_argsTupleSchemeFactory implements SchemeFactory {
10669 public checkAndDelete_argsTupleScheme getScheme() {
10670 return new checkAndDelete_argsTupleScheme();
10671 }
10672 }
10673
10674 private static class checkAndDelete_argsTupleScheme extends TupleScheme<checkAndDelete_args> {
10675
10676 @Override
10677 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10678 TTupleProtocol oprot = (TTupleProtocol) prot;
10679 oprot.writeBinary(struct.table);
10680 oprot.writeBinary(struct.row);
10681 oprot.writeBinary(struct.family);
10682 oprot.writeBinary(struct.qualifier);
10683 struct.deleteSingle.write(oprot);
10684 BitSet optionals = new BitSet();
10685 if (struct.isSetValue()) {
10686 optionals.set(0);
10687 }
10688 oprot.writeBitSet(optionals, 1);
10689 if (struct.isSetValue()) {
10690 oprot.writeBinary(struct.value);
10691 }
10692 }
10693
10694 @Override
10695 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10696 TTupleProtocol iprot = (TTupleProtocol) prot;
10697 struct.table = iprot.readBinary();
10698 struct.setTableIsSet(true);
10699 struct.row = iprot.readBinary();
10700 struct.setRowIsSet(true);
10701 struct.family = iprot.readBinary();
10702 struct.setFamilyIsSet(true);
10703 struct.qualifier = iprot.readBinary();
10704 struct.setQualifierIsSet(true);
10705 struct.deleteSingle = new TDelete();
10706 struct.deleteSingle.read(iprot);
10707 struct.setDeleteSingleIsSet(true);
10708 BitSet incoming = iprot.readBitSet(1);
10709 if (incoming.get(0)) {
10710 struct.value = iprot.readBinary();
10711 struct.setValueIsSet(true);
10712 }
10713 }
10714 }
10715
10716 }
10717
10718 public static class checkAndDelete_result implements org.apache.thrift.TBase<checkAndDelete_result, checkAndDelete_result._Fields>, java.io.Serializable, Cloneable {
10719 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_result");
10720
10721 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0);
10722 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
10723
10724 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
10725 static {
10726 schemes.put(StandardScheme.class, new checkAndDelete_resultStandardSchemeFactory());
10727 schemes.put(TupleScheme.class, new checkAndDelete_resultTupleSchemeFactory());
10728 }
10729
10730 public boolean success;
10731 public TIOError io;
10732
10733
10734 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
10735 SUCCESS((short)0, "success"),
10736 IO((short)1, "io");
10737
10738 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10739
10740 static {
10741 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10742 byName.put(field.getFieldName(), field);
10743 }
10744 }
10745
10746
10747
10748
10749 public static _Fields findByThriftId(int fieldId) {
10750 switch(fieldId) {
10751 case 0:
10752 return SUCCESS;
10753 case 1:
10754 return IO;
10755 default:
10756 return null;
10757 }
10758 }
10759
10760
10761
10762
10763
10764 public static _Fields findByThriftIdOrThrow(int fieldId) {
10765 _Fields fields = findByThriftId(fieldId);
10766 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10767 return fields;
10768 }
10769
10770
10771
10772
10773 public static _Fields findByName(String name) {
10774 return byName.get(name);
10775 }
10776
10777 private final short _thriftId;
10778 private final String _fieldName;
10779
10780 _Fields(short thriftId, String fieldName) {
10781 _thriftId = thriftId;
10782 _fieldName = fieldName;
10783 }
10784
10785 public short getThriftFieldId() {
10786 return _thriftId;
10787 }
10788
10789 public String getFieldName() {
10790 return _fieldName;
10791 }
10792 }
10793
10794
10795 private static final int __SUCCESS_ISSET_ID = 0;
10796 private BitSet __isset_bit_vector = new BitSet(1);
10797 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
10798 static {
10799 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
10800 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
10801 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
10802 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
10803 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
10804 metaDataMap = Collections.unmodifiableMap(tmpMap);
10805 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_result.class, metaDataMap);
10806 }
10807
10808 public checkAndDelete_result() {
10809 }
10810
10811 public checkAndDelete_result(
10812 boolean success,
10813 TIOError io)
10814 {
10815 this();
10816 this.success = success;
10817 setSuccessIsSet(true);
10818 this.io = io;
10819 }
10820
10821
10822
10823
10824 public checkAndDelete_result(checkAndDelete_result other) {
10825 __isset_bit_vector.clear();
10826 __isset_bit_vector.or(other.__isset_bit_vector);
10827 this.success = other.success;
10828 if (other.isSetIo()) {
10829 this.io = new TIOError(other.io);
10830 }
10831 }
10832
10833 public checkAndDelete_result deepCopy() {
10834 return new checkAndDelete_result(this);
10835 }
10836
10837 @Override
10838 public void clear() {
10839 setSuccessIsSet(false);
10840 this.success = false;
10841 this.io = null;
10842 }
10843
10844 public boolean isSuccess() {
10845 return this.success;
10846 }
10847
10848 public checkAndDelete_result setSuccess(boolean success) {
10849 this.success = success;
10850 setSuccessIsSet(true);
10851 return this;
10852 }
10853
10854 public void unsetSuccess() {
10855 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
10856 }
10857
10858
10859 public boolean isSetSuccess() {
10860 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
10861 }
10862
10863 public void setSuccessIsSet(boolean value) {
10864 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
10865 }
10866
10867 public TIOError getIo() {
10868 return this.io;
10869 }
10870
10871 public checkAndDelete_result setIo(TIOError io) {
10872 this.io = io;
10873 return this;
10874 }
10875
10876 public void unsetIo() {
10877 this.io = null;
10878 }
10879
10880
10881 public boolean isSetIo() {
10882 return this.io != null;
10883 }
10884
10885 public void setIoIsSet(boolean value) {
10886 if (!value) {
10887 this.io = null;
10888 }
10889 }
10890
10891 public void setFieldValue(_Fields field, Object value) {
10892 switch (field) {
10893 case SUCCESS:
10894 if (value == null) {
10895 unsetSuccess();
10896 } else {
10897 setSuccess((Boolean)value);
10898 }
10899 break;
10900
10901 case IO:
10902 if (value == null) {
10903 unsetIo();
10904 } else {
10905 setIo((TIOError)value);
10906 }
10907 break;
10908
10909 }
10910 }
10911
10912 public Object getFieldValue(_Fields field) {
10913 switch (field) {
10914 case SUCCESS:
10915 return Boolean.valueOf(isSuccess());
10916
10917 case IO:
10918 return getIo();
10919
10920 }
10921 throw new IllegalStateException();
10922 }
10923
10924
10925 public boolean isSet(_Fields field) {
10926 if (field == null) {
10927 throw new IllegalArgumentException();
10928 }
10929
10930 switch (field) {
10931 case SUCCESS:
10932 return isSetSuccess();
10933 case IO:
10934 return isSetIo();
10935 }
10936 throw new IllegalStateException();
10937 }
10938
10939 @Override
10940 public boolean equals(Object that) {
10941 if (that == null)
10942 return false;
10943 if (that instanceof checkAndDelete_result)
10944 return this.equals((checkAndDelete_result)that);
10945 return false;
10946 }
10947
10948 public boolean equals(checkAndDelete_result that) {
10949 if (that == null)
10950 return false;
10951
10952 boolean this_present_success = true;
10953 boolean that_present_success = true;
10954 if (this_present_success || that_present_success) {
10955 if (!(this_present_success && that_present_success))
10956 return false;
10957 if (this.success != that.success)
10958 return false;
10959 }
10960
10961 boolean this_present_io = true && this.isSetIo();
10962 boolean that_present_io = true && that.isSetIo();
10963 if (this_present_io || that_present_io) {
10964 if (!(this_present_io && that_present_io))
10965 return false;
10966 if (!this.io.equals(that.io))
10967 return false;
10968 }
10969
10970 return true;
10971 }
10972
10973 @Override
10974 public int hashCode() {
10975 HashCodeBuilder builder = new HashCodeBuilder();
10976
10977 boolean present_success = true;
10978 builder.append(present_success);
10979 if (present_success)
10980 builder.append(success);
10981
10982 boolean present_io = true && (isSetIo());
10983 builder.append(present_io);
10984 if (present_io)
10985 builder.append(io);
10986
10987 return builder.toHashCode();
10988 }
10989
10990 public int compareTo(checkAndDelete_result other) {
10991 if (!getClass().equals(other.getClass())) {
10992 return getClass().getName().compareTo(other.getClass().getName());
10993 }
10994
10995 int lastComparison = 0;
10996 checkAndDelete_result typedOther = (checkAndDelete_result)other;
10997
10998 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
10999 if (lastComparison != 0) {
11000 return lastComparison;
11001 }
11002 if (isSetSuccess()) {
11003 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
11004 if (lastComparison != 0) {
11005 return lastComparison;
11006 }
11007 }
11008 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
11009 if (lastComparison != 0) {
11010 return lastComparison;
11011 }
11012 if (isSetIo()) {
11013 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
11014 if (lastComparison != 0) {
11015 return lastComparison;
11016 }
11017 }
11018 return 0;
11019 }
11020
11021 public _Fields fieldForId(int fieldId) {
11022 return _Fields.findByThriftId(fieldId);
11023 }
11024
11025 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
11026 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
11027 }
11028
11029 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
11030 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
11031 }
11032
11033 @Override
11034 public String toString() {
11035 StringBuilder sb = new StringBuilder("checkAndDelete_result(");
11036 boolean first = true;
11037
11038 sb.append("success:");
11039 sb.append(this.success);
11040 first = false;
11041 if (!first) sb.append(", ");
11042 sb.append("io:");
11043 if (this.io == null) {
11044 sb.append("null");
11045 } else {
11046 sb.append(this.io);
11047 }
11048 first = false;
11049 sb.append(")");
11050 return sb.toString();
11051 }
11052
11053 public void validate() throws org.apache.thrift.TException {
11054
11055 }
11056
11057 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
11058 try {
11059 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
11060 } catch (org.apache.thrift.TException te) {
11061 throw new java.io.IOException(te);
11062 }
11063 }
11064
11065 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
11066 try {
11067 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
11068 } catch (org.apache.thrift.TException te) {
11069 throw new java.io.IOException(te);
11070 }
11071 }
11072
11073 private static class checkAndDelete_resultStandardSchemeFactory implements SchemeFactory {
11074 public checkAndDelete_resultStandardScheme getScheme() {
11075 return new checkAndDelete_resultStandardScheme();
11076 }
11077 }
11078
11079 private static class checkAndDelete_resultStandardScheme extends StandardScheme<checkAndDelete_result> {
11080
11081 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
11082 org.apache.thrift.protocol.TField schemeField;
11083 iprot.readStructBegin();
11084 while (true)
11085 {
11086 schemeField = iprot.readFieldBegin();
11087 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
11088 break;
11089 }
11090 switch (schemeField.id) {
11091 case 0:
11092 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
11093 struct.success = iprot.readBool();
11094 struct.setSuccessIsSet(true);
11095 } else {
11096 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11097 }
11098 break;
11099 case 1:
11100 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11101 struct.io = new TIOError();
11102 struct.io.read(iprot);
11103 struct.setIoIsSet(true);
11104 } else {
11105 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11106 }
11107 break;
11108 default:
11109 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11110 }
11111 iprot.readFieldEnd();
11112 }
11113 iprot.readStructEnd();
11114
11115
11116 struct.validate();
11117 }
11118
11119 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
11120 struct.validate();
11121
11122 oprot.writeStructBegin(STRUCT_DESC);
11123 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11124 oprot.writeBool(struct.success);
11125 oprot.writeFieldEnd();
11126 if (struct.io != null) {
11127 oprot.writeFieldBegin(IO_FIELD_DESC);
11128 struct.io.write(oprot);
11129 oprot.writeFieldEnd();
11130 }
11131 oprot.writeFieldStop();
11132 oprot.writeStructEnd();
11133 }
11134
11135 }
11136
11137 private static class checkAndDelete_resultTupleSchemeFactory implements SchemeFactory {
11138 public checkAndDelete_resultTupleScheme getScheme() {
11139 return new checkAndDelete_resultTupleScheme();
11140 }
11141 }
11142
11143 private static class checkAndDelete_resultTupleScheme extends TupleScheme<checkAndDelete_result> {
11144
11145 @Override
11146 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
11147 TTupleProtocol oprot = (TTupleProtocol) prot;
11148 BitSet optionals = new BitSet();
11149 if (struct.isSetSuccess()) {
11150 optionals.set(0);
11151 }
11152 if (struct.isSetIo()) {
11153 optionals.set(1);
11154 }
11155 oprot.writeBitSet(optionals, 2);
11156 if (struct.isSetSuccess()) {
11157 oprot.writeBool(struct.success);
11158 }
11159 if (struct.isSetIo()) {
11160 struct.io.write(oprot);
11161 }
11162 }
11163
11164 @Override
11165 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
11166 TTupleProtocol iprot = (TTupleProtocol) prot;
11167 BitSet incoming = iprot.readBitSet(2);
11168 if (incoming.get(0)) {
11169 struct.success = iprot.readBool();
11170 struct.setSuccessIsSet(true);
11171 }
11172 if (incoming.get(1)) {
11173 struct.io = new TIOError();
11174 struct.io.read(iprot);
11175 struct.setIoIsSet(true);
11176 }
11177 }
11178 }
11179
11180 }
11181
11182 public static class increment_args implements org.apache.thrift.TBase<increment_args, increment_args._Fields>, java.io.Serializable, Cloneable {
11183 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_args");
11184
11185 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
11186 private static final org.apache.thrift.protocol.TField INCREMENT_FIELD_DESC = new org.apache.thrift.protocol.TField("increment", org.apache.thrift.protocol.TType.STRUCT, (short)2);
11187
11188 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
11189 static {
11190 schemes.put(StandardScheme.class, new increment_argsStandardSchemeFactory());
11191 schemes.put(TupleScheme.class, new increment_argsTupleSchemeFactory());
11192 }
11193
11194
11195
11196
11197 public ByteBuffer table;
11198
11199
11200
11201 public TIncrement increment;
11202
11203
11204 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
11205
11206
11207
11208 TABLE((short)1, "table"),
11209
11210
11211
11212 INCREMENT((short)2, "increment");
11213
11214 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11215
11216 static {
11217 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11218 byName.put(field.getFieldName(), field);
11219 }
11220 }
11221
11222
11223
11224
11225 public static _Fields findByThriftId(int fieldId) {
11226 switch(fieldId) {
11227 case 1:
11228 return TABLE;
11229 case 2:
11230 return INCREMENT;
11231 default:
11232 return null;
11233 }
11234 }
11235
11236
11237
11238
11239
11240 public static _Fields findByThriftIdOrThrow(int fieldId) {
11241 _Fields fields = findByThriftId(fieldId);
11242 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11243 return fields;
11244 }
11245
11246
11247
11248
11249 public static _Fields findByName(String name) {
11250 return byName.get(name);
11251 }
11252
11253 private final short _thriftId;
11254 private final String _fieldName;
11255
11256 _Fields(short thriftId, String fieldName) {
11257 _thriftId = thriftId;
11258 _fieldName = fieldName;
11259 }
11260
11261 public short getThriftFieldId() {
11262 return _thriftId;
11263 }
11264
11265 public String getFieldName() {
11266 return _fieldName;
11267 }
11268 }
11269
11270
11271 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
11272 static {
11273 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
11274 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
11275 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
11276 tmpMap.put(_Fields.INCREMENT, new org.apache.thrift.meta_data.FieldMetaData("increment", org.apache.thrift.TFieldRequirementType.REQUIRED,
11277 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIncrement.class)));
11278 metaDataMap = Collections.unmodifiableMap(tmpMap);
11279 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_args.class, metaDataMap);
11280 }
11281
11282 public increment_args() {
11283 }
11284
11285 public increment_args(
11286 ByteBuffer table,
11287 TIncrement increment)
11288 {
11289 this();
11290 this.table = table;
11291 this.increment = increment;
11292 }
11293
11294
11295
11296
11297 public increment_args(increment_args other) {
11298 if (other.isSetTable()) {
11299 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
11300 ;
11301 }
11302 if (other.isSetIncrement()) {
11303 this.increment = new TIncrement(other.increment);
11304 }
11305 }
11306
11307 public increment_args deepCopy() {
11308 return new increment_args(this);
11309 }
11310
11311 @Override
11312 public void clear() {
11313 this.table = null;
11314 this.increment = null;
11315 }
11316
11317
11318
11319
11320 public byte[] getTable() {
11321 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
11322 return table == null ? null : table.array();
11323 }
11324
11325 public ByteBuffer bufferForTable() {
11326 return table;
11327 }
11328
11329
11330
11331
11332 public increment_args setTable(byte[] table) {
11333 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
11334 return this;
11335 }
11336
11337 public increment_args setTable(ByteBuffer table) {
11338 this.table = table;
11339 return this;
11340 }
11341
11342 public void unsetTable() {
11343 this.table = null;
11344 }
11345
11346
11347 public boolean isSetTable() {
11348 return this.table != null;
11349 }
11350
11351 public void setTableIsSet(boolean value) {
11352 if (!value) {
11353 this.table = null;
11354 }
11355 }
11356
11357
11358
11359
11360 public TIncrement getIncrement() {
11361 return this.increment;
11362 }
11363
11364
11365
11366
11367 public increment_args setIncrement(TIncrement increment) {
11368 this.increment = increment;
11369 return this;
11370 }
11371
11372 public void unsetIncrement() {
11373 this.increment = null;
11374 }
11375
11376
11377 public boolean isSetIncrement() {
11378 return this.increment != null;
11379 }
11380
11381 public void setIncrementIsSet(boolean value) {
11382 if (!value) {
11383 this.increment = null;
11384 }
11385 }
11386
11387 public void setFieldValue(_Fields field, Object value) {
11388 switch (field) {
11389 case TABLE:
11390 if (value == null) {
11391 unsetTable();
11392 } else {
11393 setTable((ByteBuffer)value);
11394 }
11395 break;
11396
11397 case INCREMENT:
11398 if (value == null) {
11399 unsetIncrement();
11400 } else {
11401 setIncrement((TIncrement)value);
11402 }
11403 break;
11404
11405 }
11406 }
11407
11408 public Object getFieldValue(_Fields field) {
11409 switch (field) {
11410 case TABLE:
11411 return getTable();
11412
11413 case INCREMENT:
11414 return getIncrement();
11415
11416 }
11417 throw new IllegalStateException();
11418 }
11419
11420
11421 public boolean isSet(_Fields field) {
11422 if (field == null) {
11423 throw new IllegalArgumentException();
11424 }
11425
11426 switch (field) {
11427 case TABLE:
11428 return isSetTable();
11429 case INCREMENT:
11430 return isSetIncrement();
11431 }
11432 throw new IllegalStateException();
11433 }
11434
11435 @Override
11436 public boolean equals(Object that) {
11437 if (that == null)
11438 return false;
11439 if (that instanceof increment_args)
11440 return this.equals((increment_args)that);
11441 return false;
11442 }
11443
11444 public boolean equals(increment_args that) {
11445 if (that == null)
11446 return false;
11447
11448 boolean this_present_table = true && this.isSetTable();
11449 boolean that_present_table = true && that.isSetTable();
11450 if (this_present_table || that_present_table) {
11451 if (!(this_present_table && that_present_table))
11452 return false;
11453 if (!this.table.equals(that.table))
11454 return false;
11455 }
11456
11457 boolean this_present_increment = true && this.isSetIncrement();
11458 boolean that_present_increment = true && that.isSetIncrement();
11459 if (this_present_increment || that_present_increment) {
11460 if (!(this_present_increment && that_present_increment))
11461 return false;
11462 if (!this.increment.equals(that.increment))
11463 return false;
11464 }
11465
11466 return true;
11467 }
11468
11469 @Override
11470 public int hashCode() {
11471 HashCodeBuilder builder = new HashCodeBuilder();
11472
11473 boolean present_table = true && (isSetTable());
11474 builder.append(present_table);
11475 if (present_table)
11476 builder.append(table);
11477
11478 boolean present_increment = true && (isSetIncrement());
11479 builder.append(present_increment);
11480 if (present_increment)
11481 builder.append(increment);
11482
11483 return builder.toHashCode();
11484 }
11485
11486 public int compareTo(increment_args other) {
11487 if (!getClass().equals(other.getClass())) {
11488 return getClass().getName().compareTo(other.getClass().getName());
11489 }
11490
11491 int lastComparison = 0;
11492 increment_args typedOther = (increment_args)other;
11493
11494 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
11495 if (lastComparison != 0) {
11496 return lastComparison;
11497 }
11498 if (isSetTable()) {
11499 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
11500 if (lastComparison != 0) {
11501 return lastComparison;
11502 }
11503 }
11504 lastComparison = Boolean.valueOf(isSetIncrement()).compareTo(typedOther.isSetIncrement());
11505 if (lastComparison != 0) {
11506 return lastComparison;
11507 }
11508 if (isSetIncrement()) {
11509 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.increment, typedOther.increment);
11510 if (lastComparison != 0) {
11511 return lastComparison;
11512 }
11513 }
11514 return 0;
11515 }
11516
11517 public _Fields fieldForId(int fieldId) {
11518 return _Fields.findByThriftId(fieldId);
11519 }
11520
11521 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
11522 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
11523 }
11524
11525 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
11526 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
11527 }
11528
11529 @Override
11530 public String toString() {
11531 StringBuilder sb = new StringBuilder("increment_args(");
11532 boolean first = true;
11533
11534 sb.append("table:");
11535 if (this.table == null) {
11536 sb.append("null");
11537 } else {
11538 org.apache.thrift.TBaseHelper.toString(this.table, sb);
11539 }
11540 first = false;
11541 if (!first) sb.append(", ");
11542 sb.append("increment:");
11543 if (this.increment == null) {
11544 sb.append("null");
11545 } else {
11546 sb.append(this.increment);
11547 }
11548 first = false;
11549 sb.append(")");
11550 return sb.toString();
11551 }
11552
11553 public void validate() throws org.apache.thrift.TException {
11554
11555 if (table == null) {
11556 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
11557 }
11558 if (increment == null) {
11559 throw new org.apache.thrift.protocol.TProtocolException("Required field 'increment' was not present! Struct: " + toString());
11560 }
11561 }
11562
11563 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
11564 try {
11565 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
11566 } catch (org.apache.thrift.TException te) {
11567 throw new java.io.IOException(te);
11568 }
11569 }
11570
11571 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
11572 try {
11573 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
11574 } catch (org.apache.thrift.TException te) {
11575 throw new java.io.IOException(te);
11576 }
11577 }
11578
11579 private static class increment_argsStandardSchemeFactory implements SchemeFactory {
11580 public increment_argsStandardScheme getScheme() {
11581 return new increment_argsStandardScheme();
11582 }
11583 }
11584
11585 private static class increment_argsStandardScheme extends StandardScheme<increment_args> {
11586
11587 public void read(org.apache.thrift.protocol.TProtocol iprot, increment_args struct) throws org.apache.thrift.TException {
11588 org.apache.thrift.protocol.TField schemeField;
11589 iprot.readStructBegin();
11590 while (true)
11591 {
11592 schemeField = iprot.readFieldBegin();
11593 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
11594 break;
11595 }
11596 switch (schemeField.id) {
11597 case 1:
11598 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
11599 struct.table = iprot.readBinary();
11600 struct.setTableIsSet(true);
11601 } else {
11602 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11603 }
11604 break;
11605 case 2:
11606 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11607 struct.increment = new TIncrement();
11608 struct.increment.read(iprot);
11609 struct.setIncrementIsSet(true);
11610 } else {
11611 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11612 }
11613 break;
11614 default:
11615 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11616 }
11617 iprot.readFieldEnd();
11618 }
11619 iprot.readStructEnd();
11620
11621
11622 struct.validate();
11623 }
11624
11625 public void write(org.apache.thrift.protocol.TProtocol oprot, increment_args struct) throws org.apache.thrift.TException {
11626 struct.validate();
11627
11628 oprot.writeStructBegin(STRUCT_DESC);
11629 if (struct.table != null) {
11630 oprot.writeFieldBegin(TABLE_FIELD_DESC);
11631 oprot.writeBinary(struct.table);
11632 oprot.writeFieldEnd();
11633 }
11634 if (struct.increment != null) {
11635 oprot.writeFieldBegin(INCREMENT_FIELD_DESC);
11636 struct.increment.write(oprot);
11637 oprot.writeFieldEnd();
11638 }
11639 oprot.writeFieldStop();
11640 oprot.writeStructEnd();
11641 }
11642
11643 }
11644
11645 private static class increment_argsTupleSchemeFactory implements SchemeFactory {
11646 public increment_argsTupleScheme getScheme() {
11647 return new increment_argsTupleScheme();
11648 }
11649 }
11650
11651 private static class increment_argsTupleScheme extends TupleScheme<increment_args> {
11652
11653 @Override
11654 public void write(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
11655 TTupleProtocol oprot = (TTupleProtocol) prot;
11656 oprot.writeBinary(struct.table);
11657 struct.increment.write(oprot);
11658 }
11659
11660 @Override
11661 public void read(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
11662 TTupleProtocol iprot = (TTupleProtocol) prot;
11663 struct.table = iprot.readBinary();
11664 struct.setTableIsSet(true);
11665 struct.increment = new TIncrement();
11666 struct.increment.read(iprot);
11667 struct.setIncrementIsSet(true);
11668 }
11669 }
11670
11671 }
11672
11673 public static class increment_result implements org.apache.thrift.TBase<increment_result, increment_result._Fields>, java.io.Serializable, Cloneable {
11674 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_result");
11675
11676 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
11677 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
11678
11679 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
11680 static {
11681 schemes.put(StandardScheme.class, new increment_resultStandardSchemeFactory());
11682 schemes.put(TupleScheme.class, new increment_resultTupleSchemeFactory());
11683 }
11684
11685 public TResult success;
11686 public TIOError io;
11687
11688
11689 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
11690 SUCCESS((short)0, "success"),
11691 IO((short)1, "io");
11692
11693 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11694
11695 static {
11696 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11697 byName.put(field.getFieldName(), field);
11698 }
11699 }
11700
11701
11702
11703
11704 public static _Fields findByThriftId(int fieldId) {
11705 switch(fieldId) {
11706 case 0:
11707 return SUCCESS;
11708 case 1:
11709 return IO;
11710 default:
11711 return null;
11712 }
11713 }
11714
11715
11716
11717
11718
11719 public static _Fields findByThriftIdOrThrow(int fieldId) {
11720 _Fields fields = findByThriftId(fieldId);
11721 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11722 return fields;
11723 }
11724
11725
11726
11727
11728 public static _Fields findByName(String name) {
11729 return byName.get(name);
11730 }
11731
11732 private final short _thriftId;
11733 private final String _fieldName;
11734
11735 _Fields(short thriftId, String fieldName) {
11736 _thriftId = thriftId;
11737 _fieldName = fieldName;
11738 }
11739
11740 public short getThriftFieldId() {
11741 return _thriftId;
11742 }
11743
11744 public String getFieldName() {
11745 return _fieldName;
11746 }
11747 }
11748
11749
11750 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
11751 static {
11752 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
11753 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
11754 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
11755 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
11756 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
11757 metaDataMap = Collections.unmodifiableMap(tmpMap);
11758 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_result.class, metaDataMap);
11759 }
11760
11761 public increment_result() {
11762 }
11763
11764 public increment_result(
11765 TResult success,
11766 TIOError io)
11767 {
11768 this();
11769 this.success = success;
11770 this.io = io;
11771 }
11772
11773
11774
11775
11776 public increment_result(increment_result other) {
11777 if (other.isSetSuccess()) {
11778 this.success = new TResult(other.success);
11779 }
11780 if (other.isSetIo()) {
11781 this.io = new TIOError(other.io);
11782 }
11783 }
11784
11785 public increment_result deepCopy() {
11786 return new increment_result(this);
11787 }
11788
11789 @Override
11790 public void clear() {
11791 this.success = null;
11792 this.io = null;
11793 }
11794
11795 public TResult getSuccess() {
11796 return this.success;
11797 }
11798
11799 public increment_result setSuccess(TResult success) {
11800 this.success = success;
11801 return this;
11802 }
11803
11804 public void unsetSuccess() {
11805 this.success = null;
11806 }
11807
11808
11809 public boolean isSetSuccess() {
11810 return this.success != null;
11811 }
11812
11813 public void setSuccessIsSet(boolean value) {
11814 if (!value) {
11815 this.success = null;
11816 }
11817 }
11818
11819 public TIOError getIo() {
11820 return this.io;
11821 }
11822
11823 public increment_result setIo(TIOError io) {
11824 this.io = io;
11825 return this;
11826 }
11827
11828 public void unsetIo() {
11829 this.io = null;
11830 }
11831
11832
11833 public boolean isSetIo() {
11834 return this.io != null;
11835 }
11836
11837 public void setIoIsSet(boolean value) {
11838 if (!value) {
11839 this.io = null;
11840 }
11841 }
11842
11843 public void setFieldValue(_Fields field, Object value) {
11844 switch (field) {
11845 case SUCCESS:
11846 if (value == null) {
11847 unsetSuccess();
11848 } else {
11849 setSuccess((TResult)value);
11850 }
11851 break;
11852
11853 case IO:
11854 if (value == null) {
11855 unsetIo();
11856 } else {
11857 setIo((TIOError)value);
11858 }
11859 break;
11860
11861 }
11862 }
11863
11864 public Object getFieldValue(_Fields field) {
11865 switch (field) {
11866 case SUCCESS:
11867 return getSuccess();
11868
11869 case IO:
11870 return getIo();
11871
11872 }
11873 throw new IllegalStateException();
11874 }
11875
11876
11877 public boolean isSet(_Fields field) {
11878 if (field == null) {
11879 throw new IllegalArgumentException();
11880 }
11881
11882 switch (field) {
11883 case SUCCESS:
11884 return isSetSuccess();
11885 case IO:
11886 return isSetIo();
11887 }
11888 throw new IllegalStateException();
11889 }
11890
11891 @Override
11892 public boolean equals(Object that) {
11893 if (that == null)
11894 return false;
11895 if (that instanceof increment_result)
11896 return this.equals((increment_result)that);
11897 return false;
11898 }
11899
11900 public boolean equals(increment_result that) {
11901 if (that == null)
11902 return false;
11903
11904 boolean this_present_success = true && this.isSetSuccess();
11905 boolean that_present_success = true && that.isSetSuccess();
11906 if (this_present_success || that_present_success) {
11907 if (!(this_present_success && that_present_success))
11908 return false;
11909 if (!this.success.equals(that.success))
11910 return false;
11911 }
11912
11913 boolean this_present_io = true && this.isSetIo();
11914 boolean that_present_io = true && that.isSetIo();
11915 if (this_present_io || that_present_io) {
11916 if (!(this_present_io && that_present_io))
11917 return false;
11918 if (!this.io.equals(that.io))
11919 return false;
11920 }
11921
11922 return true;
11923 }
11924
11925 @Override
11926 public int hashCode() {
11927 HashCodeBuilder builder = new HashCodeBuilder();
11928
11929 boolean present_success = true && (isSetSuccess());
11930 builder.append(present_success);
11931 if (present_success)
11932 builder.append(success);
11933
11934 boolean present_io = true && (isSetIo());
11935 builder.append(present_io);
11936 if (present_io)
11937 builder.append(io);
11938
11939 return builder.toHashCode();
11940 }
11941
11942 public int compareTo(increment_result other) {
11943 if (!getClass().equals(other.getClass())) {
11944 return getClass().getName().compareTo(other.getClass().getName());
11945 }
11946
11947 int lastComparison = 0;
11948 increment_result typedOther = (increment_result)other;
11949
11950 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
11951 if (lastComparison != 0) {
11952 return lastComparison;
11953 }
11954 if (isSetSuccess()) {
11955 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
11956 if (lastComparison != 0) {
11957 return lastComparison;
11958 }
11959 }
11960 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
11961 if (lastComparison != 0) {
11962 return lastComparison;
11963 }
11964 if (isSetIo()) {
11965 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
11966 if (lastComparison != 0) {
11967 return lastComparison;
11968 }
11969 }
11970 return 0;
11971 }
11972
11973 public _Fields fieldForId(int fieldId) {
11974 return _Fields.findByThriftId(fieldId);
11975 }
11976
11977 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
11978 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
11979 }
11980
11981 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
11982 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
11983 }
11984
11985 @Override
11986 public String toString() {
11987 StringBuilder sb = new StringBuilder("increment_result(");
11988 boolean first = true;
11989
11990 sb.append("success:");
11991 if (this.success == null) {
11992 sb.append("null");
11993 } else {
11994 sb.append(this.success);
11995 }
11996 first = false;
11997 if (!first) sb.append(", ");
11998 sb.append("io:");
11999 if (this.io == null) {
12000 sb.append("null");
12001 } else {
12002 sb.append(this.io);
12003 }
12004 first = false;
12005 sb.append(")");
12006 return sb.toString();
12007 }
12008
12009 public void validate() throws org.apache.thrift.TException {
12010
12011 }
12012
12013 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12014 try {
12015 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12016 } catch (org.apache.thrift.TException te) {
12017 throw new java.io.IOException(te);
12018 }
12019 }
12020
12021 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12022 try {
12023 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12024 } catch (org.apache.thrift.TException te) {
12025 throw new java.io.IOException(te);
12026 }
12027 }
12028
12029 private static class increment_resultStandardSchemeFactory implements SchemeFactory {
12030 public increment_resultStandardScheme getScheme() {
12031 return new increment_resultStandardScheme();
12032 }
12033 }
12034
12035 private static class increment_resultStandardScheme extends StandardScheme<increment_result> {
12036
12037 public void read(org.apache.thrift.protocol.TProtocol iprot, increment_result struct) throws org.apache.thrift.TException {
12038 org.apache.thrift.protocol.TField schemeField;
12039 iprot.readStructBegin();
12040 while (true)
12041 {
12042 schemeField = iprot.readFieldBegin();
12043 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
12044 break;
12045 }
12046 switch (schemeField.id) {
12047 case 0:
12048 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
12049 struct.success = new TResult();
12050 struct.success.read(iprot);
12051 struct.setSuccessIsSet(true);
12052 } else {
12053 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12054 }
12055 break;
12056 case 1:
12057 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
12058 struct.io = new TIOError();
12059 struct.io.read(iprot);
12060 struct.setIoIsSet(true);
12061 } else {
12062 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12063 }
12064 break;
12065 default:
12066 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12067 }
12068 iprot.readFieldEnd();
12069 }
12070 iprot.readStructEnd();
12071
12072
12073 struct.validate();
12074 }
12075
12076 public void write(org.apache.thrift.protocol.TProtocol oprot, increment_result struct) throws org.apache.thrift.TException {
12077 struct.validate();
12078
12079 oprot.writeStructBegin(STRUCT_DESC);
12080 if (struct.success != null) {
12081 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12082 struct.success.write(oprot);
12083 oprot.writeFieldEnd();
12084 }
12085 if (struct.io != null) {
12086 oprot.writeFieldBegin(IO_FIELD_DESC);
12087 struct.io.write(oprot);
12088 oprot.writeFieldEnd();
12089 }
12090 oprot.writeFieldStop();
12091 oprot.writeStructEnd();
12092 }
12093
12094 }
12095
12096 private static class increment_resultTupleSchemeFactory implements SchemeFactory {
12097 public increment_resultTupleScheme getScheme() {
12098 return new increment_resultTupleScheme();
12099 }
12100 }
12101
12102 private static class increment_resultTupleScheme extends TupleScheme<increment_result> {
12103
12104 @Override
12105 public void write(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
12106 TTupleProtocol oprot = (TTupleProtocol) prot;
12107 BitSet optionals = new BitSet();
12108 if (struct.isSetSuccess()) {
12109 optionals.set(0);
12110 }
12111 if (struct.isSetIo()) {
12112 optionals.set(1);
12113 }
12114 oprot.writeBitSet(optionals, 2);
12115 if (struct.isSetSuccess()) {
12116 struct.success.write(oprot);
12117 }
12118 if (struct.isSetIo()) {
12119 struct.io.write(oprot);
12120 }
12121 }
12122
12123 @Override
12124 public void read(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
12125 TTupleProtocol iprot = (TTupleProtocol) prot;
12126 BitSet incoming = iprot.readBitSet(2);
12127 if (incoming.get(0)) {
12128 struct.success = new TResult();
12129 struct.success.read(iprot);
12130 struct.setSuccessIsSet(true);
12131 }
12132 if (incoming.get(1)) {
12133 struct.io = new TIOError();
12134 struct.io.read(iprot);
12135 struct.setIoIsSet(true);
12136 }
12137 }
12138 }
12139
12140 }
12141
12142 public static class openScanner_args implements org.apache.thrift.TBase<openScanner_args, openScanner_args._Fields>, java.io.Serializable, Cloneable {
12143 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_args");
12144
12145 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
12146 private static final org.apache.thrift.protocol.TField SCAN_FIELD_DESC = new org.apache.thrift.protocol.TField("scan", org.apache.thrift.protocol.TType.STRUCT, (short)2);
12147
12148 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
12149 static {
12150 schemes.put(StandardScheme.class, new openScanner_argsStandardSchemeFactory());
12151 schemes.put(TupleScheme.class, new openScanner_argsTupleSchemeFactory());
12152 }
12153
12154
12155
12156
12157 public ByteBuffer table;
12158
12159
12160
12161 public TScan scan;
12162
12163
12164 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
12165
12166
12167
12168 TABLE((short)1, "table"),
12169
12170
12171
12172 SCAN((short)2, "scan");
12173
12174 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12175
12176 static {
12177 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12178 byName.put(field.getFieldName(), field);
12179 }
12180 }
12181
12182
12183
12184
12185 public static _Fields findByThriftId(int fieldId) {
12186 switch(fieldId) {
12187 case 1:
12188 return TABLE;
12189 case 2:
12190 return SCAN;
12191 default:
12192 return null;
12193 }
12194 }
12195
12196
12197
12198
12199
12200 public static _Fields findByThriftIdOrThrow(int fieldId) {
12201 _Fields fields = findByThriftId(fieldId);
12202 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12203 return fields;
12204 }
12205
12206
12207
12208
12209 public static _Fields findByName(String name) {
12210 return byName.get(name);
12211 }
12212
12213 private final short _thriftId;
12214 private final String _fieldName;
12215
12216 _Fields(short thriftId, String fieldName) {
12217 _thriftId = thriftId;
12218 _fieldName = fieldName;
12219 }
12220
12221 public short getThriftFieldId() {
12222 return _thriftId;
12223 }
12224
12225 public String getFieldName() {
12226 return _fieldName;
12227 }
12228 }
12229
12230
12231 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
12232 static {
12233 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
12234 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
12235 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
12236 tmpMap.put(_Fields.SCAN, new org.apache.thrift.meta_data.FieldMetaData("scan", org.apache.thrift.TFieldRequirementType.REQUIRED,
12237 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TScan.class)));
12238 metaDataMap = Collections.unmodifiableMap(tmpMap);
12239 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_args.class, metaDataMap);
12240 }
12241
12242 public openScanner_args() {
12243 }
12244
12245 public openScanner_args(
12246 ByteBuffer table,
12247 TScan scan)
12248 {
12249 this();
12250 this.table = table;
12251 this.scan = scan;
12252 }
12253
12254
12255
12256
12257 public openScanner_args(openScanner_args other) {
12258 if (other.isSetTable()) {
12259 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
12260 ;
12261 }
12262 if (other.isSetScan()) {
12263 this.scan = new TScan(other.scan);
12264 }
12265 }
12266
12267 public openScanner_args deepCopy() {
12268 return new openScanner_args(this);
12269 }
12270
12271 @Override
12272 public void clear() {
12273 this.table = null;
12274 this.scan = null;
12275 }
12276
12277
12278
12279
12280 public byte[] getTable() {
12281 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
12282 return table == null ? null : table.array();
12283 }
12284
12285 public ByteBuffer bufferForTable() {
12286 return table;
12287 }
12288
12289
12290
12291
12292 public openScanner_args setTable(byte[] table) {
12293 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
12294 return this;
12295 }
12296
12297 public openScanner_args setTable(ByteBuffer table) {
12298 this.table = table;
12299 return this;
12300 }
12301
12302 public void unsetTable() {
12303 this.table = null;
12304 }
12305
12306
12307 public boolean isSetTable() {
12308 return this.table != null;
12309 }
12310
12311 public void setTableIsSet(boolean value) {
12312 if (!value) {
12313 this.table = null;
12314 }
12315 }
12316
12317
12318
12319
12320 public TScan getScan() {
12321 return this.scan;
12322 }
12323
12324
12325
12326
12327 public openScanner_args setScan(TScan scan) {
12328 this.scan = scan;
12329 return this;
12330 }
12331
12332 public void unsetScan() {
12333 this.scan = null;
12334 }
12335
12336
12337 public boolean isSetScan() {
12338 return this.scan != null;
12339 }
12340
12341 public void setScanIsSet(boolean value) {
12342 if (!value) {
12343 this.scan = null;
12344 }
12345 }
12346
12347 public void setFieldValue(_Fields field, Object value) {
12348 switch (field) {
12349 case TABLE:
12350 if (value == null) {
12351 unsetTable();
12352 } else {
12353 setTable((ByteBuffer)value);
12354 }
12355 break;
12356
12357 case SCAN:
12358 if (value == null) {
12359 unsetScan();
12360 } else {
12361 setScan((TScan)value);
12362 }
12363 break;
12364
12365 }
12366 }
12367
12368 public Object getFieldValue(_Fields field) {
12369 switch (field) {
12370 case TABLE:
12371 return getTable();
12372
12373 case SCAN:
12374 return getScan();
12375
12376 }
12377 throw new IllegalStateException();
12378 }
12379
12380
12381 public boolean isSet(_Fields field) {
12382 if (field == null) {
12383 throw new IllegalArgumentException();
12384 }
12385
12386 switch (field) {
12387 case TABLE:
12388 return isSetTable();
12389 case SCAN:
12390 return isSetScan();
12391 }
12392 throw new IllegalStateException();
12393 }
12394
12395 @Override
12396 public boolean equals(Object that) {
12397 if (that == null)
12398 return false;
12399 if (that instanceof openScanner_args)
12400 return this.equals((openScanner_args)that);
12401 return false;
12402 }
12403
12404 public boolean equals(openScanner_args that) {
12405 if (that == null)
12406 return false;
12407
12408 boolean this_present_table = true && this.isSetTable();
12409 boolean that_present_table = true && that.isSetTable();
12410 if (this_present_table || that_present_table) {
12411 if (!(this_present_table && that_present_table))
12412 return false;
12413 if (!this.table.equals(that.table))
12414 return false;
12415 }
12416
12417 boolean this_present_scan = true && this.isSetScan();
12418 boolean that_present_scan = true && that.isSetScan();
12419 if (this_present_scan || that_present_scan) {
12420 if (!(this_present_scan && that_present_scan))
12421 return false;
12422 if (!this.scan.equals(that.scan))
12423 return false;
12424 }
12425
12426 return true;
12427 }
12428
12429 @Override
12430 public int hashCode() {
12431 HashCodeBuilder builder = new HashCodeBuilder();
12432
12433 boolean present_table = true && (isSetTable());
12434 builder.append(present_table);
12435 if (present_table)
12436 builder.append(table);
12437
12438 boolean present_scan = true && (isSetScan());
12439 builder.append(present_scan);
12440 if (present_scan)
12441 builder.append(scan);
12442
12443 return builder.toHashCode();
12444 }
12445
12446 public int compareTo(openScanner_args other) {
12447 if (!getClass().equals(other.getClass())) {
12448 return getClass().getName().compareTo(other.getClass().getName());
12449 }
12450
12451 int lastComparison = 0;
12452 openScanner_args typedOther = (openScanner_args)other;
12453
12454 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
12455 if (lastComparison != 0) {
12456 return lastComparison;
12457 }
12458 if (isSetTable()) {
12459 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
12460 if (lastComparison != 0) {
12461 return lastComparison;
12462 }
12463 }
12464 lastComparison = Boolean.valueOf(isSetScan()).compareTo(typedOther.isSetScan());
12465 if (lastComparison != 0) {
12466 return lastComparison;
12467 }
12468 if (isSetScan()) {
12469 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scan, typedOther.scan);
12470 if (lastComparison != 0) {
12471 return lastComparison;
12472 }
12473 }
12474 return 0;
12475 }
12476
12477 public _Fields fieldForId(int fieldId) {
12478 return _Fields.findByThriftId(fieldId);
12479 }
12480
12481 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
12482 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
12483 }
12484
12485 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
12486 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
12487 }
12488
12489 @Override
12490 public String toString() {
12491 StringBuilder sb = new StringBuilder("openScanner_args(");
12492 boolean first = true;
12493
12494 sb.append("table:");
12495 if (this.table == null) {
12496 sb.append("null");
12497 } else {
12498 org.apache.thrift.TBaseHelper.toString(this.table, sb);
12499 }
12500 first = false;
12501 if (!first) sb.append(", ");
12502 sb.append("scan:");
12503 if (this.scan == null) {
12504 sb.append("null");
12505 } else {
12506 sb.append(this.scan);
12507 }
12508 first = false;
12509 sb.append(")");
12510 return sb.toString();
12511 }
12512
12513 public void validate() throws org.apache.thrift.TException {
12514
12515 if (table == null) {
12516 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
12517 }
12518 if (scan == null) {
12519 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scan' was not present! Struct: " + toString());
12520 }
12521 }
12522
12523 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12524 try {
12525 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12526 } catch (org.apache.thrift.TException te) {
12527 throw new java.io.IOException(te);
12528 }
12529 }
12530
12531 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12532 try {
12533 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12534 } catch (org.apache.thrift.TException te) {
12535 throw new java.io.IOException(te);
12536 }
12537 }
12538
12539 private static class openScanner_argsStandardSchemeFactory implements SchemeFactory {
12540 public openScanner_argsStandardScheme getScheme() {
12541 return new openScanner_argsStandardScheme();
12542 }
12543 }
12544
12545 private static class openScanner_argsStandardScheme extends StandardScheme<openScanner_args> {
12546
12547 public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_args struct) throws org.apache.thrift.TException {
12548 org.apache.thrift.protocol.TField schemeField;
12549 iprot.readStructBegin();
12550 while (true)
12551 {
12552 schemeField = iprot.readFieldBegin();
12553 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
12554 break;
12555 }
12556 switch (schemeField.id) {
12557 case 1:
12558 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
12559 struct.table = iprot.readBinary();
12560 struct.setTableIsSet(true);
12561 } else {
12562 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12563 }
12564 break;
12565 case 2:
12566 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
12567 struct.scan = new TScan();
12568 struct.scan.read(iprot);
12569 struct.setScanIsSet(true);
12570 } else {
12571 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12572 }
12573 break;
12574 default:
12575 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12576 }
12577 iprot.readFieldEnd();
12578 }
12579 iprot.readStructEnd();
12580
12581
12582 struct.validate();
12583 }
12584
12585 public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_args struct) throws org.apache.thrift.TException {
12586 struct.validate();
12587
12588 oprot.writeStructBegin(STRUCT_DESC);
12589 if (struct.table != null) {
12590 oprot.writeFieldBegin(TABLE_FIELD_DESC);
12591 oprot.writeBinary(struct.table);
12592 oprot.writeFieldEnd();
12593 }
12594 if (struct.scan != null) {
12595 oprot.writeFieldBegin(SCAN_FIELD_DESC);
12596 struct.scan.write(oprot);
12597 oprot.writeFieldEnd();
12598 }
12599 oprot.writeFieldStop();
12600 oprot.writeStructEnd();
12601 }
12602
12603 }
12604
12605 private static class openScanner_argsTupleSchemeFactory implements SchemeFactory {
12606 public openScanner_argsTupleScheme getScheme() {
12607 return new openScanner_argsTupleScheme();
12608 }
12609 }
12610
12611 private static class openScanner_argsTupleScheme extends TupleScheme<openScanner_args> {
12612
12613 @Override
12614 public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
12615 TTupleProtocol oprot = (TTupleProtocol) prot;
12616 oprot.writeBinary(struct.table);
12617 struct.scan.write(oprot);
12618 }
12619
12620 @Override
12621 public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
12622 TTupleProtocol iprot = (TTupleProtocol) prot;
12623 struct.table = iprot.readBinary();
12624 struct.setTableIsSet(true);
12625 struct.scan = new TScan();
12626 struct.scan.read(iprot);
12627 struct.setScanIsSet(true);
12628 }
12629 }
12630
12631 }
12632
12633 public static class openScanner_result implements org.apache.thrift.TBase<openScanner_result, openScanner_result._Fields>, java.io.Serializable, Cloneable {
12634 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_result");
12635
12636 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (short)0);
12637 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
12638
12639 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
12640 static {
12641 schemes.put(StandardScheme.class, new openScanner_resultStandardSchemeFactory());
12642 schemes.put(TupleScheme.class, new openScanner_resultTupleSchemeFactory());
12643 }
12644
12645 public int success;
12646 public TIOError io;
12647
12648
12649 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
12650 SUCCESS((short)0, "success"),
12651 IO((short)1, "io");
12652
12653 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12654
12655 static {
12656 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12657 byName.put(field.getFieldName(), field);
12658 }
12659 }
12660
12661
12662
12663
12664 public static _Fields findByThriftId(int fieldId) {
12665 switch(fieldId) {
12666 case 0:
12667 return SUCCESS;
12668 case 1:
12669 return IO;
12670 default:
12671 return null;
12672 }
12673 }
12674
12675
12676
12677
12678
12679 public static _Fields findByThriftIdOrThrow(int fieldId) {
12680 _Fields fields = findByThriftId(fieldId);
12681 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12682 return fields;
12683 }
12684
12685
12686
12687
12688 public static _Fields findByName(String name) {
12689 return byName.get(name);
12690 }
12691
12692 private final short _thriftId;
12693 private final String _fieldName;
12694
12695 _Fields(short thriftId, String fieldName) {
12696 _thriftId = thriftId;
12697 _fieldName = fieldName;
12698 }
12699
12700 public short getThriftFieldId() {
12701 return _thriftId;
12702 }
12703
12704 public String getFieldName() {
12705 return _fieldName;
12706 }
12707 }
12708
12709
12710 private static final int __SUCCESS_ISSET_ID = 0;
12711 private BitSet __isset_bit_vector = new BitSet(1);
12712 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
12713 static {
12714 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
12715 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
12716 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12717 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
12718 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
12719 metaDataMap = Collections.unmodifiableMap(tmpMap);
12720 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_result.class, metaDataMap);
12721 }
12722
12723 public openScanner_result() {
12724 }
12725
12726 public openScanner_result(
12727 int success,
12728 TIOError io)
12729 {
12730 this();
12731 this.success = success;
12732 setSuccessIsSet(true);
12733 this.io = io;
12734 }
12735
12736
12737
12738
12739 public openScanner_result(openScanner_result other) {
12740 __isset_bit_vector.clear();
12741 __isset_bit_vector.or(other.__isset_bit_vector);
12742 this.success = other.success;
12743 if (other.isSetIo()) {
12744 this.io = new TIOError(other.io);
12745 }
12746 }
12747
12748 public openScanner_result deepCopy() {
12749 return new openScanner_result(this);
12750 }
12751
12752 @Override
12753 public void clear() {
12754 setSuccessIsSet(false);
12755 this.success = 0;
12756 this.io = null;
12757 }
12758
12759 public int getSuccess() {
12760 return this.success;
12761 }
12762
12763 public openScanner_result setSuccess(int success) {
12764 this.success = success;
12765 setSuccessIsSet(true);
12766 return this;
12767 }
12768
12769 public void unsetSuccess() {
12770 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
12771 }
12772
12773
12774 public boolean isSetSuccess() {
12775 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
12776 }
12777
12778 public void setSuccessIsSet(boolean value) {
12779 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
12780 }
12781
12782 public TIOError getIo() {
12783 return this.io;
12784 }
12785
12786 public openScanner_result setIo(TIOError io) {
12787 this.io = io;
12788 return this;
12789 }
12790
12791 public void unsetIo() {
12792 this.io = null;
12793 }
12794
12795
12796 public boolean isSetIo() {
12797 return this.io != null;
12798 }
12799
12800 public void setIoIsSet(boolean value) {
12801 if (!value) {
12802 this.io = null;
12803 }
12804 }
12805
12806 public void setFieldValue(_Fields field, Object value) {
12807 switch (field) {
12808 case SUCCESS:
12809 if (value == null) {
12810 unsetSuccess();
12811 } else {
12812 setSuccess((Integer)value);
12813 }
12814 break;
12815
12816 case IO:
12817 if (value == null) {
12818 unsetIo();
12819 } else {
12820 setIo((TIOError)value);
12821 }
12822 break;
12823
12824 }
12825 }
12826
12827 public Object getFieldValue(_Fields field) {
12828 switch (field) {
12829 case SUCCESS:
12830 return Integer.valueOf(getSuccess());
12831
12832 case IO:
12833 return getIo();
12834
12835 }
12836 throw new IllegalStateException();
12837 }
12838
12839
12840 public boolean isSet(_Fields field) {
12841 if (field == null) {
12842 throw new IllegalArgumentException();
12843 }
12844
12845 switch (field) {
12846 case SUCCESS:
12847 return isSetSuccess();
12848 case IO:
12849 return isSetIo();
12850 }
12851 throw new IllegalStateException();
12852 }
12853
12854 @Override
12855 public boolean equals(Object that) {
12856 if (that == null)
12857 return false;
12858 if (that instanceof openScanner_result)
12859 return this.equals((openScanner_result)that);
12860 return false;
12861 }
12862
12863 public boolean equals(openScanner_result that) {
12864 if (that == null)
12865 return false;
12866
12867 boolean this_present_success = true;
12868 boolean that_present_success = true;
12869 if (this_present_success || that_present_success) {
12870 if (!(this_present_success && that_present_success))
12871 return false;
12872 if (this.success != that.success)
12873 return false;
12874 }
12875
12876 boolean this_present_io = true && this.isSetIo();
12877 boolean that_present_io = true && that.isSetIo();
12878 if (this_present_io || that_present_io) {
12879 if (!(this_present_io && that_present_io))
12880 return false;
12881 if (!this.io.equals(that.io))
12882 return false;
12883 }
12884
12885 return true;
12886 }
12887
12888 @Override
12889 public int hashCode() {
12890 HashCodeBuilder builder = new HashCodeBuilder();
12891
12892 boolean present_success = true;
12893 builder.append(present_success);
12894 if (present_success)
12895 builder.append(success);
12896
12897 boolean present_io = true && (isSetIo());
12898 builder.append(present_io);
12899 if (present_io)
12900 builder.append(io);
12901
12902 return builder.toHashCode();
12903 }
12904
12905 public int compareTo(openScanner_result other) {
12906 if (!getClass().equals(other.getClass())) {
12907 return getClass().getName().compareTo(other.getClass().getName());
12908 }
12909
12910 int lastComparison = 0;
12911 openScanner_result typedOther = (openScanner_result)other;
12912
12913 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
12914 if (lastComparison != 0) {
12915 return lastComparison;
12916 }
12917 if (isSetSuccess()) {
12918 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
12919 if (lastComparison != 0) {
12920 return lastComparison;
12921 }
12922 }
12923 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
12924 if (lastComparison != 0) {
12925 return lastComparison;
12926 }
12927 if (isSetIo()) {
12928 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
12929 if (lastComparison != 0) {
12930 return lastComparison;
12931 }
12932 }
12933 return 0;
12934 }
12935
12936 public _Fields fieldForId(int fieldId) {
12937 return _Fields.findByThriftId(fieldId);
12938 }
12939
12940 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
12941 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
12942 }
12943
12944 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
12945 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
12946 }
12947
12948 @Override
12949 public String toString() {
12950 StringBuilder sb = new StringBuilder("openScanner_result(");
12951 boolean first = true;
12952
12953 sb.append("success:");
12954 sb.append(this.success);
12955 first = false;
12956 if (!first) sb.append(", ");
12957 sb.append("io:");
12958 if (this.io == null) {
12959 sb.append("null");
12960 } else {
12961 sb.append(this.io);
12962 }
12963 first = false;
12964 sb.append(")");
12965 return sb.toString();
12966 }
12967
12968 public void validate() throws org.apache.thrift.TException {
12969
12970 }
12971
12972 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12973 try {
12974 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12975 } catch (org.apache.thrift.TException te) {
12976 throw new java.io.IOException(te);
12977 }
12978 }
12979
12980 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12981 try {
12982 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12983 } catch (org.apache.thrift.TException te) {
12984 throw new java.io.IOException(te);
12985 }
12986 }
12987
12988 private static class openScanner_resultStandardSchemeFactory implements SchemeFactory {
12989 public openScanner_resultStandardScheme getScheme() {
12990 return new openScanner_resultStandardScheme();
12991 }
12992 }
12993
12994 private static class openScanner_resultStandardScheme extends StandardScheme<openScanner_result> {
12995
12996 public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_result struct) throws org.apache.thrift.TException {
12997 org.apache.thrift.protocol.TField schemeField;
12998 iprot.readStructBegin();
12999 while (true)
13000 {
13001 schemeField = iprot.readFieldBegin();
13002 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
13003 break;
13004 }
13005 switch (schemeField.id) {
13006 case 0:
13007 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
13008 struct.success = iprot.readI32();
13009 struct.setSuccessIsSet(true);
13010 } else {
13011 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13012 }
13013 break;
13014 case 1:
13015 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
13016 struct.io = new TIOError();
13017 struct.io.read(iprot);
13018 struct.setIoIsSet(true);
13019 } else {
13020 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13021 }
13022 break;
13023 default:
13024 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13025 }
13026 iprot.readFieldEnd();
13027 }
13028 iprot.readStructEnd();
13029
13030
13031 struct.validate();
13032 }
13033
13034 public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_result struct) throws org.apache.thrift.TException {
13035 struct.validate();
13036
13037 oprot.writeStructBegin(STRUCT_DESC);
13038 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13039 oprot.writeI32(struct.success);
13040 oprot.writeFieldEnd();
13041 if (struct.io != null) {
13042 oprot.writeFieldBegin(IO_FIELD_DESC);
13043 struct.io.write(oprot);
13044 oprot.writeFieldEnd();
13045 }
13046 oprot.writeFieldStop();
13047 oprot.writeStructEnd();
13048 }
13049
13050 }
13051
13052 private static class openScanner_resultTupleSchemeFactory implements SchemeFactory {
13053 public openScanner_resultTupleScheme getScheme() {
13054 return new openScanner_resultTupleScheme();
13055 }
13056 }
13057
13058 private static class openScanner_resultTupleScheme extends TupleScheme<openScanner_result> {
13059
13060 @Override
13061 public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
13062 TTupleProtocol oprot = (TTupleProtocol) prot;
13063 BitSet optionals = new BitSet();
13064 if (struct.isSetSuccess()) {
13065 optionals.set(0);
13066 }
13067 if (struct.isSetIo()) {
13068 optionals.set(1);
13069 }
13070 oprot.writeBitSet(optionals, 2);
13071 if (struct.isSetSuccess()) {
13072 oprot.writeI32(struct.success);
13073 }
13074 if (struct.isSetIo()) {
13075 struct.io.write(oprot);
13076 }
13077 }
13078
13079 @Override
13080 public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
13081 TTupleProtocol iprot = (TTupleProtocol) prot;
13082 BitSet incoming = iprot.readBitSet(2);
13083 if (incoming.get(0)) {
13084 struct.success = iprot.readI32();
13085 struct.setSuccessIsSet(true);
13086 }
13087 if (incoming.get(1)) {
13088 struct.io = new TIOError();
13089 struct.io.read(iprot);
13090 struct.setIoIsSet(true);
13091 }
13092 }
13093 }
13094
13095 }
13096
13097 public static class getScannerRows_args implements org.apache.thrift.TBase<getScannerRows_args, getScannerRows_args._Fields>, java.io.Serializable, Cloneable {
13098 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_args");
13099
13100 private static final org.apache.thrift.protocol.TField SCANNER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scannerId", org.apache.thrift.protocol.TType.I32, (short)1);
13101 private static final org.apache.thrift.protocol.TField NUM_ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("numRows", org.apache.thrift.protocol.TType.I32, (short)2);
13102
13103 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
13104 static {
13105 schemes.put(StandardScheme.class, new getScannerRows_argsStandardSchemeFactory());
13106 schemes.put(TupleScheme.class, new getScannerRows_argsTupleSchemeFactory());
13107 }
13108
13109
13110
13111
13112 public int scannerId;
13113
13114
13115
13116 public int numRows;
13117
13118
13119 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
13120
13121
13122
13123 SCANNER_ID((short)1, "scannerId"),
13124
13125
13126
13127 NUM_ROWS((short)2, "numRows");
13128
13129 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13130
13131 static {
13132 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13133 byName.put(field.getFieldName(), field);
13134 }
13135 }
13136
13137
13138
13139
13140 public static _Fields findByThriftId(int fieldId) {
13141 switch(fieldId) {
13142 case 1:
13143 return SCANNER_ID;
13144 case 2:
13145 return NUM_ROWS;
13146 default:
13147 return null;
13148 }
13149 }
13150
13151
13152
13153
13154
13155 public static _Fields findByThriftIdOrThrow(int fieldId) {
13156 _Fields fields = findByThriftId(fieldId);
13157 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13158 return fields;
13159 }
13160
13161
13162
13163
13164 public static _Fields findByName(String name) {
13165 return byName.get(name);
13166 }
13167
13168 private final short _thriftId;
13169 private final String _fieldName;
13170
13171 _Fields(short thriftId, String fieldName) {
13172 _thriftId = thriftId;
13173 _fieldName = fieldName;
13174 }
13175
13176 public short getThriftFieldId() {
13177 return _thriftId;
13178 }
13179
13180 public String getFieldName() {
13181 return _fieldName;
13182 }
13183 }
13184
13185
13186 private static final int __SCANNERID_ISSET_ID = 0;
13187 private static final int __NUMROWS_ISSET_ID = 1;
13188 private BitSet __isset_bit_vector = new BitSet(2);
13189 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
13190 static {
13191 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
13192 tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
13193 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
13194 tmpMap.put(_Fields.NUM_ROWS, new org.apache.thrift.meta_data.FieldMetaData("numRows", org.apache.thrift.TFieldRequirementType.DEFAULT,
13195 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
13196 metaDataMap = Collections.unmodifiableMap(tmpMap);
13197 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_args.class, metaDataMap);
13198 }
13199
13200 public getScannerRows_args() {
13201 this.numRows = 1;
13202
13203 }
13204
13205 public getScannerRows_args(
13206 int scannerId,
13207 int numRows)
13208 {
13209 this();
13210 this.scannerId = scannerId;
13211 setScannerIdIsSet(true);
13212 this.numRows = numRows;
13213 setNumRowsIsSet(true);
13214 }
13215
13216
13217
13218
13219 public getScannerRows_args(getScannerRows_args other) {
13220 __isset_bit_vector.clear();
13221 __isset_bit_vector.or(other.__isset_bit_vector);
13222 this.scannerId = other.scannerId;
13223 this.numRows = other.numRows;
13224 }
13225
13226 public getScannerRows_args deepCopy() {
13227 return new getScannerRows_args(this);
13228 }
13229
13230 @Override
13231 public void clear() {
13232 setScannerIdIsSet(false);
13233 this.scannerId = 0;
13234 this.numRows = 1;
13235
13236 }
13237
13238
13239
13240
13241 public int getScannerId() {
13242 return this.scannerId;
13243 }
13244
13245
13246
13247
13248 public getScannerRows_args setScannerId(int scannerId) {
13249 this.scannerId = scannerId;
13250 setScannerIdIsSet(true);
13251 return this;
13252 }
13253
13254 public void unsetScannerId() {
13255 __isset_bit_vector.clear(__SCANNERID_ISSET_ID);
13256 }
13257
13258
13259 public boolean isSetScannerId() {
13260 return __isset_bit_vector.get(__SCANNERID_ISSET_ID);
13261 }
13262
13263 public void setScannerIdIsSet(boolean value) {
13264 __isset_bit_vector.set(__SCANNERID_ISSET_ID, value);
13265 }
13266
13267
13268
13269
13270 public int getNumRows() {
13271 return this.numRows;
13272 }
13273
13274
13275
13276
13277 public getScannerRows_args setNumRows(int numRows) {
13278 this.numRows = numRows;
13279 setNumRowsIsSet(true);
13280 return this;
13281 }
13282
13283 public void unsetNumRows() {
13284 __isset_bit_vector.clear(__NUMROWS_ISSET_ID);
13285 }
13286
13287
13288 public boolean isSetNumRows() {
13289 return __isset_bit_vector.get(__NUMROWS_ISSET_ID);
13290 }
13291
13292 public void setNumRowsIsSet(boolean value) {
13293 __isset_bit_vector.set(__NUMROWS_ISSET_ID, value);
13294 }
13295
13296 public void setFieldValue(_Fields field, Object value) {
13297 switch (field) {
13298 case SCANNER_ID:
13299 if (value == null) {
13300 unsetScannerId();
13301 } else {
13302 setScannerId((Integer)value);
13303 }
13304 break;
13305
13306 case NUM_ROWS:
13307 if (value == null) {
13308 unsetNumRows();
13309 } else {
13310 setNumRows((Integer)value);
13311 }
13312 break;
13313
13314 }
13315 }
13316
13317 public Object getFieldValue(_Fields field) {
13318 switch (field) {
13319 case SCANNER_ID:
13320 return Integer.valueOf(getScannerId());
13321
13322 case NUM_ROWS:
13323 return Integer.valueOf(getNumRows());
13324
13325 }
13326 throw new IllegalStateException();
13327 }
13328
13329
13330 public boolean isSet(_Fields field) {
13331 if (field == null) {
13332 throw new IllegalArgumentException();
13333 }
13334
13335 switch (field) {
13336 case SCANNER_ID:
13337 return isSetScannerId();
13338 case NUM_ROWS:
13339 return isSetNumRows();
13340 }
13341 throw new IllegalStateException();
13342 }
13343
13344 @Override
13345 public boolean equals(Object that) {
13346 if (that == null)
13347 return false;
13348 if (that instanceof getScannerRows_args)
13349 return this.equals((getScannerRows_args)that);
13350 return false;
13351 }
13352
13353 public boolean equals(getScannerRows_args that) {
13354 if (that == null)
13355 return false;
13356
13357 boolean this_present_scannerId = true;
13358 boolean that_present_scannerId = true;
13359 if (this_present_scannerId || that_present_scannerId) {
13360 if (!(this_present_scannerId && that_present_scannerId))
13361 return false;
13362 if (this.scannerId != that.scannerId)
13363 return false;
13364 }
13365
13366 boolean this_present_numRows = true;
13367 boolean that_present_numRows = true;
13368 if (this_present_numRows || that_present_numRows) {
13369 if (!(this_present_numRows && that_present_numRows))
13370 return false;
13371 if (this.numRows != that.numRows)
13372 return false;
13373 }
13374
13375 return true;
13376 }
13377
13378 @Override
13379 public int hashCode() {
13380 HashCodeBuilder builder = new HashCodeBuilder();
13381
13382 boolean present_scannerId = true;
13383 builder.append(present_scannerId);
13384 if (present_scannerId)
13385 builder.append(scannerId);
13386
13387 boolean present_numRows = true;
13388 builder.append(present_numRows);
13389 if (present_numRows)
13390 builder.append(numRows);
13391
13392 return builder.toHashCode();
13393 }
13394
13395 public int compareTo(getScannerRows_args other) {
13396 if (!getClass().equals(other.getClass())) {
13397 return getClass().getName().compareTo(other.getClass().getName());
13398 }
13399
13400 int lastComparison = 0;
13401 getScannerRows_args typedOther = (getScannerRows_args)other;
13402
13403 lastComparison = Boolean.valueOf(isSetScannerId()).compareTo(typedOther.isSetScannerId());
13404 if (lastComparison != 0) {
13405 return lastComparison;
13406 }
13407 if (isSetScannerId()) {
13408 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, typedOther.scannerId);
13409 if (lastComparison != 0) {
13410 return lastComparison;
13411 }
13412 }
13413 lastComparison = Boolean.valueOf(isSetNumRows()).compareTo(typedOther.isSetNumRows());
13414 if (lastComparison != 0) {
13415 return lastComparison;
13416 }
13417 if (isSetNumRows()) {
13418 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numRows, typedOther.numRows);
13419 if (lastComparison != 0) {
13420 return lastComparison;
13421 }
13422 }
13423 return 0;
13424 }
13425
13426 public _Fields fieldForId(int fieldId) {
13427 return _Fields.findByThriftId(fieldId);
13428 }
13429
13430 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
13431 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
13432 }
13433
13434 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
13435 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
13436 }
13437
13438 @Override
13439 public String toString() {
13440 StringBuilder sb = new StringBuilder("getScannerRows_args(");
13441 boolean first = true;
13442
13443 sb.append("scannerId:");
13444 sb.append(this.scannerId);
13445 first = false;
13446 if (!first) sb.append(", ");
13447 sb.append("numRows:");
13448 sb.append(this.numRows);
13449 first = false;
13450 sb.append(")");
13451 return sb.toString();
13452 }
13453
13454 public void validate() throws org.apache.thrift.TException {
13455
13456
13457 }
13458
13459 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
13460 try {
13461 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
13462 } catch (org.apache.thrift.TException te) {
13463 throw new java.io.IOException(te);
13464 }
13465 }
13466
13467 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
13468 try {
13469
13470 __isset_bit_vector = new BitSet(1);
13471 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
13472 } catch (org.apache.thrift.TException te) {
13473 throw new java.io.IOException(te);
13474 }
13475 }
13476
13477 private static class getScannerRows_argsStandardSchemeFactory implements SchemeFactory {
13478 public getScannerRows_argsStandardScheme getScheme() {
13479 return new getScannerRows_argsStandardScheme();
13480 }
13481 }
13482
13483 private static class getScannerRows_argsStandardScheme extends StandardScheme<getScannerRows_args> {
13484
13485 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_args struct) throws org.apache.thrift.TException {
13486 org.apache.thrift.protocol.TField schemeField;
13487 iprot.readStructBegin();
13488 while (true)
13489 {
13490 schemeField = iprot.readFieldBegin();
13491 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
13492 break;
13493 }
13494 switch (schemeField.id) {
13495 case 1:
13496 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
13497 struct.scannerId = iprot.readI32();
13498 struct.setScannerIdIsSet(true);
13499 } else {
13500 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13501 }
13502 break;
13503 case 2:
13504 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
13505 struct.numRows = iprot.readI32();
13506 struct.setNumRowsIsSet(true);
13507 } else {
13508 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13509 }
13510 break;
13511 default:
13512 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13513 }
13514 iprot.readFieldEnd();
13515 }
13516 iprot.readStructEnd();
13517
13518
13519 if (!struct.isSetScannerId()) {
13520 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
13521 }
13522 struct.validate();
13523 }
13524
13525 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_args struct) throws org.apache.thrift.TException {
13526 struct.validate();
13527
13528 oprot.writeStructBegin(STRUCT_DESC);
13529 oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
13530 oprot.writeI32(struct.scannerId);
13531 oprot.writeFieldEnd();
13532 oprot.writeFieldBegin(NUM_ROWS_FIELD_DESC);
13533 oprot.writeI32(struct.numRows);
13534 oprot.writeFieldEnd();
13535 oprot.writeFieldStop();
13536 oprot.writeStructEnd();
13537 }
13538
13539 }
13540
13541 private static class getScannerRows_argsTupleSchemeFactory implements SchemeFactory {
13542 public getScannerRows_argsTupleScheme getScheme() {
13543 return new getScannerRows_argsTupleScheme();
13544 }
13545 }
13546
13547 private static class getScannerRows_argsTupleScheme extends TupleScheme<getScannerRows_args> {
13548
13549 @Override
13550 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
13551 TTupleProtocol oprot = (TTupleProtocol) prot;
13552 oprot.writeI32(struct.scannerId);
13553 BitSet optionals = new BitSet();
13554 if (struct.isSetNumRows()) {
13555 optionals.set(0);
13556 }
13557 oprot.writeBitSet(optionals, 1);
13558 if (struct.isSetNumRows()) {
13559 oprot.writeI32(struct.numRows);
13560 }
13561 }
13562
13563 @Override
13564 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
13565 TTupleProtocol iprot = (TTupleProtocol) prot;
13566 struct.scannerId = iprot.readI32();
13567 struct.setScannerIdIsSet(true);
13568 BitSet incoming = iprot.readBitSet(1);
13569 if (incoming.get(0)) {
13570 struct.numRows = iprot.readI32();
13571 struct.setNumRowsIsSet(true);
13572 }
13573 }
13574 }
13575
13576 }
13577
13578 public static class getScannerRows_result implements org.apache.thrift.TBase<getScannerRows_result, getScannerRows_result._Fields>, java.io.Serializable, Cloneable {
13579 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_result");
13580
13581 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
13582 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
13583 private static final org.apache.thrift.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2);
13584
13585 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
13586 static {
13587 schemes.put(StandardScheme.class, new getScannerRows_resultStandardSchemeFactory());
13588 schemes.put(TupleScheme.class, new getScannerRows_resultTupleSchemeFactory());
13589 }
13590
13591 public List<TResult> success;
13592 public TIOError io;
13593
13594
13595
13596 public TIllegalArgument ia;
13597
13598
13599 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
13600 SUCCESS((short)0, "success"),
13601 IO((short)1, "io"),
13602
13603
13604
13605 IA((short)2, "ia");
13606
13607 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13608
13609 static {
13610 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13611 byName.put(field.getFieldName(), field);
13612 }
13613 }
13614
13615
13616
13617
13618 public static _Fields findByThriftId(int fieldId) {
13619 switch(fieldId) {
13620 case 0:
13621 return SUCCESS;
13622 case 1:
13623 return IO;
13624 case 2:
13625 return IA;
13626 default:
13627 return null;
13628 }
13629 }
13630
13631
13632
13633
13634
13635 public static _Fields findByThriftIdOrThrow(int fieldId) {
13636 _Fields fields = findByThriftId(fieldId);
13637 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13638 return fields;
13639 }
13640
13641
13642
13643
13644 public static _Fields findByName(String name) {
13645 return byName.get(name);
13646 }
13647
13648 private final short _thriftId;
13649 private final String _fieldName;
13650
13651 _Fields(short thriftId, String fieldName) {
13652 _thriftId = thriftId;
13653 _fieldName = fieldName;
13654 }
13655
13656 public short getThriftFieldId() {
13657 return _thriftId;
13658 }
13659
13660 public String getFieldName() {
13661 return _fieldName;
13662 }
13663 }
13664
13665
13666 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
13667 static {
13668 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
13669 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
13670 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
13671 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
13672 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
13673 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
13674 tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
13675 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
13676 metaDataMap = Collections.unmodifiableMap(tmpMap);
13677 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_result.class, metaDataMap);
13678 }
13679
13680 public getScannerRows_result() {
13681 }
13682
13683 public getScannerRows_result(
13684 List<TResult> success,
13685 TIOError io,
13686 TIllegalArgument ia)
13687 {
13688 this();
13689 this.success = success;
13690 this.io = io;
13691 this.ia = ia;
13692 }
13693
13694
13695
13696
13697 public getScannerRows_result(getScannerRows_result other) {
13698 if (other.isSetSuccess()) {
13699 List<TResult> __this__success = new ArrayList<TResult>();
13700 for (TResult other_element : other.success) {
13701 __this__success.add(new TResult(other_element));
13702 }
13703 this.success = __this__success;
13704 }
13705 if (other.isSetIo()) {
13706 this.io = new TIOError(other.io);
13707 }
13708 if (other.isSetIa()) {
13709 this.ia = new TIllegalArgument(other.ia);
13710 }
13711 }
13712
13713 public getScannerRows_result deepCopy() {
13714 return new getScannerRows_result(this);
13715 }
13716
13717 @Override
13718 public void clear() {
13719 this.success = null;
13720 this.io = null;
13721 this.ia = null;
13722 }
13723
13724 public int getSuccessSize() {
13725 return (this.success == null) ? 0 : this.success.size();
13726 }
13727
13728 public java.util.Iterator<TResult> getSuccessIterator() {
13729 return (this.success == null) ? null : this.success.iterator();
13730 }
13731
13732 public void addToSuccess(TResult elem) {
13733 if (this.success == null) {
13734 this.success = new ArrayList<TResult>();
13735 }
13736 this.success.add(elem);
13737 }
13738
13739 public List<TResult> getSuccess() {
13740 return this.success;
13741 }
13742
13743 public getScannerRows_result setSuccess(List<TResult> success) {
13744 this.success = success;
13745 return this;
13746 }
13747
13748 public void unsetSuccess() {
13749 this.success = null;
13750 }
13751
13752
13753 public boolean isSetSuccess() {
13754 return this.success != null;
13755 }
13756
13757 public void setSuccessIsSet(boolean value) {
13758 if (!value) {
13759 this.success = null;
13760 }
13761 }
13762
13763 public TIOError getIo() {
13764 return this.io;
13765 }
13766
13767 public getScannerRows_result setIo(TIOError io) {
13768 this.io = io;
13769 return this;
13770 }
13771
13772 public void unsetIo() {
13773 this.io = null;
13774 }
13775
13776
13777 public boolean isSetIo() {
13778 return this.io != null;
13779 }
13780
13781 public void setIoIsSet(boolean value) {
13782 if (!value) {
13783 this.io = null;
13784 }
13785 }
13786
13787
13788
13789
13790 public TIllegalArgument getIa() {
13791 return this.ia;
13792 }
13793
13794
13795
13796
13797 public getScannerRows_result setIa(TIllegalArgument ia) {
13798 this.ia = ia;
13799 return this;
13800 }
13801
13802 public void unsetIa() {
13803 this.ia = null;
13804 }
13805
13806
13807 public boolean isSetIa() {
13808 return this.ia != null;
13809 }
13810
13811 public void setIaIsSet(boolean value) {
13812 if (!value) {
13813 this.ia = null;
13814 }
13815 }
13816
13817 public void setFieldValue(_Fields field, Object value) {
13818 switch (field) {
13819 case SUCCESS:
13820 if (value == null) {
13821 unsetSuccess();
13822 } else {
13823 setSuccess((List<TResult>)value);
13824 }
13825 break;
13826
13827 case IO:
13828 if (value == null) {
13829 unsetIo();
13830 } else {
13831 setIo((TIOError)value);
13832 }
13833 break;
13834
13835 case IA:
13836 if (value == null) {
13837 unsetIa();
13838 } else {
13839 setIa((TIllegalArgument)value);
13840 }
13841 break;
13842
13843 }
13844 }
13845
13846 public Object getFieldValue(_Fields field) {
13847 switch (field) {
13848 case SUCCESS:
13849 return getSuccess();
13850
13851 case IO:
13852 return getIo();
13853
13854 case IA:
13855 return getIa();
13856
13857 }
13858 throw new IllegalStateException();
13859 }
13860
13861
13862 public boolean isSet(_Fields field) {
13863 if (field == null) {
13864 throw new IllegalArgumentException();
13865 }
13866
13867 switch (field) {
13868 case SUCCESS:
13869 return isSetSuccess();
13870 case IO:
13871 return isSetIo();
13872 case IA:
13873 return isSetIa();
13874 }
13875 throw new IllegalStateException();
13876 }
13877
13878 @Override
13879 public boolean equals(Object that) {
13880 if (that == null)
13881 return false;
13882 if (that instanceof getScannerRows_result)
13883 return this.equals((getScannerRows_result)that);
13884 return false;
13885 }
13886
13887 public boolean equals(getScannerRows_result that) {
13888 if (that == null)
13889 return false;
13890
13891 boolean this_present_success = true && this.isSetSuccess();
13892 boolean that_present_success = true && that.isSetSuccess();
13893 if (this_present_success || that_present_success) {
13894 if (!(this_present_success && that_present_success))
13895 return false;
13896 if (!this.success.equals(that.success))
13897 return false;
13898 }
13899
13900 boolean this_present_io = true && this.isSetIo();
13901 boolean that_present_io = true && that.isSetIo();
13902 if (this_present_io || that_present_io) {
13903 if (!(this_present_io && that_present_io))
13904 return false;
13905 if (!this.io.equals(that.io))
13906 return false;
13907 }
13908
13909 boolean this_present_ia = true && this.isSetIa();
13910 boolean that_present_ia = true && that.isSetIa();
13911 if (this_present_ia || that_present_ia) {
13912 if (!(this_present_ia && that_present_ia))
13913 return false;
13914 if (!this.ia.equals(that.ia))
13915 return false;
13916 }
13917
13918 return true;
13919 }
13920
13921 @Override
13922 public int hashCode() {
13923 HashCodeBuilder builder = new HashCodeBuilder();
13924
13925 boolean present_success = true && (isSetSuccess());
13926 builder.append(present_success);
13927 if (present_success)
13928 builder.append(success);
13929
13930 boolean present_io = true && (isSetIo());
13931 builder.append(present_io);
13932 if (present_io)
13933 builder.append(io);
13934
13935 boolean present_ia = true && (isSetIa());
13936 builder.append(present_ia);
13937 if (present_ia)
13938 builder.append(ia);
13939
13940 return builder.toHashCode();
13941 }
13942
13943 public int compareTo(getScannerRows_result other) {
13944 if (!getClass().equals(other.getClass())) {
13945 return getClass().getName().compareTo(other.getClass().getName());
13946 }
13947
13948 int lastComparison = 0;
13949 getScannerRows_result typedOther = (getScannerRows_result)other;
13950
13951 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
13952 if (lastComparison != 0) {
13953 return lastComparison;
13954 }
13955 if (isSetSuccess()) {
13956 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
13957 if (lastComparison != 0) {
13958 return lastComparison;
13959 }
13960 }
13961 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
13962 if (lastComparison != 0) {
13963 return lastComparison;
13964 }
13965 if (isSetIo()) {
13966 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
13967 if (lastComparison != 0) {
13968 return lastComparison;
13969 }
13970 }
13971 lastComparison = Boolean.valueOf(isSetIa()).compareTo(typedOther.isSetIa());
13972 if (lastComparison != 0) {
13973 return lastComparison;
13974 }
13975 if (isSetIa()) {
13976 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia);
13977 if (lastComparison != 0) {
13978 return lastComparison;
13979 }
13980 }
13981 return 0;
13982 }
13983
13984 public _Fields fieldForId(int fieldId) {
13985 return _Fields.findByThriftId(fieldId);
13986 }
13987
13988 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
13989 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
13990 }
13991
13992 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
13993 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
13994 }
13995
13996 @Override
13997 public String toString() {
13998 StringBuilder sb = new StringBuilder("getScannerRows_result(");
13999 boolean first = true;
14000
14001 sb.append("success:");
14002 if (this.success == null) {
14003 sb.append("null");
14004 } else {
14005 sb.append(this.success);
14006 }
14007 first = false;
14008 if (!first) sb.append(", ");
14009 sb.append("io:");
14010 if (this.io == null) {
14011 sb.append("null");
14012 } else {
14013 sb.append(this.io);
14014 }
14015 first = false;
14016 if (!first) sb.append(", ");
14017 sb.append("ia:");
14018 if (this.ia == null) {
14019 sb.append("null");
14020 } else {
14021 sb.append(this.ia);
14022 }
14023 first = false;
14024 sb.append(")");
14025 return sb.toString();
14026 }
14027
14028 public void validate() throws org.apache.thrift.TException {
14029
14030 }
14031
14032 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
14033 try {
14034 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
14035 } catch (org.apache.thrift.TException te) {
14036 throw new java.io.IOException(te);
14037 }
14038 }
14039
14040 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
14041 try {
14042 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
14043 } catch (org.apache.thrift.TException te) {
14044 throw new java.io.IOException(te);
14045 }
14046 }
14047
14048 private static class getScannerRows_resultStandardSchemeFactory implements SchemeFactory {
14049 public getScannerRows_resultStandardScheme getScheme() {
14050 return new getScannerRows_resultStandardScheme();
14051 }
14052 }
14053
14054 private static class getScannerRows_resultStandardScheme extends StandardScheme<getScannerRows_result> {
14055
14056 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_result struct) throws org.apache.thrift.TException {
14057 org.apache.thrift.protocol.TField schemeField;
14058 iprot.readStructBegin();
14059 while (true)
14060 {
14061 schemeField = iprot.readFieldBegin();
14062 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
14063 break;
14064 }
14065 switch (schemeField.id) {
14066 case 0:
14067 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
14068 {
14069 org.apache.thrift.protocol.TList _list136 = iprot.readListBegin();
14070 struct.success = new ArrayList<TResult>(_list136.size);
14071 for (int _i137 = 0; _i137 < _list136.size; ++_i137)
14072 {
14073 TResult _elem138;
14074 _elem138 = new TResult();
14075 _elem138.read(iprot);
14076 struct.success.add(_elem138);
14077 }
14078 iprot.readListEnd();
14079 }
14080 struct.setSuccessIsSet(true);
14081 } else {
14082 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14083 }
14084 break;
14085 case 1:
14086 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14087 struct.io = new TIOError();
14088 struct.io.read(iprot);
14089 struct.setIoIsSet(true);
14090 } else {
14091 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14092 }
14093 break;
14094 case 2:
14095 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14096 struct.ia = new TIllegalArgument();
14097 struct.ia.read(iprot);
14098 struct.setIaIsSet(true);
14099 } else {
14100 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14101 }
14102 break;
14103 default:
14104 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14105 }
14106 iprot.readFieldEnd();
14107 }
14108 iprot.readStructEnd();
14109
14110
14111 struct.validate();
14112 }
14113
14114 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_result struct) throws org.apache.thrift.TException {
14115 struct.validate();
14116
14117 oprot.writeStructBegin(STRUCT_DESC);
14118 if (struct.success != null) {
14119 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
14120 {
14121 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
14122 for (TResult _iter139 : struct.success)
14123 {
14124 _iter139.write(oprot);
14125 }
14126 oprot.writeListEnd();
14127 }
14128 oprot.writeFieldEnd();
14129 }
14130 if (struct.io != null) {
14131 oprot.writeFieldBegin(IO_FIELD_DESC);
14132 struct.io.write(oprot);
14133 oprot.writeFieldEnd();
14134 }
14135 if (struct.ia != null) {
14136 oprot.writeFieldBegin(IA_FIELD_DESC);
14137 struct.ia.write(oprot);
14138 oprot.writeFieldEnd();
14139 }
14140 oprot.writeFieldStop();
14141 oprot.writeStructEnd();
14142 }
14143
14144 }
14145
14146 private static class getScannerRows_resultTupleSchemeFactory implements SchemeFactory {
14147 public getScannerRows_resultTupleScheme getScheme() {
14148 return new getScannerRows_resultTupleScheme();
14149 }
14150 }
14151
14152 private static class getScannerRows_resultTupleScheme extends TupleScheme<getScannerRows_result> {
14153
14154 @Override
14155 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
14156 TTupleProtocol oprot = (TTupleProtocol) prot;
14157 BitSet optionals = new BitSet();
14158 if (struct.isSetSuccess()) {
14159 optionals.set(0);
14160 }
14161 if (struct.isSetIo()) {
14162 optionals.set(1);
14163 }
14164 if (struct.isSetIa()) {
14165 optionals.set(2);
14166 }
14167 oprot.writeBitSet(optionals, 3);
14168 if (struct.isSetSuccess()) {
14169 {
14170 oprot.writeI32(struct.success.size());
14171 for (TResult _iter140 : struct.success)
14172 {
14173 _iter140.write(oprot);
14174 }
14175 }
14176 }
14177 if (struct.isSetIo()) {
14178 struct.io.write(oprot);
14179 }
14180 if (struct.isSetIa()) {
14181 struct.ia.write(oprot);
14182 }
14183 }
14184
14185 @Override
14186 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
14187 TTupleProtocol iprot = (TTupleProtocol) prot;
14188 BitSet incoming = iprot.readBitSet(3);
14189 if (incoming.get(0)) {
14190 {
14191 org.apache.thrift.protocol.TList _list141 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
14192 struct.success = new ArrayList<TResult>(_list141.size);
14193 for (int _i142 = 0; _i142 < _list141.size; ++_i142)
14194 {
14195 TResult _elem143;
14196 _elem143 = new TResult();
14197 _elem143.read(iprot);
14198 struct.success.add(_elem143);
14199 }
14200 }
14201 struct.setSuccessIsSet(true);
14202 }
14203 if (incoming.get(1)) {
14204 struct.io = new TIOError();
14205 struct.io.read(iprot);
14206 struct.setIoIsSet(true);
14207 }
14208 if (incoming.get(2)) {
14209 struct.ia = new TIllegalArgument();
14210 struct.ia.read(iprot);
14211 struct.setIaIsSet(true);
14212 }
14213 }
14214 }
14215
14216 }
14217
14218 public static class closeScanner_args implements org.apache.thrift.TBase<closeScanner_args, closeScanner_args._Fields>, java.io.Serializable, Cloneable {
14219 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_args");
14220
14221 private static final org.apache.thrift.protocol.TField SCANNER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scannerId", org.apache.thrift.protocol.TType.I32, (short)1);
14222
14223 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
14224 static {
14225 schemes.put(StandardScheme.class, new closeScanner_argsStandardSchemeFactory());
14226 schemes.put(TupleScheme.class, new closeScanner_argsTupleSchemeFactory());
14227 }
14228
14229
14230
14231
14232 public int scannerId;
14233
14234
14235 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
14236
14237
14238
14239 SCANNER_ID((short)1, "scannerId");
14240
14241 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14242
14243 static {
14244 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14245 byName.put(field.getFieldName(), field);
14246 }
14247 }
14248
14249
14250
14251
14252 public static _Fields findByThriftId(int fieldId) {
14253 switch(fieldId) {
14254 case 1:
14255 return SCANNER_ID;
14256 default:
14257 return null;
14258 }
14259 }
14260
14261
14262
14263
14264
14265 public static _Fields findByThriftIdOrThrow(int fieldId) {
14266 _Fields fields = findByThriftId(fieldId);
14267 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14268 return fields;
14269 }
14270
14271
14272
14273
14274 public static _Fields findByName(String name) {
14275 return byName.get(name);
14276 }
14277
14278 private final short _thriftId;
14279 private final String _fieldName;
14280
14281 _Fields(short thriftId, String fieldName) {
14282 _thriftId = thriftId;
14283 _fieldName = fieldName;
14284 }
14285
14286 public short getThriftFieldId() {
14287 return _thriftId;
14288 }
14289
14290 public String getFieldName() {
14291 return _fieldName;
14292 }
14293 }
14294
14295
14296 private static final int __SCANNERID_ISSET_ID = 0;
14297 private BitSet __isset_bit_vector = new BitSet(1);
14298 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
14299 static {
14300 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
14301 tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
14302 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
14303 metaDataMap = Collections.unmodifiableMap(tmpMap);
14304 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_args.class, metaDataMap);
14305 }
14306
14307 public closeScanner_args() {
14308 }
14309
14310 public closeScanner_args(
14311 int scannerId)
14312 {
14313 this();
14314 this.scannerId = scannerId;
14315 setScannerIdIsSet(true);
14316 }
14317
14318
14319
14320
14321 public closeScanner_args(closeScanner_args other) {
14322 __isset_bit_vector.clear();
14323 __isset_bit_vector.or(other.__isset_bit_vector);
14324 this.scannerId = other.scannerId;
14325 }
14326
14327 public closeScanner_args deepCopy() {
14328 return new closeScanner_args(this);
14329 }
14330
14331 @Override
14332 public void clear() {
14333 setScannerIdIsSet(false);
14334 this.scannerId = 0;
14335 }
14336
14337
14338
14339
14340 public int getScannerId() {
14341 return this.scannerId;
14342 }
14343
14344
14345
14346
14347 public closeScanner_args setScannerId(int scannerId) {
14348 this.scannerId = scannerId;
14349 setScannerIdIsSet(true);
14350 return this;
14351 }
14352
14353 public void unsetScannerId() {
14354 __isset_bit_vector.clear(__SCANNERID_ISSET_ID);
14355 }
14356
14357
14358 public boolean isSetScannerId() {
14359 return __isset_bit_vector.get(__SCANNERID_ISSET_ID);
14360 }
14361
14362 public void setScannerIdIsSet(boolean value) {
14363 __isset_bit_vector.set(__SCANNERID_ISSET_ID, value);
14364 }
14365
14366 public void setFieldValue(_Fields field, Object value) {
14367 switch (field) {
14368 case SCANNER_ID:
14369 if (value == null) {
14370 unsetScannerId();
14371 } else {
14372 setScannerId((Integer)value);
14373 }
14374 break;
14375
14376 }
14377 }
14378
14379 public Object getFieldValue(_Fields field) {
14380 switch (field) {
14381 case SCANNER_ID:
14382 return Integer.valueOf(getScannerId());
14383
14384 }
14385 throw new IllegalStateException();
14386 }
14387
14388
14389 public boolean isSet(_Fields field) {
14390 if (field == null) {
14391 throw new IllegalArgumentException();
14392 }
14393
14394 switch (field) {
14395 case SCANNER_ID:
14396 return isSetScannerId();
14397 }
14398 throw new IllegalStateException();
14399 }
14400
14401 @Override
14402 public boolean equals(Object that) {
14403 if (that == null)
14404 return false;
14405 if (that instanceof closeScanner_args)
14406 return this.equals((closeScanner_args)that);
14407 return false;
14408 }
14409
14410 public boolean equals(closeScanner_args that) {
14411 if (that == null)
14412 return false;
14413
14414 boolean this_present_scannerId = true;
14415 boolean that_present_scannerId = true;
14416 if (this_present_scannerId || that_present_scannerId) {
14417 if (!(this_present_scannerId && that_present_scannerId))
14418 return false;
14419 if (this.scannerId != that.scannerId)
14420 return false;
14421 }
14422
14423 return true;
14424 }
14425
14426 @Override
14427 public int hashCode() {
14428 HashCodeBuilder builder = new HashCodeBuilder();
14429
14430 boolean present_scannerId = true;
14431 builder.append(present_scannerId);
14432 if (present_scannerId)
14433 builder.append(scannerId);
14434
14435 return builder.toHashCode();
14436 }
14437
14438 public int compareTo(closeScanner_args other) {
14439 if (!getClass().equals(other.getClass())) {
14440 return getClass().getName().compareTo(other.getClass().getName());
14441 }
14442
14443 int lastComparison = 0;
14444 closeScanner_args typedOther = (closeScanner_args)other;
14445
14446 lastComparison = Boolean.valueOf(isSetScannerId()).compareTo(typedOther.isSetScannerId());
14447 if (lastComparison != 0) {
14448 return lastComparison;
14449 }
14450 if (isSetScannerId()) {
14451 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, typedOther.scannerId);
14452 if (lastComparison != 0) {
14453 return lastComparison;
14454 }
14455 }
14456 return 0;
14457 }
14458
14459 public _Fields fieldForId(int fieldId) {
14460 return _Fields.findByThriftId(fieldId);
14461 }
14462
14463 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
14464 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
14465 }
14466
14467 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
14468 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
14469 }
14470
14471 @Override
14472 public String toString() {
14473 StringBuilder sb = new StringBuilder("closeScanner_args(");
14474 boolean first = true;
14475
14476 sb.append("scannerId:");
14477 sb.append(this.scannerId);
14478 first = false;
14479 sb.append(")");
14480 return sb.toString();
14481 }
14482
14483 public void validate() throws org.apache.thrift.TException {
14484
14485
14486 }
14487
14488 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
14489 try {
14490 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
14491 } catch (org.apache.thrift.TException te) {
14492 throw new java.io.IOException(te);
14493 }
14494 }
14495
14496 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
14497 try {
14498 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
14499 } catch (org.apache.thrift.TException te) {
14500 throw new java.io.IOException(te);
14501 }
14502 }
14503
14504 private static class closeScanner_argsStandardSchemeFactory implements SchemeFactory {
14505 public closeScanner_argsStandardScheme getScheme() {
14506 return new closeScanner_argsStandardScheme();
14507 }
14508 }
14509
14510 private static class closeScanner_argsStandardScheme extends StandardScheme<closeScanner_args> {
14511
14512 public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_args struct) throws org.apache.thrift.TException {
14513 org.apache.thrift.protocol.TField schemeField;
14514 iprot.readStructBegin();
14515 while (true)
14516 {
14517 schemeField = iprot.readFieldBegin();
14518 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
14519 break;
14520 }
14521 switch (schemeField.id) {
14522 case 1:
14523 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
14524 struct.scannerId = iprot.readI32();
14525 struct.setScannerIdIsSet(true);
14526 } else {
14527 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14528 }
14529 break;
14530 default:
14531 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14532 }
14533 iprot.readFieldEnd();
14534 }
14535 iprot.readStructEnd();
14536
14537
14538 if (!struct.isSetScannerId()) {
14539 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
14540 }
14541 struct.validate();
14542 }
14543
14544 public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_args struct) throws org.apache.thrift.TException {
14545 struct.validate();
14546
14547 oprot.writeStructBegin(STRUCT_DESC);
14548 oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
14549 oprot.writeI32(struct.scannerId);
14550 oprot.writeFieldEnd();
14551 oprot.writeFieldStop();
14552 oprot.writeStructEnd();
14553 }
14554
14555 }
14556
14557 private static class closeScanner_argsTupleSchemeFactory implements SchemeFactory {
14558 public closeScanner_argsTupleScheme getScheme() {
14559 return new closeScanner_argsTupleScheme();
14560 }
14561 }
14562
14563 private static class closeScanner_argsTupleScheme extends TupleScheme<closeScanner_args> {
14564
14565 @Override
14566 public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
14567 TTupleProtocol oprot = (TTupleProtocol) prot;
14568 oprot.writeI32(struct.scannerId);
14569 }
14570
14571 @Override
14572 public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
14573 TTupleProtocol iprot = (TTupleProtocol) prot;
14574 struct.scannerId = iprot.readI32();
14575 struct.setScannerIdIsSet(true);
14576 }
14577 }
14578
14579 }
14580
14581 public static class closeScanner_result implements org.apache.thrift.TBase<closeScanner_result, closeScanner_result._Fields>, java.io.Serializable, Cloneable {
14582 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_result");
14583
14584 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
14585 private static final org.apache.thrift.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2);
14586
14587 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
14588 static {
14589 schemes.put(StandardScheme.class, new closeScanner_resultStandardSchemeFactory());
14590 schemes.put(TupleScheme.class, new closeScanner_resultTupleSchemeFactory());
14591 }
14592
14593 public TIOError io;
14594
14595
14596
14597 public TIllegalArgument ia;
14598
14599
14600 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
14601 IO((short)1, "io"),
14602
14603
14604
14605 IA((short)2, "ia");
14606
14607 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14608
14609 static {
14610 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14611 byName.put(field.getFieldName(), field);
14612 }
14613 }
14614
14615
14616
14617
14618 public static _Fields findByThriftId(int fieldId) {
14619 switch(fieldId) {
14620 case 1:
14621 return IO;
14622 case 2:
14623 return IA;
14624 default:
14625 return null;
14626 }
14627 }
14628
14629
14630
14631
14632
14633 public static _Fields findByThriftIdOrThrow(int fieldId) {
14634 _Fields fields = findByThriftId(fieldId);
14635 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14636 return fields;
14637 }
14638
14639
14640
14641
14642 public static _Fields findByName(String name) {
14643 return byName.get(name);
14644 }
14645
14646 private final short _thriftId;
14647 private final String _fieldName;
14648
14649 _Fields(short thriftId, String fieldName) {
14650 _thriftId = thriftId;
14651 _fieldName = fieldName;
14652 }
14653
14654 public short getThriftFieldId() {
14655 return _thriftId;
14656 }
14657
14658 public String getFieldName() {
14659 return _fieldName;
14660 }
14661 }
14662
14663
14664 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
14665 static {
14666 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
14667 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
14668 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
14669 tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
14670 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
14671 metaDataMap = Collections.unmodifiableMap(tmpMap);
14672 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_result.class, metaDataMap);
14673 }
14674
14675 public closeScanner_result() {
14676 }
14677
14678 public closeScanner_result(
14679 TIOError io,
14680 TIllegalArgument ia)
14681 {
14682 this();
14683 this.io = io;
14684 this.ia = ia;
14685 }
14686
14687
14688
14689
14690 public closeScanner_result(closeScanner_result other) {
14691 if (other.isSetIo()) {
14692 this.io = new TIOError(other.io);
14693 }
14694 if (other.isSetIa()) {
14695 this.ia = new TIllegalArgument(other.ia);
14696 }
14697 }
14698
14699 public closeScanner_result deepCopy() {
14700 return new closeScanner_result(this);
14701 }
14702
14703 @Override
14704 public void clear() {
14705 this.io = null;
14706 this.ia = null;
14707 }
14708
14709 public TIOError getIo() {
14710 return this.io;
14711 }
14712
14713 public closeScanner_result setIo(TIOError io) {
14714 this.io = io;
14715 return this;
14716 }
14717
14718 public void unsetIo() {
14719 this.io = null;
14720 }
14721
14722
14723 public boolean isSetIo() {
14724 return this.io != null;
14725 }
14726
14727 public void setIoIsSet(boolean value) {
14728 if (!value) {
14729 this.io = null;
14730 }
14731 }
14732
14733
14734
14735
14736 public TIllegalArgument getIa() {
14737 return this.ia;
14738 }
14739
14740
14741
14742
14743 public closeScanner_result setIa(TIllegalArgument ia) {
14744 this.ia = ia;
14745 return this;
14746 }
14747
14748 public void unsetIa() {
14749 this.ia = null;
14750 }
14751
14752
14753 public boolean isSetIa() {
14754 return this.ia != null;
14755 }
14756
14757 public void setIaIsSet(boolean value) {
14758 if (!value) {
14759 this.ia = null;
14760 }
14761 }
14762
14763 public void setFieldValue(_Fields field, Object value) {
14764 switch (field) {
14765 case IO:
14766 if (value == null) {
14767 unsetIo();
14768 } else {
14769 setIo((TIOError)value);
14770 }
14771 break;
14772
14773 case IA:
14774 if (value == null) {
14775 unsetIa();
14776 } else {
14777 setIa((TIllegalArgument)value);
14778 }
14779 break;
14780
14781 }
14782 }
14783
14784 public Object getFieldValue(_Fields field) {
14785 switch (field) {
14786 case IO:
14787 return getIo();
14788
14789 case IA:
14790 return getIa();
14791
14792 }
14793 throw new IllegalStateException();
14794 }
14795
14796
14797 public boolean isSet(_Fields field) {
14798 if (field == null) {
14799 throw new IllegalArgumentException();
14800 }
14801
14802 switch (field) {
14803 case IO:
14804 return isSetIo();
14805 case IA:
14806 return isSetIa();
14807 }
14808 throw new IllegalStateException();
14809 }
14810
14811 @Override
14812 public boolean equals(Object that) {
14813 if (that == null)
14814 return false;
14815 if (that instanceof closeScanner_result)
14816 return this.equals((closeScanner_result)that);
14817 return false;
14818 }
14819
14820 public boolean equals(closeScanner_result that) {
14821 if (that == null)
14822 return false;
14823
14824 boolean this_present_io = true && this.isSetIo();
14825 boolean that_present_io = true && that.isSetIo();
14826 if (this_present_io || that_present_io) {
14827 if (!(this_present_io && that_present_io))
14828 return false;
14829 if (!this.io.equals(that.io))
14830 return false;
14831 }
14832
14833 boolean this_present_ia = true && this.isSetIa();
14834 boolean that_present_ia = true && that.isSetIa();
14835 if (this_present_ia || that_present_ia) {
14836 if (!(this_present_ia && that_present_ia))
14837 return false;
14838 if (!this.ia.equals(that.ia))
14839 return false;
14840 }
14841
14842 return true;
14843 }
14844
14845 @Override
14846 public int hashCode() {
14847 HashCodeBuilder builder = new HashCodeBuilder();
14848
14849 boolean present_io = true && (isSetIo());
14850 builder.append(present_io);
14851 if (present_io)
14852 builder.append(io);
14853
14854 boolean present_ia = true && (isSetIa());
14855 builder.append(present_ia);
14856 if (present_ia)
14857 builder.append(ia);
14858
14859 return builder.toHashCode();
14860 }
14861
14862 public int compareTo(closeScanner_result other) {
14863 if (!getClass().equals(other.getClass())) {
14864 return getClass().getName().compareTo(other.getClass().getName());
14865 }
14866
14867 int lastComparison = 0;
14868 closeScanner_result typedOther = (closeScanner_result)other;
14869
14870 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
14871 if (lastComparison != 0) {
14872 return lastComparison;
14873 }
14874 if (isSetIo()) {
14875 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
14876 if (lastComparison != 0) {
14877 return lastComparison;
14878 }
14879 }
14880 lastComparison = Boolean.valueOf(isSetIa()).compareTo(typedOther.isSetIa());
14881 if (lastComparison != 0) {
14882 return lastComparison;
14883 }
14884 if (isSetIa()) {
14885 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia);
14886 if (lastComparison != 0) {
14887 return lastComparison;
14888 }
14889 }
14890 return 0;
14891 }
14892
14893 public _Fields fieldForId(int fieldId) {
14894 return _Fields.findByThriftId(fieldId);
14895 }
14896
14897 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
14898 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
14899 }
14900
14901 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
14902 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
14903 }
14904
14905 @Override
14906 public String toString() {
14907 StringBuilder sb = new StringBuilder("closeScanner_result(");
14908 boolean first = true;
14909
14910 sb.append("io:");
14911 if (this.io == null) {
14912 sb.append("null");
14913 } else {
14914 sb.append(this.io);
14915 }
14916 first = false;
14917 if (!first) sb.append(", ");
14918 sb.append("ia:");
14919 if (this.ia == null) {
14920 sb.append("null");
14921 } else {
14922 sb.append(this.ia);
14923 }
14924 first = false;
14925 sb.append(")");
14926 return sb.toString();
14927 }
14928
14929 public void validate() throws org.apache.thrift.TException {
14930
14931 }
14932
14933 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
14934 try {
14935 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
14936 } catch (org.apache.thrift.TException te) {
14937 throw new java.io.IOException(te);
14938 }
14939 }
14940
14941 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
14942 try {
14943 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
14944 } catch (org.apache.thrift.TException te) {
14945 throw new java.io.IOException(te);
14946 }
14947 }
14948
14949 private static class closeScanner_resultStandardSchemeFactory implements SchemeFactory {
14950 public closeScanner_resultStandardScheme getScheme() {
14951 return new closeScanner_resultStandardScheme();
14952 }
14953 }
14954
14955 private static class closeScanner_resultStandardScheme extends StandardScheme<closeScanner_result> {
14956
14957 public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_result struct) throws org.apache.thrift.TException {
14958 org.apache.thrift.protocol.TField schemeField;
14959 iprot.readStructBegin();
14960 while (true)
14961 {
14962 schemeField = iprot.readFieldBegin();
14963 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
14964 break;
14965 }
14966 switch (schemeField.id) {
14967 case 1:
14968 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14969 struct.io = new TIOError();
14970 struct.io.read(iprot);
14971 struct.setIoIsSet(true);
14972 } else {
14973 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14974 }
14975 break;
14976 case 2:
14977 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14978 struct.ia = new TIllegalArgument();
14979 struct.ia.read(iprot);
14980 struct.setIaIsSet(true);
14981 } else {
14982 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14983 }
14984 break;
14985 default:
14986 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14987 }
14988 iprot.readFieldEnd();
14989 }
14990 iprot.readStructEnd();
14991
14992
14993 struct.validate();
14994 }
14995
14996 public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_result struct) throws org.apache.thrift.TException {
14997 struct.validate();
14998
14999 oprot.writeStructBegin(STRUCT_DESC);
15000 if (struct.io != null) {
15001 oprot.writeFieldBegin(IO_FIELD_DESC);
15002 struct.io.write(oprot);
15003 oprot.writeFieldEnd();
15004 }
15005 if (struct.ia != null) {
15006 oprot.writeFieldBegin(IA_FIELD_DESC);
15007 struct.ia.write(oprot);
15008 oprot.writeFieldEnd();
15009 }
15010 oprot.writeFieldStop();
15011 oprot.writeStructEnd();
15012 }
15013
15014 }
15015
15016 private static class closeScanner_resultTupleSchemeFactory implements SchemeFactory {
15017 public closeScanner_resultTupleScheme getScheme() {
15018 return new closeScanner_resultTupleScheme();
15019 }
15020 }
15021
15022 private static class closeScanner_resultTupleScheme extends TupleScheme<closeScanner_result> {
15023
15024 @Override
15025 public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
15026 TTupleProtocol oprot = (TTupleProtocol) prot;
15027 BitSet optionals = new BitSet();
15028 if (struct.isSetIo()) {
15029 optionals.set(0);
15030 }
15031 if (struct.isSetIa()) {
15032 optionals.set(1);
15033 }
15034 oprot.writeBitSet(optionals, 2);
15035 if (struct.isSetIo()) {
15036 struct.io.write(oprot);
15037 }
15038 if (struct.isSetIa()) {
15039 struct.ia.write(oprot);
15040 }
15041 }
15042
15043 @Override
15044 public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
15045 TTupleProtocol iprot = (TTupleProtocol) prot;
15046 BitSet incoming = iprot.readBitSet(2);
15047 if (incoming.get(0)) {
15048 struct.io = new TIOError();
15049 struct.io.read(iprot);
15050 struct.setIoIsSet(true);
15051 }
15052 if (incoming.get(1)) {
15053 struct.ia = new TIllegalArgument();
15054 struct.ia.read(iprot);
15055 struct.setIaIsSet(true);
15056 }
15057 }
15058 }
15059
15060 }
15061
15062 public static class mutateRow_args implements org.apache.thrift.TBase<mutateRow_args, mutateRow_args._Fields>, java.io.Serializable, Cloneable {
15063 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRow_args");
15064
15065 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
15066 private static final org.apache.thrift.protocol.TField ROW_MUTATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("rowMutations", org.apache.thrift.protocol.TType.STRUCT, (short)2);
15067
15068 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
15069 static {
15070 schemes.put(StandardScheme.class, new mutateRow_argsStandardSchemeFactory());
15071 schemes.put(TupleScheme.class, new mutateRow_argsTupleSchemeFactory());
15072 }
15073
15074
15075
15076
15077 public ByteBuffer table;
15078
15079
15080
15081 public TRowMutations rowMutations;
15082
15083
15084 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
15085
15086
15087
15088 TABLE((short)1, "table"),
15089
15090
15091
15092 ROW_MUTATIONS((short)2, "rowMutations");
15093
15094 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15095
15096 static {
15097 for (_Fields field : EnumSet.allOf(_Fields.class)) {
15098 byName.put(field.getFieldName(), field);
15099 }
15100 }
15101
15102
15103
15104
15105 public static _Fields findByThriftId(int fieldId) {
15106 switch(fieldId) {
15107 case 1:
15108 return TABLE;
15109 case 2:
15110 return ROW_MUTATIONS;
15111 default:
15112 return null;
15113 }
15114 }
15115
15116
15117
15118
15119
15120 public static _Fields findByThriftIdOrThrow(int fieldId) {
15121 _Fields fields = findByThriftId(fieldId);
15122 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15123 return fields;
15124 }
15125
15126
15127
15128
15129 public static _Fields findByName(String name) {
15130 return byName.get(name);
15131 }
15132
15133 private final short _thriftId;
15134 private final String _fieldName;
15135
15136 _Fields(short thriftId, String fieldName) {
15137 _thriftId = thriftId;
15138 _fieldName = fieldName;
15139 }
15140
15141 public short getThriftFieldId() {
15142 return _thriftId;
15143 }
15144
15145 public String getFieldName() {
15146 return _fieldName;
15147 }
15148 }
15149
15150
15151 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
15152 static {
15153 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
15154 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
15155 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
15156 tmpMap.put(_Fields.ROW_MUTATIONS, new org.apache.thrift.meta_data.FieldMetaData("rowMutations", org.apache.thrift.TFieldRequirementType.REQUIRED,
15157 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowMutations.class)));
15158 metaDataMap = Collections.unmodifiableMap(tmpMap);
15159 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
15160 }
15161
15162 public mutateRow_args() {
15163 }
15164
15165 public mutateRow_args(
15166 ByteBuffer table,
15167 TRowMutations rowMutations)
15168 {
15169 this();
15170 this.table = table;
15171 this.rowMutations = rowMutations;
15172 }
15173
15174
15175
15176
15177 public mutateRow_args(mutateRow_args other) {
15178 if (other.isSetTable()) {
15179 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
15180 ;
15181 }
15182 if (other.isSetRowMutations()) {
15183 this.rowMutations = new TRowMutations(other.rowMutations);
15184 }
15185 }
15186
15187 public mutateRow_args deepCopy() {
15188 return new mutateRow_args(this);
15189 }
15190
15191 @Override
15192 public void clear() {
15193 this.table = null;
15194 this.rowMutations = null;
15195 }
15196
15197
15198
15199
15200 public byte[] getTable() {
15201 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
15202 return table == null ? null : table.array();
15203 }
15204
15205 public ByteBuffer bufferForTable() {
15206 return table;
15207 }
15208
15209
15210
15211
15212 public mutateRow_args setTable(byte[] table) {
15213 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
15214 return this;
15215 }
15216
15217 public mutateRow_args setTable(ByteBuffer table) {
15218 this.table = table;
15219 return this;
15220 }
15221
15222 public void unsetTable() {
15223 this.table = null;
15224 }
15225
15226
15227 public boolean isSetTable() {
15228 return this.table != null;
15229 }
15230
15231 public void setTableIsSet(boolean value) {
15232 if (!value) {
15233 this.table = null;
15234 }
15235 }
15236
15237
15238
15239
15240 public TRowMutations getRowMutations() {
15241 return this.rowMutations;
15242 }
15243
15244
15245
15246
15247 public mutateRow_args setRowMutations(TRowMutations rowMutations) {
15248 this.rowMutations = rowMutations;
15249 return this;
15250 }
15251
15252 public void unsetRowMutations() {
15253 this.rowMutations = null;
15254 }
15255
15256
15257 public boolean isSetRowMutations() {
15258 return this.rowMutations != null;
15259 }
15260
15261 public void setRowMutationsIsSet(boolean value) {
15262 if (!value) {
15263 this.rowMutations = null;
15264 }
15265 }
15266
15267 public void setFieldValue(_Fields field, Object value) {
15268 switch (field) {
15269 case TABLE:
15270 if (value == null) {
15271 unsetTable();
15272 } else {
15273 setTable((ByteBuffer)value);
15274 }
15275 break;
15276
15277 case ROW_MUTATIONS:
15278 if (value == null) {
15279 unsetRowMutations();
15280 } else {
15281 setRowMutations((TRowMutations)value);
15282 }
15283 break;
15284
15285 }
15286 }
15287
15288 public Object getFieldValue(_Fields field) {
15289 switch (field) {
15290 case TABLE:
15291 return getTable();
15292
15293 case ROW_MUTATIONS:
15294 return getRowMutations();
15295
15296 }
15297 throw new IllegalStateException();
15298 }
15299
15300
15301 public boolean isSet(_Fields field) {
15302 if (field == null) {
15303 throw new IllegalArgumentException();
15304 }
15305
15306 switch (field) {
15307 case TABLE:
15308 return isSetTable();
15309 case ROW_MUTATIONS:
15310 return isSetRowMutations();
15311 }
15312 throw new IllegalStateException();
15313 }
15314
15315 @Override
15316 public boolean equals(Object that) {
15317 if (that == null)
15318 return false;
15319 if (that instanceof mutateRow_args)
15320 return this.equals((mutateRow_args)that);
15321 return false;
15322 }
15323
15324 public boolean equals(mutateRow_args that) {
15325 if (that == null)
15326 return false;
15327
15328 boolean this_present_table = true && this.isSetTable();
15329 boolean that_present_table = true && that.isSetTable();
15330 if (this_present_table || that_present_table) {
15331 if (!(this_present_table && that_present_table))
15332 return false;
15333 if (!this.table.equals(that.table))
15334 return false;
15335 }
15336
15337 boolean this_present_rowMutations = true && this.isSetRowMutations();
15338 boolean that_present_rowMutations = true && that.isSetRowMutations();
15339 if (this_present_rowMutations || that_present_rowMutations) {
15340 if (!(this_present_rowMutations && that_present_rowMutations))
15341 return false;
15342 if (!this.rowMutations.equals(that.rowMutations))
15343 return false;
15344 }
15345
15346 return true;
15347 }
15348
15349 @Override
15350 public int hashCode() {
15351 HashCodeBuilder builder = new HashCodeBuilder();
15352
15353 boolean present_table = true && (isSetTable());
15354 builder.append(present_table);
15355 if (present_table)
15356 builder.append(table);
15357
15358 boolean present_rowMutations = true && (isSetRowMutations());
15359 builder.append(present_rowMutations);
15360 if (present_rowMutations)
15361 builder.append(rowMutations);
15362
15363 return builder.toHashCode();
15364 }
15365
15366 public int compareTo(mutateRow_args other) {
15367 if (!getClass().equals(other.getClass())) {
15368 return getClass().getName().compareTo(other.getClass().getName());
15369 }
15370
15371 int lastComparison = 0;
15372 mutateRow_args typedOther = (mutateRow_args)other;
15373
15374 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
15375 if (lastComparison != 0) {
15376 return lastComparison;
15377 }
15378 if (isSetTable()) {
15379 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
15380 if (lastComparison != 0) {
15381 return lastComparison;
15382 }
15383 }
15384 lastComparison = Boolean.valueOf(isSetRowMutations()).compareTo(typedOther.isSetRowMutations());
15385 if (lastComparison != 0) {
15386 return lastComparison;
15387 }
15388 if (isSetRowMutations()) {
15389 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rowMutations, typedOther.rowMutations);
15390 if (lastComparison != 0) {
15391 return lastComparison;
15392 }
15393 }
15394 return 0;
15395 }
15396
15397 public _Fields fieldForId(int fieldId) {
15398 return _Fields.findByThriftId(fieldId);
15399 }
15400
15401 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
15402 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
15403 }
15404
15405 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
15406 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
15407 }
15408
15409 @Override
15410 public String toString() {
15411 StringBuilder sb = new StringBuilder("mutateRow_args(");
15412 boolean first = true;
15413
15414 sb.append("table:");
15415 if (this.table == null) {
15416 sb.append("null");
15417 } else {
15418 org.apache.thrift.TBaseHelper.toString(this.table, sb);
15419 }
15420 first = false;
15421 if (!first) sb.append(", ");
15422 sb.append("rowMutations:");
15423 if (this.rowMutations == null) {
15424 sb.append("null");
15425 } else {
15426 sb.append(this.rowMutations);
15427 }
15428 first = false;
15429 sb.append(")");
15430 return sb.toString();
15431 }
15432
15433 public void validate() throws org.apache.thrift.TException {
15434
15435 if (table == null) {
15436 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
15437 }
15438 if (rowMutations == null) {
15439 throw new org.apache.thrift.protocol.TProtocolException("Required field 'rowMutations' was not present! Struct: " + toString());
15440 }
15441 }
15442
15443 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
15444 try {
15445 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
15446 } catch (org.apache.thrift.TException te) {
15447 throw new java.io.IOException(te);
15448 }
15449 }
15450
15451 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
15452 try {
15453 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
15454 } catch (org.apache.thrift.TException te) {
15455 throw new java.io.IOException(te);
15456 }
15457 }
15458
15459 private static class mutateRow_argsStandardSchemeFactory implements SchemeFactory {
15460 public mutateRow_argsStandardScheme getScheme() {
15461 return new mutateRow_argsStandardScheme();
15462 }
15463 }
15464
15465 private static class mutateRow_argsStandardScheme extends StandardScheme<mutateRow_args> {
15466
15467 public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_args struct) throws org.apache.thrift.TException {
15468 org.apache.thrift.protocol.TField schemeField;
15469 iprot.readStructBegin();
15470 while (true)
15471 {
15472 schemeField = iprot.readFieldBegin();
15473 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
15474 break;
15475 }
15476 switch (schemeField.id) {
15477 case 1:
15478 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
15479 struct.table = iprot.readBinary();
15480 struct.setTableIsSet(true);
15481 } else {
15482 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15483 }
15484 break;
15485 case 2:
15486 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
15487 struct.rowMutations = new TRowMutations();
15488 struct.rowMutations.read(iprot);
15489 struct.setRowMutationsIsSet(true);
15490 } else {
15491 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15492 }
15493 break;
15494 default:
15495 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15496 }
15497 iprot.readFieldEnd();
15498 }
15499 iprot.readStructEnd();
15500
15501
15502 struct.validate();
15503 }
15504
15505 public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_args struct) throws org.apache.thrift.TException {
15506 struct.validate();
15507
15508 oprot.writeStructBegin(STRUCT_DESC);
15509 if (struct.table != null) {
15510 oprot.writeFieldBegin(TABLE_FIELD_DESC);
15511 oprot.writeBinary(struct.table);
15512 oprot.writeFieldEnd();
15513 }
15514 if (struct.rowMutations != null) {
15515 oprot.writeFieldBegin(ROW_MUTATIONS_FIELD_DESC);
15516 struct.rowMutations.write(oprot);
15517 oprot.writeFieldEnd();
15518 }
15519 oprot.writeFieldStop();
15520 oprot.writeStructEnd();
15521 }
15522
15523 }
15524
15525 private static class mutateRow_argsTupleSchemeFactory implements SchemeFactory {
15526 public mutateRow_argsTupleScheme getScheme() {
15527 return new mutateRow_argsTupleScheme();
15528 }
15529 }
15530
15531 private static class mutateRow_argsTupleScheme extends TupleScheme<mutateRow_args> {
15532
15533 @Override
15534 public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
15535 TTupleProtocol oprot = (TTupleProtocol) prot;
15536 oprot.writeBinary(struct.table);
15537 struct.rowMutations.write(oprot);
15538 }
15539
15540 @Override
15541 public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
15542 TTupleProtocol iprot = (TTupleProtocol) prot;
15543 struct.table = iprot.readBinary();
15544 struct.setTableIsSet(true);
15545 struct.rowMutations = new TRowMutations();
15546 struct.rowMutations.read(iprot);
15547 struct.setRowMutationsIsSet(true);
15548 }
15549 }
15550
15551 }
15552
15553 public static class mutateRow_result implements org.apache.thrift.TBase<mutateRow_result, mutateRow_result._Fields>, java.io.Serializable, Cloneable {
15554 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRow_result");
15555
15556 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
15557
15558 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
15559 static {
15560 schemes.put(StandardScheme.class, new mutateRow_resultStandardSchemeFactory());
15561 schemes.put(TupleScheme.class, new mutateRow_resultTupleSchemeFactory());
15562 }
15563
15564 public TIOError io;
15565
15566
15567 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
15568 IO((short)1, "io");
15569
15570 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15571
15572 static {
15573 for (_Fields field : EnumSet.allOf(_Fields.class)) {
15574 byName.put(field.getFieldName(), field);
15575 }
15576 }
15577
15578
15579
15580
15581 public static _Fields findByThriftId(int fieldId) {
15582 switch(fieldId) {
15583 case 1:
15584 return IO;
15585 default:
15586 return null;
15587 }
15588 }
15589
15590
15591
15592
15593
15594 public static _Fields findByThriftIdOrThrow(int fieldId) {
15595 _Fields fields = findByThriftId(fieldId);
15596 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15597 return fields;
15598 }
15599
15600
15601
15602
15603 public static _Fields findByName(String name) {
15604 return byName.get(name);
15605 }
15606
15607 private final short _thriftId;
15608 private final String _fieldName;
15609
15610 _Fields(short thriftId, String fieldName) {
15611 _thriftId = thriftId;
15612 _fieldName = fieldName;
15613 }
15614
15615 public short getThriftFieldId() {
15616 return _thriftId;
15617 }
15618
15619 public String getFieldName() {
15620 return _fieldName;
15621 }
15622 }
15623
15624
15625 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
15626 static {
15627 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
15628 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
15629 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
15630 metaDataMap = Collections.unmodifiableMap(tmpMap);
15631 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap);
15632 }
15633
15634 public mutateRow_result() {
15635 }
15636
15637 public mutateRow_result(
15638 TIOError io)
15639 {
15640 this();
15641 this.io = io;
15642 }
15643
15644
15645
15646
15647 public mutateRow_result(mutateRow_result other) {
15648 if (other.isSetIo()) {
15649 this.io = new TIOError(other.io);
15650 }
15651 }
15652
15653 public mutateRow_result deepCopy() {
15654 return new mutateRow_result(this);
15655 }
15656
15657 @Override
15658 public void clear() {
15659 this.io = null;
15660 }
15661
15662 public TIOError getIo() {
15663 return this.io;
15664 }
15665
15666 public mutateRow_result setIo(TIOError io) {
15667 this.io = io;
15668 return this;
15669 }
15670
15671 public void unsetIo() {
15672 this.io = null;
15673 }
15674
15675
15676 public boolean isSetIo() {
15677 return this.io != null;
15678 }
15679
15680 public void setIoIsSet(boolean value) {
15681 if (!value) {
15682 this.io = null;
15683 }
15684 }
15685
15686 public void setFieldValue(_Fields field, Object value) {
15687 switch (field) {
15688 case IO:
15689 if (value == null) {
15690 unsetIo();
15691 } else {
15692 setIo((TIOError)value);
15693 }
15694 break;
15695
15696 }
15697 }
15698
15699 public Object getFieldValue(_Fields field) {
15700 switch (field) {
15701 case IO:
15702 return getIo();
15703
15704 }
15705 throw new IllegalStateException();
15706 }
15707
15708
15709 public boolean isSet(_Fields field) {
15710 if (field == null) {
15711 throw new IllegalArgumentException();
15712 }
15713
15714 switch (field) {
15715 case IO:
15716 return isSetIo();
15717 }
15718 throw new IllegalStateException();
15719 }
15720
15721 @Override
15722 public boolean equals(Object that) {
15723 if (that == null)
15724 return false;
15725 if (that instanceof mutateRow_result)
15726 return this.equals((mutateRow_result)that);
15727 return false;
15728 }
15729
15730 public boolean equals(mutateRow_result that) {
15731 if (that == null)
15732 return false;
15733
15734 boolean this_present_io = true && this.isSetIo();
15735 boolean that_present_io = true && that.isSetIo();
15736 if (this_present_io || that_present_io) {
15737 if (!(this_present_io && that_present_io))
15738 return false;
15739 if (!this.io.equals(that.io))
15740 return false;
15741 }
15742
15743 return true;
15744 }
15745
15746 @Override
15747 public int hashCode() {
15748 HashCodeBuilder builder = new HashCodeBuilder();
15749
15750 boolean present_io = true && (isSetIo());
15751 builder.append(present_io);
15752 if (present_io)
15753 builder.append(io);
15754
15755 return builder.toHashCode();
15756 }
15757
15758 public int compareTo(mutateRow_result other) {
15759 if (!getClass().equals(other.getClass())) {
15760 return getClass().getName().compareTo(other.getClass().getName());
15761 }
15762
15763 int lastComparison = 0;
15764 mutateRow_result typedOther = (mutateRow_result)other;
15765
15766 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
15767 if (lastComparison != 0) {
15768 return lastComparison;
15769 }
15770 if (isSetIo()) {
15771 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
15772 if (lastComparison != 0) {
15773 return lastComparison;
15774 }
15775 }
15776 return 0;
15777 }
15778
15779 public _Fields fieldForId(int fieldId) {
15780 return _Fields.findByThriftId(fieldId);
15781 }
15782
15783 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
15784 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
15785 }
15786
15787 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
15788 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
15789 }
15790
15791 @Override
15792 public String toString() {
15793 StringBuilder sb = new StringBuilder("mutateRow_result(");
15794 boolean first = true;
15795
15796 sb.append("io:");
15797 if (this.io == null) {
15798 sb.append("null");
15799 } else {
15800 sb.append(this.io);
15801 }
15802 first = false;
15803 sb.append(")");
15804 return sb.toString();
15805 }
15806
15807 public void validate() throws org.apache.thrift.TException {
15808
15809 }
15810
15811 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
15812 try {
15813 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
15814 } catch (org.apache.thrift.TException te) {
15815 throw new java.io.IOException(te);
15816 }
15817 }
15818
15819 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
15820 try {
15821 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
15822 } catch (org.apache.thrift.TException te) {
15823 throw new java.io.IOException(te);
15824 }
15825 }
15826
15827 private static class mutateRow_resultStandardSchemeFactory implements SchemeFactory {
15828 public mutateRow_resultStandardScheme getScheme() {
15829 return new mutateRow_resultStandardScheme();
15830 }
15831 }
15832
15833 private static class mutateRow_resultStandardScheme extends StandardScheme<mutateRow_result> {
15834
15835 public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_result struct) throws org.apache.thrift.TException {
15836 org.apache.thrift.protocol.TField schemeField;
15837 iprot.readStructBegin();
15838 while (true)
15839 {
15840 schemeField = iprot.readFieldBegin();
15841 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
15842 break;
15843 }
15844 switch (schemeField.id) {
15845 case 1:
15846 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
15847 struct.io = new TIOError();
15848 struct.io.read(iprot);
15849 struct.setIoIsSet(true);
15850 } else {
15851 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15852 }
15853 break;
15854 default:
15855 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15856 }
15857 iprot.readFieldEnd();
15858 }
15859 iprot.readStructEnd();
15860
15861
15862 struct.validate();
15863 }
15864
15865 public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_result struct) throws org.apache.thrift.TException {
15866 struct.validate();
15867
15868 oprot.writeStructBegin(STRUCT_DESC);
15869 if (struct.io != null) {
15870 oprot.writeFieldBegin(IO_FIELD_DESC);
15871 struct.io.write(oprot);
15872 oprot.writeFieldEnd();
15873 }
15874 oprot.writeFieldStop();
15875 oprot.writeStructEnd();
15876 }
15877
15878 }
15879
15880 private static class mutateRow_resultTupleSchemeFactory implements SchemeFactory {
15881 public mutateRow_resultTupleScheme getScheme() {
15882 return new mutateRow_resultTupleScheme();
15883 }
15884 }
15885
15886 private static class mutateRow_resultTupleScheme extends TupleScheme<mutateRow_result> {
15887
15888 @Override
15889 public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
15890 TTupleProtocol oprot = (TTupleProtocol) prot;
15891 BitSet optionals = new BitSet();
15892 if (struct.isSetIo()) {
15893 optionals.set(0);
15894 }
15895 oprot.writeBitSet(optionals, 1);
15896 if (struct.isSetIo()) {
15897 struct.io.write(oprot);
15898 }
15899 }
15900
15901 @Override
15902 public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
15903 TTupleProtocol iprot = (TTupleProtocol) prot;
15904 BitSet incoming = iprot.readBitSet(1);
15905 if (incoming.get(0)) {
15906 struct.io = new TIOError();
15907 struct.io.read(iprot);
15908 struct.setIoIsSet(true);
15909 }
15910 }
15911 }
15912
15913 }
15914
15915 public static class getScannerResults_args implements org.apache.thrift.TBase<getScannerResults_args, getScannerResults_args._Fields>, java.io.Serializable, Cloneable {
15916 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerResults_args");
15917
15918 private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
15919 private static final org.apache.thrift.protocol.TField SCAN_FIELD_DESC = new org.apache.thrift.protocol.TField("scan", org.apache.thrift.protocol.TType.STRUCT, (short)2);
15920 private static final org.apache.thrift.protocol.TField NUM_ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("numRows", org.apache.thrift.protocol.TType.I32, (short)3);
15921
15922 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
15923 static {
15924 schemes.put(StandardScheme.class, new getScannerResults_argsStandardSchemeFactory());
15925 schemes.put(TupleScheme.class, new getScannerResults_argsTupleSchemeFactory());
15926 }
15927
15928
15929
15930
15931 public ByteBuffer table;
15932
15933
15934
15935 public TScan scan;
15936
15937
15938
15939 public int numRows;
15940
15941
15942 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
15943
15944
15945
15946 TABLE((short)1, "table"),
15947
15948
15949
15950 SCAN((short)2, "scan"),
15951
15952
15953
15954 NUM_ROWS((short)3, "numRows");
15955
15956 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15957
15958 static {
15959 for (_Fields field : EnumSet.allOf(_Fields.class)) {
15960 byName.put(field.getFieldName(), field);
15961 }
15962 }
15963
15964
15965
15966
15967 public static _Fields findByThriftId(int fieldId) {
15968 switch(fieldId) {
15969 case 1:
15970 return TABLE;
15971 case 2:
15972 return SCAN;
15973 case 3:
15974 return NUM_ROWS;
15975 default:
15976 return null;
15977 }
15978 }
15979
15980
15981
15982
15983
15984 public static _Fields findByThriftIdOrThrow(int fieldId) {
15985 _Fields fields = findByThriftId(fieldId);
15986 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15987 return fields;
15988 }
15989
15990
15991
15992
15993 public static _Fields findByName(String name) {
15994 return byName.get(name);
15995 }
15996
15997 private final short _thriftId;
15998 private final String _fieldName;
15999
16000 _Fields(short thriftId, String fieldName) {
16001 _thriftId = thriftId;
16002 _fieldName = fieldName;
16003 }
16004
16005 public short getThriftFieldId() {
16006 return _thriftId;
16007 }
16008
16009 public String getFieldName() {
16010 return _fieldName;
16011 }
16012 }
16013
16014
16015 private static final int __NUMROWS_ISSET_ID = 0;
16016 private BitSet __isset_bit_vector = new BitSet(1);
16017 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
16018 static {
16019 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
16020 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
16021 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
16022 tmpMap.put(_Fields.SCAN, new org.apache.thrift.meta_data.FieldMetaData("scan", org.apache.thrift.TFieldRequirementType.REQUIRED,
16023 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TScan.class)));
16024 tmpMap.put(_Fields.NUM_ROWS, new org.apache.thrift.meta_data.FieldMetaData("numRows", org.apache.thrift.TFieldRequirementType.DEFAULT,
16025 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
16026 metaDataMap = Collections.unmodifiableMap(tmpMap);
16027 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerResults_args.class, metaDataMap);
16028 }
16029
16030 public getScannerResults_args() {
16031 this.numRows = 1;
16032
16033 }
16034
16035 public getScannerResults_args(
16036 ByteBuffer table,
16037 TScan scan,
16038 int numRows)
16039 {
16040 this();
16041 this.table = table;
16042 this.scan = scan;
16043 this.numRows = numRows;
16044 setNumRowsIsSet(true);
16045 }
16046
16047
16048
16049
16050 public getScannerResults_args(getScannerResults_args other) {
16051 __isset_bit_vector.clear();
16052 __isset_bit_vector.or(other.__isset_bit_vector);
16053 if (other.isSetTable()) {
16054 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
16055 ;
16056 }
16057 if (other.isSetScan()) {
16058 this.scan = new TScan(other.scan);
16059 }
16060 this.numRows = other.numRows;
16061 }
16062
16063 public getScannerResults_args deepCopy() {
16064 return new getScannerResults_args(this);
16065 }
16066
16067 @Override
16068 public void clear() {
16069 this.table = null;
16070 this.scan = null;
16071 this.numRows = 1;
16072
16073 }
16074
16075
16076
16077
16078 public byte[] getTable() {
16079 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
16080 return table == null ? null : table.array();
16081 }
16082
16083 public ByteBuffer bufferForTable() {
16084 return table;
16085 }
16086
16087
16088
16089
16090 public getScannerResults_args setTable(byte[] table) {
16091 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
16092 return this;
16093 }
16094
16095 public getScannerResults_args setTable(ByteBuffer table) {
16096 this.table = table;
16097 return this;
16098 }
16099
16100 public void unsetTable() {
16101 this.table = null;
16102 }
16103
16104
16105 public boolean isSetTable() {
16106 return this.table != null;
16107 }
16108
16109 public void setTableIsSet(boolean value) {
16110 if (!value) {
16111 this.table = null;
16112 }
16113 }
16114
16115
16116
16117
16118 public TScan getScan() {
16119 return this.scan;
16120 }
16121
16122
16123
16124
16125 public getScannerResults_args setScan(TScan scan) {
16126 this.scan = scan;
16127 return this;
16128 }
16129
16130 public void unsetScan() {
16131 this.scan = null;
16132 }
16133
16134
16135 public boolean isSetScan() {
16136 return this.scan != null;
16137 }
16138
16139 public void setScanIsSet(boolean value) {
16140 if (!value) {
16141 this.scan = null;
16142 }
16143 }
16144
16145
16146
16147
16148 public int getNumRows() {
16149 return this.numRows;
16150 }
16151
16152
16153
16154
16155 public getScannerResults_args setNumRows(int numRows) {
16156 this.numRows = numRows;
16157 setNumRowsIsSet(true);
16158 return this;
16159 }
16160
16161 public void unsetNumRows() {
16162 __isset_bit_vector.clear(__NUMROWS_ISSET_ID);
16163 }
16164
16165
16166 public boolean isSetNumRows() {
16167 return __isset_bit_vector.get(__NUMROWS_ISSET_ID);
16168 }
16169
16170 public void setNumRowsIsSet(boolean value) {
16171 __isset_bit_vector.set(__NUMROWS_ISSET_ID, value);
16172 }
16173
16174 public void setFieldValue(_Fields field, Object value) {
16175 switch (field) {
16176 case TABLE:
16177 if (value == null) {
16178 unsetTable();
16179 } else {
16180 setTable((ByteBuffer)value);
16181 }
16182 break;
16183
16184 case SCAN:
16185 if (value == null) {
16186 unsetScan();
16187 } else {
16188 setScan((TScan)value);
16189 }
16190 break;
16191
16192 case NUM_ROWS:
16193 if (value == null) {
16194 unsetNumRows();
16195 } else {
16196 setNumRows((Integer)value);
16197 }
16198 break;
16199
16200 }
16201 }
16202
16203 public Object getFieldValue(_Fields field) {
16204 switch (field) {
16205 case TABLE:
16206 return getTable();
16207
16208 case SCAN:
16209 return getScan();
16210
16211 case NUM_ROWS:
16212 return Integer.valueOf(getNumRows());
16213
16214 }
16215 throw new IllegalStateException();
16216 }
16217
16218
16219 public boolean isSet(_Fields field) {
16220 if (field == null) {
16221 throw new IllegalArgumentException();
16222 }
16223
16224 switch (field) {
16225 case TABLE:
16226 return isSetTable();
16227 case SCAN:
16228 return isSetScan();
16229 case NUM_ROWS:
16230 return isSetNumRows();
16231 }
16232 throw new IllegalStateException();
16233 }
16234
16235 @Override
16236 public boolean equals(Object that) {
16237 if (that == null)
16238 return false;
16239 if (that instanceof getScannerResults_args)
16240 return this.equals((getScannerResults_args)that);
16241 return false;
16242 }
16243
16244 public boolean equals(getScannerResults_args that) {
16245 if (that == null)
16246 return false;
16247
16248 boolean this_present_table = true && this.isSetTable();
16249 boolean that_present_table = true && that.isSetTable();
16250 if (this_present_table || that_present_table) {
16251 if (!(this_present_table && that_present_table))
16252 return false;
16253 if (!this.table.equals(that.table))
16254 return false;
16255 }
16256
16257 boolean this_present_scan = true && this.isSetScan();
16258 boolean that_present_scan = true && that.isSetScan();
16259 if (this_present_scan || that_present_scan) {
16260 if (!(this_present_scan && that_present_scan))
16261 return false;
16262 if (!this.scan.equals(that.scan))
16263 return false;
16264 }
16265
16266 boolean this_present_numRows = true;
16267 boolean that_present_numRows = true;
16268 if (this_present_numRows || that_present_numRows) {
16269 if (!(this_present_numRows && that_present_numRows))
16270 return false;
16271 if (this.numRows != that.numRows)
16272 return false;
16273 }
16274
16275 return true;
16276 }
16277
16278 @Override
16279 public int hashCode() {
16280 HashCodeBuilder builder = new HashCodeBuilder();
16281
16282 boolean present_table = true && (isSetTable());
16283 builder.append(present_table);
16284 if (present_table)
16285 builder.append(table);
16286
16287 boolean present_scan = true && (isSetScan());
16288 builder.append(present_scan);
16289 if (present_scan)
16290 builder.append(scan);
16291
16292 boolean present_numRows = true;
16293 builder.append(present_numRows);
16294 if (present_numRows)
16295 builder.append(numRows);
16296
16297 return builder.toHashCode();
16298 }
16299
16300 public int compareTo(getScannerResults_args other) {
16301 if (!getClass().equals(other.getClass())) {
16302 return getClass().getName().compareTo(other.getClass().getName());
16303 }
16304
16305 int lastComparison = 0;
16306 getScannerResults_args typedOther = (getScannerResults_args)other;
16307
16308 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
16309 if (lastComparison != 0) {
16310 return lastComparison;
16311 }
16312 if (isSetTable()) {
16313 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
16314 if (lastComparison != 0) {
16315 return lastComparison;
16316 }
16317 }
16318 lastComparison = Boolean.valueOf(isSetScan()).compareTo(typedOther.isSetScan());
16319 if (lastComparison != 0) {
16320 return lastComparison;
16321 }
16322 if (isSetScan()) {
16323 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scan, typedOther.scan);
16324 if (lastComparison != 0) {
16325 return lastComparison;
16326 }
16327 }
16328 lastComparison = Boolean.valueOf(isSetNumRows()).compareTo(typedOther.isSetNumRows());
16329 if (lastComparison != 0) {
16330 return lastComparison;
16331 }
16332 if (isSetNumRows()) {
16333 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numRows, typedOther.numRows);
16334 if (lastComparison != 0) {
16335 return lastComparison;
16336 }
16337 }
16338 return 0;
16339 }
16340
16341 public _Fields fieldForId(int fieldId) {
16342 return _Fields.findByThriftId(fieldId);
16343 }
16344
16345 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
16346 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
16347 }
16348
16349 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
16350 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
16351 }
16352
16353 @Override
16354 public String toString() {
16355 StringBuilder sb = new StringBuilder("getScannerResults_args(");
16356 boolean first = true;
16357
16358 sb.append("table:");
16359 if (this.table == null) {
16360 sb.append("null");
16361 } else {
16362 org.apache.thrift.TBaseHelper.toString(this.table, sb);
16363 }
16364 first = false;
16365 if (!first) sb.append(", ");
16366 sb.append("scan:");
16367 if (this.scan == null) {
16368 sb.append("null");
16369 } else {
16370 sb.append(this.scan);
16371 }
16372 first = false;
16373 if (!first) sb.append(", ");
16374 sb.append("numRows:");
16375 sb.append(this.numRows);
16376 first = false;
16377 sb.append(")");
16378 return sb.toString();
16379 }
16380
16381 public void validate() throws org.apache.thrift.TException {
16382
16383 if (table == null) {
16384 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
16385 }
16386 if (scan == null) {
16387 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scan' was not present! Struct: " + toString());
16388 }
16389 }
16390
16391 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
16392 try {
16393 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
16394 } catch (org.apache.thrift.TException te) {
16395 throw new java.io.IOException(te);
16396 }
16397 }
16398
16399 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
16400 try {
16401
16402 __isset_bit_vector = new BitSet(1);
16403 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
16404 } catch (org.apache.thrift.TException te) {
16405 throw new java.io.IOException(te);
16406 }
16407 }
16408
16409 private static class getScannerResults_argsStandardSchemeFactory implements SchemeFactory {
16410 public getScannerResults_argsStandardScheme getScheme() {
16411 return new getScannerResults_argsStandardScheme();
16412 }
16413 }
16414
16415 private static class getScannerResults_argsStandardScheme extends StandardScheme<getScannerResults_args> {
16416
16417 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerResults_args struct) throws org.apache.thrift.TException {
16418 org.apache.thrift.protocol.TField schemeField;
16419 iprot.readStructBegin();
16420 while (true)
16421 {
16422 schemeField = iprot.readFieldBegin();
16423 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
16424 break;
16425 }
16426 switch (schemeField.id) {
16427 case 1:
16428 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
16429 struct.table = iprot.readBinary();
16430 struct.setTableIsSet(true);
16431 } else {
16432 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16433 }
16434 break;
16435 case 2:
16436 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
16437 struct.scan = new TScan();
16438 struct.scan.read(iprot);
16439 struct.setScanIsSet(true);
16440 } else {
16441 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16442 }
16443 break;
16444 case 3:
16445 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
16446 struct.numRows = iprot.readI32();
16447 struct.setNumRowsIsSet(true);
16448 } else {
16449 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16450 }
16451 break;
16452 default:
16453 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16454 }
16455 iprot.readFieldEnd();
16456 }
16457 iprot.readStructEnd();
16458
16459
16460 struct.validate();
16461 }
16462
16463 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerResults_args struct) throws org.apache.thrift.TException {
16464 struct.validate();
16465
16466 oprot.writeStructBegin(STRUCT_DESC);
16467 if (struct.table != null) {
16468 oprot.writeFieldBegin(TABLE_FIELD_DESC);
16469 oprot.writeBinary(struct.table);
16470 oprot.writeFieldEnd();
16471 }
16472 if (struct.scan != null) {
16473 oprot.writeFieldBegin(SCAN_FIELD_DESC);
16474 struct.scan.write(oprot);
16475 oprot.writeFieldEnd();
16476 }
16477 oprot.writeFieldBegin(NUM_ROWS_FIELD_DESC);
16478 oprot.writeI32(struct.numRows);
16479 oprot.writeFieldEnd();
16480 oprot.writeFieldStop();
16481 oprot.writeStructEnd();
16482 }
16483
16484 }
16485
16486 private static class getScannerResults_argsTupleSchemeFactory implements SchemeFactory {
16487 public getScannerResults_argsTupleScheme getScheme() {
16488 return new getScannerResults_argsTupleScheme();
16489 }
16490 }
16491
16492 private static class getScannerResults_argsTupleScheme extends TupleScheme<getScannerResults_args> {
16493
16494 @Override
16495 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerResults_args struct) throws org.apache.thrift.TException {
16496 TTupleProtocol oprot = (TTupleProtocol) prot;
16497 oprot.writeBinary(struct.table);
16498 struct.scan.write(oprot);
16499 BitSet optionals = new BitSet();
16500 if (struct.isSetNumRows()) {
16501 optionals.set(0);
16502 }
16503 oprot.writeBitSet(optionals, 1);
16504 if (struct.isSetNumRows()) {
16505 oprot.writeI32(struct.numRows);
16506 }
16507 }
16508
16509 @Override
16510 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerResults_args struct) throws org.apache.thrift.TException {
16511 TTupleProtocol iprot = (TTupleProtocol) prot;
16512 struct.table = iprot.readBinary();
16513 struct.setTableIsSet(true);
16514 struct.scan = new TScan();
16515 struct.scan.read(iprot);
16516 struct.setScanIsSet(true);
16517 BitSet incoming = iprot.readBitSet(1);
16518 if (incoming.get(0)) {
16519 struct.numRows = iprot.readI32();
16520 struct.setNumRowsIsSet(true);
16521 }
16522 }
16523 }
16524
16525 }
16526
16527 public static class getScannerResults_result implements org.apache.thrift.TBase<getScannerResults_result, getScannerResults_result._Fields>, java.io.Serializable, Cloneable {
16528 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerResults_result");
16529
16530 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
16531 private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
16532
16533 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
16534 static {
16535 schemes.put(StandardScheme.class, new getScannerResults_resultStandardSchemeFactory());
16536 schemes.put(TupleScheme.class, new getScannerResults_resultTupleSchemeFactory());
16537 }
16538
16539 public List<TResult> success;
16540 public TIOError io;
16541
16542
16543 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
16544 SUCCESS((short)0, "success"),
16545 IO((short)1, "io");
16546
16547 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16548
16549 static {
16550 for (_Fields field : EnumSet.allOf(_Fields.class)) {
16551 byName.put(field.getFieldName(), field);
16552 }
16553 }
16554
16555
16556
16557
16558 public static _Fields findByThriftId(int fieldId) {
16559 switch(fieldId) {
16560 case 0:
16561 return SUCCESS;
16562 case 1:
16563 return IO;
16564 default:
16565 return null;
16566 }
16567 }
16568
16569
16570
16571
16572
16573 public static _Fields findByThriftIdOrThrow(int fieldId) {
16574 _Fields fields = findByThriftId(fieldId);
16575 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16576 return fields;
16577 }
16578
16579
16580
16581
16582 public static _Fields findByName(String name) {
16583 return byName.get(name);
16584 }
16585
16586 private final short _thriftId;
16587 private final String _fieldName;
16588
16589 _Fields(short thriftId, String fieldName) {
16590 _thriftId = thriftId;
16591 _fieldName = fieldName;
16592 }
16593
16594 public short getThriftFieldId() {
16595 return _thriftId;
16596 }
16597
16598 public String getFieldName() {
16599 return _fieldName;
16600 }
16601 }
16602
16603
16604 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
16605 static {
16606 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
16607 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
16608 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
16609 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
16610 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
16611 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
16612 metaDataMap = Collections.unmodifiableMap(tmpMap);
16613 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerResults_result.class, metaDataMap);
16614 }
16615
16616 public getScannerResults_result() {
16617 }
16618
16619 public getScannerResults_result(
16620 List<TResult> success,
16621 TIOError io)
16622 {
16623 this();
16624 this.success = success;
16625 this.io = io;
16626 }
16627
16628
16629
16630
16631 public getScannerResults_result(getScannerResults_result other) {
16632 if (other.isSetSuccess()) {
16633 List<TResult> __this__success = new ArrayList<TResult>();
16634 for (TResult other_element : other.success) {
16635 __this__success.add(new TResult(other_element));
16636 }
16637 this.success = __this__success;
16638 }
16639 if (other.isSetIo()) {
16640 this.io = new TIOError(other.io);
16641 }
16642 }
16643
16644 public getScannerResults_result deepCopy() {
16645 return new getScannerResults_result(this);
16646 }
16647
16648 @Override
16649 public void clear() {
16650 this.success = null;
16651 this.io = null;
16652 }
16653
16654 public int getSuccessSize() {
16655 return (this.success == null) ? 0 : this.success.size();
16656 }
16657
16658 public java.util.Iterator<TResult> getSuccessIterator() {
16659 return (this.success == null) ? null : this.success.iterator();
16660 }
16661
16662 public void addToSuccess(TResult elem) {
16663 if (this.success == null) {
16664 this.success = new ArrayList<TResult>();
16665 }
16666 this.success.add(elem);
16667 }
16668
16669 public List<TResult> getSuccess() {
16670 return this.success;
16671 }
16672
16673 public getScannerResults_result setSuccess(List<TResult> success) {
16674 this.success = success;
16675 return this;
16676 }
16677
16678 public void unsetSuccess() {
16679 this.success = null;
16680 }
16681
16682
16683 public boolean isSetSuccess() {
16684 return this.success != null;
16685 }
16686
16687 public void setSuccessIsSet(boolean value) {
16688 if (!value) {
16689 this.success = null;
16690 }
16691 }
16692
16693 public TIOError getIo() {
16694 return this.io;
16695 }
16696
16697 public getScannerResults_result setIo(TIOError io) {
16698 this.io = io;
16699 return this;
16700 }
16701
16702 public void unsetIo() {
16703 this.io = null;
16704 }
16705
16706
16707 public boolean isSetIo() {
16708 return this.io != null;
16709 }
16710
16711 public void setIoIsSet(boolean value) {
16712 if (!value) {
16713 this.io = null;
16714 }
16715 }
16716
16717 public void setFieldValue(_Fields field, Object value) {
16718 switch (field) {
16719 case SUCCESS:
16720 if (value == null) {
16721 unsetSuccess();
16722 } else {
16723 setSuccess((List<TResult>)value);
16724 }
16725 break;
16726
16727 case IO:
16728 if (value == null) {
16729 unsetIo();
16730 } else {
16731 setIo((TIOError)value);
16732 }
16733 break;
16734
16735 }
16736 }
16737
16738 public Object getFieldValue(_Fields field) {
16739 switch (field) {
16740 case SUCCESS:
16741 return getSuccess();
16742
16743 case IO:
16744 return getIo();
16745
16746 }
16747 throw new IllegalStateException();
16748 }
16749
16750
16751 public boolean isSet(_Fields field) {
16752 if (field == null) {
16753 throw new IllegalArgumentException();
16754 }
16755
16756 switch (field) {
16757 case SUCCESS:
16758 return isSetSuccess();
16759 case IO:
16760 return isSetIo();
16761 }
16762 throw new IllegalStateException();
16763 }
16764
16765 @Override
16766 public boolean equals(Object that) {
16767 if (that == null)
16768 return false;
16769 if (that instanceof getScannerResults_result)
16770 return this.equals((getScannerResults_result)that);
16771 return false;
16772 }
16773
16774 public boolean equals(getScannerResults_result that) {
16775 if (that == null)
16776 return false;
16777
16778 boolean this_present_success = true && this.isSetSuccess();
16779 boolean that_present_success = true && that.isSetSuccess();
16780 if (this_present_success || that_present_success) {
16781 if (!(this_present_success && that_present_success))
16782 return false;
16783 if (!this.success.equals(that.success))
16784 return false;
16785 }
16786
16787 boolean this_present_io = true && this.isSetIo();
16788 boolean that_present_io = true && that.isSetIo();
16789 if (this_present_io || that_present_io) {
16790 if (!(this_present_io && that_present_io))
16791 return false;
16792 if (!this.io.equals(that.io))
16793 return false;
16794 }
16795
16796 return true;
16797 }
16798
16799 @Override
16800 public int hashCode() {
16801 HashCodeBuilder builder = new HashCodeBuilder();
16802
16803 boolean present_success = true && (isSetSuccess());
16804 builder.append(present_success);
16805 if (present_success)
16806 builder.append(success);
16807
16808 boolean present_io = true && (isSetIo());
16809 builder.append(present_io);
16810 if (present_io)
16811 builder.append(io);
16812
16813 return builder.toHashCode();
16814 }
16815
16816 public int compareTo(getScannerResults_result other) {
16817 if (!getClass().equals(other.getClass())) {
16818 return getClass().getName().compareTo(other.getClass().getName());
16819 }
16820
16821 int lastComparison = 0;
16822 getScannerResults_result typedOther = (getScannerResults_result)other;
16823
16824 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
16825 if (lastComparison != 0) {
16826 return lastComparison;
16827 }
16828 if (isSetSuccess()) {
16829 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
16830 if (lastComparison != 0) {
16831 return lastComparison;
16832 }
16833 }
16834 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
16835 if (lastComparison != 0) {
16836 return lastComparison;
16837 }
16838 if (isSetIo()) {
16839 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
16840 if (lastComparison != 0) {
16841 return lastComparison;
16842 }
16843 }
16844 return 0;
16845 }
16846
16847 public _Fields fieldForId(int fieldId) {
16848 return _Fields.findByThriftId(fieldId);
16849 }
16850
16851 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
16852 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
16853 }
16854
16855 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
16856 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
16857 }
16858
16859 @Override
16860 public String toString() {
16861 StringBuilder sb = new StringBuilder("getScannerResults_result(");
16862 boolean first = true;
16863
16864 sb.append("success:");
16865 if (this.success == null) {
16866 sb.append("null");
16867 } else {
16868 sb.append(this.success);
16869 }
16870 first = false;
16871 if (!first) sb.append(", ");
16872 sb.append("io:");
16873 if (this.io == null) {
16874 sb.append("null");
16875 } else {
16876 sb.append(this.io);
16877 }
16878 first = false;
16879 sb.append(")");
16880 return sb.toString();
16881 }
16882
16883 public void validate() throws org.apache.thrift.TException {
16884
16885 }
16886
16887 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
16888 try {
16889 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
16890 } catch (org.apache.thrift.TException te) {
16891 throw new java.io.IOException(te);
16892 }
16893 }
16894
16895 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
16896 try {
16897 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
16898 } catch (org.apache.thrift.TException te) {
16899 throw new java.io.IOException(te);
16900 }
16901 }
16902
16903 private static class getScannerResults_resultStandardSchemeFactory implements SchemeFactory {
16904 public getScannerResults_resultStandardScheme getScheme() {
16905 return new getScannerResults_resultStandardScheme();
16906 }
16907 }
16908
16909 private static class getScannerResults_resultStandardScheme extends StandardScheme<getScannerResults_result> {
16910
16911 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerResults_result struct) throws org.apache.thrift.TException {
16912 org.apache.thrift.protocol.TField schemeField;
16913 iprot.readStructBegin();
16914 while (true)
16915 {
16916 schemeField = iprot.readFieldBegin();
16917 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
16918 break;
16919 }
16920 switch (schemeField.id) {
16921 case 0:
16922 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
16923 {
16924 org.apache.thrift.protocol.TList _list144 = iprot.readListBegin();
16925 struct.success = new ArrayList<TResult>(_list144.size);
16926 for (int _i145 = 0; _i145 < _list144.size; ++_i145)
16927 {
16928 TResult _elem146;
16929 _elem146 = new TResult();
16930 _elem146.read(iprot);
16931 struct.success.add(_elem146);
16932 }
16933 iprot.readListEnd();
16934 }
16935 struct.setSuccessIsSet(true);
16936 } else {
16937 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16938 }
16939 break;
16940 case 1:
16941 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
16942 struct.io = new TIOError();
16943 struct.io.read(iprot);
16944 struct.setIoIsSet(true);
16945 } else {
16946 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16947 }
16948 break;
16949 default:
16950 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16951 }
16952 iprot.readFieldEnd();
16953 }
16954 iprot.readStructEnd();
16955
16956
16957 struct.validate();
16958 }
16959
16960 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerResults_result struct) throws org.apache.thrift.TException {
16961 struct.validate();
16962
16963 oprot.writeStructBegin(STRUCT_DESC);
16964 if (struct.success != null) {
16965 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
16966 {
16967 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
16968 for (TResult _iter147 : struct.success)
16969 {
16970 _iter147.write(oprot);
16971 }
16972 oprot.writeListEnd();
16973 }
16974 oprot.writeFieldEnd();
16975 }
16976 if (struct.io != null) {
16977 oprot.writeFieldBegin(IO_FIELD_DESC);
16978 struct.io.write(oprot);
16979 oprot.writeFieldEnd();
16980 }
16981 oprot.writeFieldStop();
16982 oprot.writeStructEnd();
16983 }
16984
16985 }
16986
16987 private static class getScannerResults_resultTupleSchemeFactory implements SchemeFactory {
16988 public getScannerResults_resultTupleScheme getScheme() {
16989 return new getScannerResults_resultTupleScheme();
16990 }
16991 }
16992
16993 private static class getScannerResults_resultTupleScheme extends TupleScheme<getScannerResults_result> {
16994
16995 @Override
16996 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerResults_result struct) throws org.apache.thrift.TException {
16997 TTupleProtocol oprot = (TTupleProtocol) prot;
16998 BitSet optionals = new BitSet();
16999 if (struct.isSetSuccess()) {
17000 optionals.set(0);
17001 }
17002 if (struct.isSetIo()) {
17003 optionals.set(1);
17004 }
17005 oprot.writeBitSet(optionals, 2);
17006 if (struct.isSetSuccess()) {
17007 {
17008 oprot.writeI32(struct.success.size());
17009 for (TResult _iter148 : struct.success)
17010 {
17011 _iter148.write(oprot);
17012 }
17013 }
17014 }
17015 if (struct.isSetIo()) {
17016 struct.io.write(oprot);
17017 }
17018 }
17019
17020 @Override
17021 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerResults_result struct) throws org.apache.thrift.TException {
17022 TTupleProtocol iprot = (TTupleProtocol) prot;
17023 BitSet incoming = iprot.readBitSet(2);
17024 if (incoming.get(0)) {
17025 {
17026 org.apache.thrift.protocol.TList _list149 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
17027 struct.success = new ArrayList<TResult>(_list149.size);
17028 for (int _i150 = 0; _i150 < _list149.size; ++_i150)
17029 {
17030 TResult _elem151;
17031 _elem151 = new TResult();
17032 _elem151.read(iprot);
17033 struct.success.add(_elem151);
17034 }
17035 }
17036 struct.setSuccessIsSet(true);
17037 }
17038 if (incoming.get(1)) {
17039 struct.io = new TIOError();
17040 struct.io.read(iprot);
17041 struct.setIoIsSet(true);
17042 }
17043 }
17044 }
17045
17046 }
17047
17048 }