1
2
3
4
5
6
7 package org.apache.hadoop.hbase.thrift2.generated;
8
9 import org.apache.thrift.scheme.IScheme;
10 import org.apache.thrift.scheme.SchemeFactory;
11 import org.apache.thrift.scheme.StandardScheme;
12
13 import org.apache.thrift.scheme.TupleScheme;
14 import org.apache.thrift.protocol.TTupleProtocol;
15 import java.util.List;
16 import java.util.ArrayList;
17 import java.util.Map;
18 import java.util.HashMap;
19 import java.util.EnumMap;
20 import java.util.Set;
21 import java.util.HashSet;
22 import java.util.EnumSet;
23 import java.util.Collections;
24 import java.util.BitSet;
25 import java.nio.ByteBuffer;
26 import java.util.Arrays;
27 import org.slf4j.Logger;
28 import org.slf4j.LoggerFactory;
29
30 public class THBaseService {
31
32 public interface Iface {
33
34
35
36
37
38
39
40
41
42
43 public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
44
45
46
47
48
49
50
51
52
53
54
55
56
57 public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74 public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException;
75
76
77
78
79
80
81
82
83 public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException;
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105 public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException;
106
107
108
109
110
111
112
113
114 public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException;
115
116
117
118
119
120
121
122
123
124
125
126 public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
127
128
129
130
131
132
133
134
135
136
137
138
139 public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException;
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161 public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
162
163 public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException;
164
165
166
167
168
169
170
171
172
173
174 public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException;
175
176
177
178
179
180
181
182
183
184
185 public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
186
187
188
189
190
191
192
193
194 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
195
196
197
198
199
200
201
202
203 public void mutateRow(ByteBuffer table, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException;
204
205
206
207
208
209
210
211
212
213
214
215
216
217 public List<TResult> getScannerResults(ByteBuffer table, TScan scan, int numRows) throws TIOError, org.apache.thrift.TException;
218
219 }
220
221 public interface AsyncIface {
222
223 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.exists_call> resultHandler) throws org.apache.thrift.TException;
224
225 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.get_call> resultHandler) throws org.apache.thrift.TException;
226
227 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getMultiple_call> resultHandler) throws org.apache.thrift.TException;
228
229 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.put_call> resultHandler) throws org.apache.thrift.TException;
230
231 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;
232
233 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.putMultiple_call> resultHandler) throws org.apache.thrift.TException;
234
235 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteSingle_call> resultHandler) throws org.apache.thrift.TException;
236
237 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteMultiple_call> resultHandler) throws org.apache.thrift.TException;
238
239 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;
240
241 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.increment_call> resultHandler) throws org.apache.thrift.TException;
242
243 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.openScanner_call> resultHandler) throws org.apache.thrift.TException;
244
245 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getScannerRows_call> resultHandler) throws org.apache.thrift.TException;
246
247 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeScanner_call> resultHandler) throws org.apache.thrift.TException;
248
249 public void mutateRow(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.mutateRow_call> resultHandler) throws org.apache.thrift.TException;
250
251 public void getScannerResults(ByteBuffer table, TScan scan, int numRows, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getScannerResults_call> resultHandler) throws org.apache.thrift.TException;
252
253 }
254
255 public static class Client extends org.apache.thrift.TServiceClient implements Iface {
256 public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
257 public Factory() {}
258 public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
259 return new Client(prot);
260 }
261 public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
262 return new Client(iprot, oprot);
263 }
264 }
265
266 public Client(org.apache.thrift.protocol.TProtocol prot)
267 {
268 super(prot, prot);
269 }
270
271 public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
272 super(iprot, oprot);
273 }
274
275 public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
276 {
277 send_exists(table, get);
278 return recv_exists();
279 }
280
281 public void send_exists(ByteBuffer table, TGet get) throws org.apache.thrift.TException
282 {
283 exists_args args = new exists_args();
284 args.setTable(table);
285 args.setGet(get);
286 sendBase("exists", args);
287 }
288
289 public boolean recv_exists() throws TIOError, org.apache.thrift.TException
290 {
291 exists_result result = new exists_result();
292 receiveBase(result, "exists");
293 if (result.isSetSuccess()) {
294 return result.success;
295 }
296 if (result.io != null) {
297 throw result.io;
298 }
299 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "exists failed: unknown result");
300 }
301
302 public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
303 {
304 send_get(table, get);
305 return recv_get();
306 }
307
308 public void send_get(ByteBuffer table, TGet get) throws org.apache.thrift.TException
309 {
310 get_args args = new get_args();
311 args.setTable(table);
312 args.setGet(get);
313 sendBase("get", args);
314 }
315
316 public TResult recv_get() throws TIOError, org.apache.thrift.TException
317 {
318 get_result result = new get_result();
319 receiveBase(result, "get");
320 if (result.isSetSuccess()) {
321 return result.success;
322 }
323 if (result.io != null) {
324 throw result.io;
325 }
326 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get failed: unknown result");
327 }
328
329 public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException
330 {
331 send_getMultiple(table, gets);
332 return recv_getMultiple();
333 }
334
335 public void send_getMultiple(ByteBuffer table, List<TGet> gets) throws org.apache.thrift.TException
336 {
337 getMultiple_args args = new getMultiple_args();
338 args.setTable(table);
339 args.setGets(gets);
340 sendBase("getMultiple", args);
341 }
342
343 public List<TResult> recv_getMultiple() throws TIOError, org.apache.thrift.TException
344 {
345 getMultiple_result result = new getMultiple_result();
346 receiveBase(result, "getMultiple");
347 if (result.isSetSuccess()) {
348 return result.success;
349 }
350 if (result.io != null) {
351 throw result.io;
352 }
353 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getMultiple failed: unknown result");
354 }
355
356 public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException
357 {
358 send_put(table, put);
359 recv_put();
360 }
361
362 public void send_put(ByteBuffer table, TPut put) throws org.apache.thrift.TException
363 {
364 put_args args = new put_args();
365 args.setTable(table);
366 args.setPut(put);
367 sendBase("put", args);
368 }
369
370 public void recv_put() throws TIOError, org.apache.thrift.TException
371 {
372 put_result result = new put_result();
373 receiveBase(result, "put");
374 if (result.io != null) {
375 throw result.io;
376 }
377 return;
378 }
379
380 public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException
381 {
382 send_checkAndPut(table, row, family, qualifier, value, put);
383 return recv_checkAndPut();
384 }
385
386 public void send_checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws org.apache.thrift.TException
387 {
388 checkAndPut_args args = new checkAndPut_args();
389 args.setTable(table);
390 args.setRow(row);
391 args.setFamily(family);
392 args.setQualifier(qualifier);
393 args.setValue(value);
394 args.setPut(put);
395 sendBase("checkAndPut", args);
396 }
397
398 public boolean recv_checkAndPut() throws TIOError, org.apache.thrift.TException
399 {
400 checkAndPut_result result = new checkAndPut_result();
401 receiveBase(result, "checkAndPut");
402 if (result.isSetSuccess()) {
403 return result.success;
404 }
405 if (result.io != null) {
406 throw result.io;
407 }
408 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndPut failed: unknown result");
409 }
410
411 public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException
412 {
413 send_putMultiple(table, puts);
414 recv_putMultiple();
415 }
416
417 public void send_putMultiple(ByteBuffer table, List<TPut> puts) throws org.apache.thrift.TException
418 {
419 putMultiple_args args = new putMultiple_args();
420 args.setTable(table);
421 args.setPuts(puts);
422 sendBase("putMultiple", args);
423 }
424
425 public void recv_putMultiple() throws TIOError, org.apache.thrift.TException
426 {
427 putMultiple_result result = new putMultiple_result();
428 receiveBase(result, "putMultiple");
429 if (result.io != null) {
430 throw result.io;
431 }
432 return;
433 }
434
435 public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
436 {
437 send_deleteSingle(table, deleteSingle);
438 recv_deleteSingle();
439 }
440
441 public void send_deleteSingle(ByteBuffer table, TDelete deleteSingle) throws org.apache.thrift.TException
442 {
443 deleteSingle_args args = new deleteSingle_args();
444 args.setTable(table);
445 args.setDeleteSingle(deleteSingle);
446 sendBase("deleteSingle", args);
447 }
448
449 public void recv_deleteSingle() throws TIOError, org.apache.thrift.TException
450 {
451 deleteSingle_result result = new deleteSingle_result();
452 receiveBase(result, "deleteSingle");
453 if (result.io != null) {
454 throw result.io;
455 }
456 return;
457 }
458
459 public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException
460 {
461 send_deleteMultiple(table, deletes);
462 return recv_deleteMultiple();
463 }
464
465 public void send_deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws org.apache.thrift.TException
466 {
467 deleteMultiple_args args = new deleteMultiple_args();
468 args.setTable(table);
469 args.setDeletes(deletes);
470 sendBase("deleteMultiple", args);
471 }
472
473 public List<TDelete> recv_deleteMultiple() throws TIOError, org.apache.thrift.TException
474 {
475 deleteMultiple_result result = new deleteMultiple_result();
476 receiveBase(result, "deleteMultiple");
477 if (result.isSetSuccess()) {
478 return result.success;
479 }
480 if (result.io != null) {
481 throw result.io;
482 }
483 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "deleteMultiple failed: unknown result");
484 }
485
486 public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
487 {
488 send_checkAndDelete(table, row, family, qualifier, value, deleteSingle);
489 return recv_checkAndDelete();
490 }
491
492 public void send_checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws org.apache.thrift.TException
493 {
494 checkAndDelete_args args = new checkAndDelete_args();
495 args.setTable(table);
496 args.setRow(row);
497 args.setFamily(family);
498 args.setQualifier(qualifier);
499 args.setValue(value);
500 args.setDeleteSingle(deleteSingle);
501 sendBase("checkAndDelete", args);
502 }
503
504 public boolean recv_checkAndDelete() throws TIOError, org.apache.thrift.TException
505 {
506 checkAndDelete_result result = new checkAndDelete_result();
507 receiveBase(result, "checkAndDelete");
508 if (result.isSetSuccess()) {
509 return result.success;
510 }
511 if (result.io != null) {
512 throw result.io;
513 }
514 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndDelete failed: unknown result");
515 }
516
517 public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException
518 {
519 send_increment(table, increment);
520 return recv_increment();
521 }
522
523 public void send_increment(ByteBuffer table, TIncrement increment) throws org.apache.thrift.TException
524 {
525 increment_args args = new increment_args();
526 args.setTable(table);
527 args.setIncrement(increment);
528 sendBase("increment", args);
529 }
530
531 public TResult recv_increment() throws TIOError, org.apache.thrift.TException
532 {
533 increment_result result = new increment_result();
534 receiveBase(result, "increment");
535 if (result.isSetSuccess()) {
536 return result.success;
537 }
538 if (result.io != null) {
539 throw result.io;
540 }
541 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "increment failed: unknown result");
542 }
543
544 public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException
545 {
546 send_openScanner(table, scan);
547 return recv_openScanner();
548 }
549
550 public void send_openScanner(ByteBuffer table, TScan scan) throws org.apache.thrift.TException
551 {
552 openScanner_args args = new openScanner_args();
553 args.setTable(table);
554 args.setScan(scan);
555 sendBase("openScanner", args);
556 }
557
558 public int recv_openScanner() throws TIOError, org.apache.thrift.TException
559 {
560 openScanner_result result = new openScanner_result();
561 receiveBase(result, "openScanner");
562 if (result.isSetSuccess()) {
563 return result.success;
564 }
565 if (result.io != null) {
566 throw result.io;
567 }
568 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "openScanner failed: unknown result");
569 }
570
571 public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException
572 {
573 send_getScannerRows(scannerId, numRows);
574 return recv_getScannerRows();
575 }
576
577 public void send_getScannerRows(int scannerId, int numRows) throws org.apache.thrift.TException
578 {
579 getScannerRows_args args = new getScannerRows_args();
580 args.setScannerId(scannerId);
581 args.setNumRows(numRows);
582 sendBase("getScannerRows", args);
583 }
584
585 public List<TResult> recv_getScannerRows() throws TIOError, TIllegalArgument, org.apache.thrift.TException
586 {
587 getScannerRows_result result = new getScannerRows_result();
588 receiveBase(result, "getScannerRows");
589 if (result.isSetSuccess()) {
590 return result.success;
591 }
592 if (result.io != null) {
593 throw result.io;
594 }
595 if (result.ia != null) {
596 throw result.ia;
597 }
598 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerRows failed: unknown result");
599 }
600
601 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException
602 {
603 send_closeScanner(scannerId);
604 recv_closeScanner();
605 }
606
607 public void send_closeScanner(int scannerId) throws org.apache.thrift.TException
608 {
609 closeScanner_args args = new closeScanner_args();
610 args.setScannerId(scannerId);
611 sendBase("closeScanner", args);
612 }
613
614 public void recv_closeScanner() throws TIOError, TIllegalArgument, org.apache.thrift.TException
615 {
616 closeScanner_result result = new closeScanner_result();
617 receiveBase(result, "closeScanner");
618 if (result.io != null) {
619 throw result.io;
620 }
621 if (result.ia != null) {
622 throw result.ia;
623 }
624 return;
625 }
626
627 public void mutateRow(ByteBuffer table, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException
628 {
629 send_mutateRow(table, rowMutations);
630 recv_mutateRow();
631 }
632
633 public void send_mutateRow(ByteBuffer table, TRowMutations rowMutations) throws org.apache.thrift.TException
634 {
635 mutateRow_args args = new mutateRow_args();
636 args.setTable(table);
637 args.setRowMutations(rowMutations);
638 sendBase("mutateRow", args);
639 }
640
641 public void recv_mutateRow() throws TIOError, org.apache.thrift.TException
642 {
643 mutateRow_result result = new mutateRow_result();
644 receiveBase(result, "mutateRow");
645 if (result.io != null) {
646 throw result.io;
647 }
648 return;
649 }
650
651 public List<TResult> getScannerResults(ByteBuffer table, TScan scan, int numRows) throws TIOError, org.apache.thrift.TException
652 {
653 send_getScannerResults(table, scan, numRows);
654 return recv_getScannerResults();
655 }
656
657 public void send_getScannerResults(ByteBuffer table, TScan scan, int numRows) throws org.apache.thrift.TException
658 {
659 getScannerResults_args args = new getScannerResults_args();
660 args.setTable(table);
661 args.setScan(scan);
662 args.setNumRows(numRows);
663 sendBase("getScannerResults", args);
664 }
665
666 public List<TResult> recv_getScannerResults() throws TIOError, org.apache.thrift.TException
667 {
668 getScannerResults_result result = new getScannerResults_result();
669 receiveBase(result, "getScannerResults");
670 if (result.isSetSuccess()) {
671 return result.success;
672 }
673 if (result.io != null) {
674 throw result.io;
675 }
676 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerResults failed: unknown result");
677 }
678
679 }
680 public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
681 public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
682 private org.apache.thrift.async.TAsyncClientManager clientManager;
683 private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
684 public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) {
685 this.clientManager = clientManager;
686 this.protocolFactory = protocolFactory;
687 }
688 public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) {
689 return new AsyncClient(protocolFactory, clientManager, transport);
690 }
691 }
692
693 public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) {
694 super(protocolFactory, clientManager, transport);
695 }
696
697 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<exists_call> resultHandler) throws org.apache.thrift.TException {
698 checkReady();
699 exists_call method_call = new exists_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
700 this.___currentMethod = method_call;
701 ___manager.call(method_call);
702 }
703
704 public static class exists_call extends org.apache.thrift.async.TAsyncMethodCall {
705 private ByteBuffer table;
706 private TGet get;
707 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 {
708 super(client, protocolFactory, transport, resultHandler, false);
709 this.table = table;
710 this.get = get;
711 }
712
713 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
714 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("exists", org.apache.thrift.protocol.TMessageType.CALL, 0));
715 exists_args args = new exists_args();
716 args.setTable(table);
717 args.setGet(get);
718 args.write(prot);
719 prot.writeMessageEnd();
720 }
721
722 public boolean getResult() throws TIOError, org.apache.thrift.TException {
723 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
724 throw new IllegalStateException("Method call not finished!");
725 }
726 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
727 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
728 return (new Client(prot)).recv_exists();
729 }
730 }
731
732 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<get_call> resultHandler) throws org.apache.thrift.TException {
733 checkReady();
734 get_call method_call = new get_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
735 this.___currentMethod = method_call;
736 ___manager.call(method_call);
737 }
738
739 public static class get_call extends org.apache.thrift.async.TAsyncMethodCall {
740 private ByteBuffer table;
741 private TGet get;
742 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 {
743 super(client, protocolFactory, transport, resultHandler, false);
744 this.table = table;
745 this.get = get;
746 }
747
748 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
749 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.CALL, 0));
750 get_args args = new get_args();
751 args.setTable(table);
752 args.setGet(get);
753 args.write(prot);
754 prot.writeMessageEnd();
755 }
756
757 public TResult getResult() throws TIOError, org.apache.thrift.TException {
758 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
759 throw new IllegalStateException("Method call not finished!");
760 }
761 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
762 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
763 return (new Client(prot)).recv_get();
764 }
765 }
766
767 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<getMultiple_call> resultHandler) throws org.apache.thrift.TException {
768 checkReady();
769 getMultiple_call method_call = new getMultiple_call(table, gets, resultHandler, this, ___protocolFactory, ___transport);
770 this.___currentMethod = method_call;
771 ___manager.call(method_call);
772 }
773
774 public static class getMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
775 private ByteBuffer table;
776 private List<TGet> gets;
777 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 {
778 super(client, protocolFactory, transport, resultHandler, false);
779 this.table = table;
780 this.gets = gets;
781 }
782
783 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
784 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
785 getMultiple_args args = new getMultiple_args();
786 args.setTable(table);
787 args.setGets(gets);
788 args.write(prot);
789 prot.writeMessageEnd();
790 }
791
792 public List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
793 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
794 throw new IllegalStateException("Method call not finished!");
795 }
796 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
797 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
798 return (new Client(prot)).recv_getMultiple();
799 }
800 }
801
802 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<put_call> resultHandler) throws org.apache.thrift.TException {
803 checkReady();
804 put_call method_call = new put_call(table, put, resultHandler, this, ___protocolFactory, ___transport);
805 this.___currentMethod = method_call;
806 ___manager.call(method_call);
807 }
808
809 public static class put_call extends org.apache.thrift.async.TAsyncMethodCall {
810 private ByteBuffer table;
811 private TPut put;
812 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 {
813 super(client, protocolFactory, transport, resultHandler, false);
814 this.table = table;
815 this.put = put;
816 }
817
818 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
819 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("put", org.apache.thrift.protocol.TMessageType.CALL, 0));
820 put_args args = new put_args();
821 args.setTable(table);
822 args.setPut(put);
823 args.write(prot);
824 prot.writeMessageEnd();
825 }
826
827 public void getResult() throws TIOError, org.apache.thrift.TException {
828 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
829 throw new IllegalStateException("Method call not finished!");
830 }
831 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
832 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
833 (new Client(prot)).recv_put();
834 }
835 }
836
837 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 {
838 checkReady();
839 checkAndPut_call method_call = new checkAndPut_call(table, row, family, qualifier, value, put, resultHandler, this, ___protocolFactory, ___transport);
840 this.___currentMethod = method_call;
841 ___manager.call(method_call);
842 }
843
844 public static class checkAndPut_call extends org.apache.thrift.async.TAsyncMethodCall {
845 private ByteBuffer table;
846 private ByteBuffer row;
847 private ByteBuffer family;
848 private ByteBuffer qualifier;
849 private ByteBuffer value;
850 private TPut put;
851 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 {
852 super(client, protocolFactory, transport, resultHandler, false);
853 this.table = table;
854 this.row = row;
855 this.family = family;
856 this.qualifier = qualifier;
857 this.value = value;
858 this.put = put;
859 }
860
861 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
862 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndPut", org.apache.thrift.protocol.TMessageType.CALL, 0));
863 checkAndPut_args args = new checkAndPut_args();
864 args.setTable(table);
865 args.setRow(row);
866 args.setFamily(family);
867 args.setQualifier(qualifier);
868 args.setValue(value);
869 args.setPut(put);
870 args.write(prot);
871 prot.writeMessageEnd();
872 }
873
874 public boolean getResult() throws TIOError, org.apache.thrift.TException {
875 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
876 throw new IllegalStateException("Method call not finished!");
877 }
878 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
879 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
880 return (new Client(prot)).recv_checkAndPut();
881 }
882 }
883
884 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<putMultiple_call> resultHandler) throws org.apache.thrift.TException {
885 checkReady();
886 putMultiple_call method_call = new putMultiple_call(table, puts, resultHandler, this, ___protocolFactory, ___transport);
887 this.___currentMethod = method_call;
888 ___manager.call(method_call);
889 }
890
891 public static class putMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
892 private ByteBuffer table;
893 private List<TPut> puts;
894 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 {
895 super(client, protocolFactory, transport, resultHandler, false);
896 this.table = table;
897 this.puts = puts;
898 }
899
900 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
901 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("putMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
902 putMultiple_args args = new putMultiple_args();
903 args.setTable(table);
904 args.setPuts(puts);
905 args.write(prot);
906 prot.writeMessageEnd();
907 }
908
909 public void getResult() throws TIOError, org.apache.thrift.TException {
910 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
911 throw new IllegalStateException("Method call not finished!");
912 }
913 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
914 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
915 (new Client(prot)).recv_putMultiple();
916 }
917 }
918
919 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<deleteSingle_call> resultHandler) throws org.apache.thrift.TException {
920 checkReady();
921 deleteSingle_call method_call = new deleteSingle_call(table, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
922 this.___currentMethod = method_call;
923 ___manager.call(method_call);
924 }
925
926 public static class deleteSingle_call extends org.apache.thrift.async.TAsyncMethodCall {
927 private ByteBuffer table;
928 private TDelete deleteSingle;
929 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 {
930 super(client, protocolFactory, transport, resultHandler, false);
931 this.table = table;
932 this.deleteSingle = deleteSingle;
933 }
934
935 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
936 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteSingle", org.apache.thrift.protocol.TMessageType.CALL, 0));
937 deleteSingle_args args = new deleteSingle_args();
938 args.setTable(table);
939 args.setDeleteSingle(deleteSingle);
940 args.write(prot);
941 prot.writeMessageEnd();
942 }
943
944 public void getResult() throws TIOError, org.apache.thrift.TException {
945 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
946 throw new IllegalStateException("Method call not finished!");
947 }
948 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
949 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
950 (new Client(prot)).recv_deleteSingle();
951 }
952 }
953
954 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<deleteMultiple_call> resultHandler) throws org.apache.thrift.TException {
955 checkReady();
956 deleteMultiple_call method_call = new deleteMultiple_call(table, deletes, resultHandler, this, ___protocolFactory, ___transport);
957 this.___currentMethod = method_call;
958 ___manager.call(method_call);
959 }
960
961 public static class deleteMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
962 private ByteBuffer table;
963 private List<TDelete> deletes;
964 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 {
965 super(client, protocolFactory, transport, resultHandler, false);
966 this.table = table;
967 this.deletes = deletes;
968 }
969
970 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
971 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
972 deleteMultiple_args args = new deleteMultiple_args();
973 args.setTable(table);
974 args.setDeletes(deletes);
975 args.write(prot);
976 prot.writeMessageEnd();
977 }
978
979 public List<TDelete> getResult() throws TIOError, org.apache.thrift.TException {
980 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
981 throw new IllegalStateException("Method call not finished!");
982 }
983 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
984 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
985 return (new Client(prot)).recv_deleteMultiple();
986 }
987 }
988
989 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 {
990 checkReady();
991 checkAndDelete_call method_call = new checkAndDelete_call(table, row, family, qualifier, value, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
992 this.___currentMethod = method_call;
993 ___manager.call(method_call);
994 }
995
996 public static class checkAndDelete_call extends org.apache.thrift.async.TAsyncMethodCall {
997 private ByteBuffer table;
998 private ByteBuffer row;
999 private ByteBuffer family;
1000 private ByteBuffer qualifier;
1001 private ByteBuffer value;
1002 private TDelete deleteSingle;
1003 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 {
1004 super(client, protocolFactory, transport, resultHandler, false);
1005 this.table = table;
1006 this.row = row;
1007 this.family = family;
1008 this.qualifier = qualifier;
1009 this.value = value;
1010 this.deleteSingle = deleteSingle;
1011 }
1012
1013 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1014 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndDelete", org.apache.thrift.protocol.TMessageType.CALL, 0));
1015 checkAndDelete_args args = new checkAndDelete_args();
1016 args.setTable(table);
1017 args.setRow(row);
1018 args.setFamily(family);
1019 args.setQualifier(qualifier);
1020 args.setValue(value);
1021 args.setDeleteSingle(deleteSingle);
1022 args.write(prot);
1023 prot.writeMessageEnd();
1024 }
1025
1026 public boolean getResult() throws TIOError, org.apache.thrift.TException {
1027 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1028 throw new IllegalStateException("Method call not finished!");
1029 }
1030 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1031 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1032 return (new Client(prot)).recv_checkAndDelete();
1033 }
1034 }
1035
1036 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<increment_call> resultHandler) throws org.apache.thrift.TException {
1037 checkReady();
1038 increment_call method_call = new increment_call(table, increment, resultHandler, this, ___protocolFactory, ___transport);
1039 this.___currentMethod = method_call;
1040 ___manager.call(method_call);
1041 }
1042
1043 public static class increment_call extends org.apache.thrift.async.TAsyncMethodCall {
1044 private ByteBuffer table;
1045 private TIncrement increment;
1046 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 {
1047 super(client, protocolFactory, transport, resultHandler, false);
1048 this.table = table;
1049 this.increment = increment;
1050 }
1051
1052 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1053 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("increment", org.apache.thrift.protocol.TMessageType.CALL, 0));
1054 increment_args args = new increment_args();
1055 args.setTable(table);
1056 args.setIncrement(increment);
1057 args.write(prot);
1058 prot.writeMessageEnd();
1059 }
1060
1061 public TResult getResult() throws TIOError, org.apache.thrift.TException {
1062 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1063 throw new IllegalStateException("Method call not finished!");
1064 }
1065 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1066 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1067 return (new Client(prot)).recv_increment();
1068 }
1069 }
1070
1071 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<openScanner_call> resultHandler) throws org.apache.thrift.TException {
1072 checkReady();
1073 openScanner_call method_call = new openScanner_call(table, scan, resultHandler, this, ___protocolFactory, ___transport);
1074 this.___currentMethod = method_call;
1075 ___manager.call(method_call);
1076 }
1077
1078 public static class openScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1079 private ByteBuffer table;
1080 private TScan scan;
1081 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 {
1082 super(client, protocolFactory, transport, resultHandler, false);
1083 this.table = table;
1084 this.scan = scan;
1085 }
1086
1087 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1088 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("openScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1089 openScanner_args args = new openScanner_args();
1090 args.setTable(table);
1091 args.setScan(scan);
1092 args.write(prot);
1093 prot.writeMessageEnd();
1094 }
1095
1096 public int getResult() throws TIOError, org.apache.thrift.TException {
1097 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1098 throw new IllegalStateException("Method call not finished!");
1099 }
1100 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1101 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1102 return (new Client(prot)).recv_openScanner();
1103 }
1104 }
1105
1106 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerRows_call> resultHandler) throws org.apache.thrift.TException {
1107 checkReady();
1108 getScannerRows_call method_call = new getScannerRows_call(scannerId, numRows, resultHandler, this, ___protocolFactory, ___transport);
1109 this.___currentMethod = method_call;
1110 ___manager.call(method_call);
1111 }
1112
1113 public static class getScannerRows_call extends org.apache.thrift.async.TAsyncMethodCall {
1114 private int scannerId;
1115 private int numRows;
1116 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 {
1117 super(client, protocolFactory, transport, resultHandler, false);
1118 this.scannerId = scannerId;
1119 this.numRows = numRows;
1120 }
1121
1122 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1123 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerRows", org.apache.thrift.protocol.TMessageType.CALL, 0));
1124 getScannerRows_args args = new getScannerRows_args();
1125 args.setScannerId(scannerId);
1126 args.setNumRows(numRows);
1127 args.write(prot);
1128 prot.writeMessageEnd();
1129 }
1130
1131 public List<TResult> getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1132 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1133 throw new IllegalStateException("Method call not finished!");
1134 }
1135 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1136 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1137 return (new Client(prot)).recv_getScannerRows();
1138 }
1139 }
1140
1141 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<closeScanner_call> resultHandler) throws org.apache.thrift.TException {
1142 checkReady();
1143 closeScanner_call method_call = new closeScanner_call(scannerId, resultHandler, this, ___protocolFactory, ___transport);
1144 this.___currentMethod = method_call;
1145 ___manager.call(method_call);
1146 }
1147
1148 public static class closeScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1149 private int scannerId;
1150 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 {
1151 super(client, protocolFactory, transport, resultHandler, false);
1152 this.scannerId = scannerId;
1153 }
1154
1155 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1156 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1157 closeScanner_args args = new closeScanner_args();
1158 args.setScannerId(scannerId);
1159 args.write(prot);
1160 prot.writeMessageEnd();
1161 }
1162
1163 public void getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1164 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1165 throw new IllegalStateException("Method call not finished!");
1166 }
1167 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1168 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1169 (new Client(prot)).recv_closeScanner();
1170 }
1171 }
1172
1173 public void mutateRow(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<mutateRow_call> resultHandler) throws org.apache.thrift.TException {
1174 checkReady();
1175 mutateRow_call method_call = new mutateRow_call(table, rowMutations, resultHandler, this, ___protocolFactory, ___transport);
1176 this.___currentMethod = method_call;
1177 ___manager.call(method_call);
1178 }
1179
1180 public static class mutateRow_call extends org.apache.thrift.async.TAsyncMethodCall {
1181 private ByteBuffer table;
1182 private TRowMutations rowMutations;
1183 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 {
1184 super(client, protocolFactory, transport, resultHandler, false);
1185 this.table = table;
1186 this.rowMutations = rowMutations;
1187 }
1188
1189 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1190 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRow", org.apache.thrift.protocol.TMessageType.CALL, 0));
1191 mutateRow_args args = new mutateRow_args();
1192 args.setTable(table);
1193 args.setRowMutations(rowMutations);
1194 args.write(prot);
1195 prot.writeMessageEnd();
1196 }
1197
1198 public void getResult() throws TIOError, org.apache.thrift.TException {
1199 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1200 throw new IllegalStateException("Method call not finished!");
1201 }
1202 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1203 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1204 (new Client(prot)).recv_mutateRow();
1205 }
1206 }
1207
1208 public void getScannerResults(ByteBuffer table, TScan scan, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerResults_call> resultHandler) throws org.apache.thrift.TException {
1209 checkReady();
1210 getScannerResults_call method_call = new getScannerResults_call(table, scan, numRows, resultHandler, this, ___protocolFactory, ___transport);
1211 this.___currentMethod = method_call;
1212 ___manager.call(method_call);
1213 }
1214
1215 public static class getScannerResults_call extends org.apache.thrift.async.TAsyncMethodCall {
1216 private ByteBuffer table;
1217 private TScan scan;
1218 private int numRows;
1219 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 {
1220 super(client, protocolFactory, transport, resultHandler, false);
1221 this.table = table;
1222 this.scan = scan;
1223 this.numRows = numRows;
1224 }
1225
1226 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1227 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerResults", org.apache.thrift.protocol.TMessageType.CALL, 0));
1228 getScannerResults_args args = new getScannerResults_args();
1229 args.setTable(table);
1230 args.setScan(scan);
1231 args.setNumRows(numRows);
1232 args.write(prot);
1233 prot.writeMessageEnd();
1234 }
1235
1236 public List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
1237 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1238 throw new IllegalStateException("Method call not finished!");
1239 }
1240 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1241 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1242 return (new Client(prot)).recv_getScannerResults();
1243 }
1244 }
1245
1246 }
1247
1248 public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
1249 private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1250 public Processor(I iface) {
1251 super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
1252 }
1253
1254 protected Processor(I iface, Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
1255 super(iface, getProcessMap(processMap));
1256 }
1257
1258 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) {
1259 processMap.put("exists", new exists());
1260 processMap.put("get", new get());
1261 processMap.put("getMultiple", new getMultiple());
1262 processMap.put("put", new put());
1263 processMap.put("checkAndPut", new checkAndPut());
1264 processMap.put("putMultiple", new putMultiple());
1265 processMap.put("deleteSingle", new deleteSingle());
1266 processMap.put("deleteMultiple", new deleteMultiple());
1267 processMap.put("checkAndDelete", new checkAndDelete());
1268 processMap.put("increment", new increment());
1269 processMap.put("openScanner", new openScanner());
1270 processMap.put("getScannerRows", new getScannerRows());
1271 processMap.put("closeScanner", new closeScanner());
1272 processMap.put("mutateRow", new mutateRow());
1273 processMap.put("getScannerResults", new getScannerResults());
1274 return processMap;
1275 }
1276
1277 private static class exists<I extends Iface> extends org.apache.thrift.ProcessFunction<I, exists_args> {
1278 public exists() {
1279 super("exists");
1280 }
1281
1282 protected exists_args getEmptyArgsInstance() {
1283 return new exists_args();
1284 }
1285
1286 protected exists_result getResult(I iface, exists_args args) throws org.apache.thrift.TException {
1287 exists_result result = new exists_result();
1288 try {
1289 result.success = iface.exists(args.table, args.get);
1290 result.setSuccessIsSet(true);
1291 } catch (TIOError io) {
1292 result.io = io;
1293 }
1294 return result;
1295 }
1296 }
1297
1298 private static class get<I extends Iface> extends org.apache.thrift.ProcessFunction<I, get_args> {
1299 public get() {
1300 super("get");
1301 }
1302
1303 protected get_args getEmptyArgsInstance() {
1304 return new get_args();
1305 }
1306
1307 protected get_result getResult(I iface, get_args args) throws org.apache.thrift.TException {
1308 get_result result = new get_result();
1309 try {
1310 result.success = iface.get(args.table, args.get);
1311 } catch (TIOError io) {
1312 result.io = io;
1313 }
1314 return result;
1315 }
1316 }
1317
1318 private static class getMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getMultiple_args> {
1319 public getMultiple() {
1320 super("getMultiple");
1321 }
1322
1323 protected getMultiple_args getEmptyArgsInstance() {
1324 return new getMultiple_args();
1325 }
1326
1327 protected getMultiple_result getResult(I iface, getMultiple_args args) throws org.apache.thrift.TException {
1328 getMultiple_result result = new getMultiple_result();
1329 try {
1330 result.success = iface.getMultiple(args.table, args.gets);
1331 } catch (TIOError io) {
1332 result.io = io;
1333 }
1334 return result;
1335 }
1336 }
1337
1338 private static class put<I extends Iface> extends org.apache.thrift.ProcessFunction<I, put_args> {
1339 public put() {
1340 super("put");
1341 }
1342
1343 protected put_args getEmptyArgsInstance() {
1344 return new put_args();
1345 }
1346
1347 protected put_result getResult(I iface, put_args args) throws org.apache.thrift.TException {
1348 put_result result = new put_result();
1349 try {
1350 iface.put(args.table, args.put);
1351 } catch (TIOError io) {
1352 result.io = io;
1353 }
1354 return result;
1355 }
1356 }
1357
1358 private static class checkAndPut<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndPut_args> {
1359 public checkAndPut() {
1360 super("checkAndPut");
1361 }
1362
1363 protected checkAndPut_args getEmptyArgsInstance() {
1364 return new checkAndPut_args();
1365 }
1366
1367 protected checkAndPut_result getResult(I iface, checkAndPut_args args) throws org.apache.thrift.TException {
1368 checkAndPut_result result = new checkAndPut_result();
1369 try {
1370 result.success = iface.checkAndPut(args.table, args.row, args.family, args.qualifier, args.value, args.put);
1371 result.setSuccessIsSet(true);
1372 } catch (TIOError io) {
1373 result.io = io;
1374 }
1375 return result;
1376 }
1377 }
1378
1379 private static class putMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, putMultiple_args> {
1380 public putMultiple() {
1381 super("putMultiple");
1382 }
1383
1384 protected putMultiple_args getEmptyArgsInstance() {
1385 return new putMultiple_args();
1386 }
1387
1388 protected putMultiple_result getResult(I iface, putMultiple_args args) throws org.apache.thrift.TException {
1389 putMultiple_result result = new putMultiple_result();
1390 try {
1391 iface.putMultiple(args.table, args.puts);
1392 } catch (TIOError io) {
1393 result.io = io;
1394 }
1395 return result;
1396 }
1397 }
1398
1399 private static class deleteSingle<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteSingle_args> {
1400 public deleteSingle() {
1401 super("deleteSingle");
1402 }
1403
1404 protected deleteSingle_args getEmptyArgsInstance() {
1405 return new deleteSingle_args();
1406 }
1407
1408 protected deleteSingle_result getResult(I iface, deleteSingle_args args) throws org.apache.thrift.TException {
1409 deleteSingle_result result = new deleteSingle_result();
1410 try {
1411 iface.deleteSingle(args.table, args.deleteSingle);
1412 } catch (TIOError io) {
1413 result.io = io;
1414 }
1415 return result;
1416 }
1417 }
1418
1419 private static class deleteMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteMultiple_args> {
1420 public deleteMultiple() {
1421 super("deleteMultiple");
1422 }
1423
1424 protected deleteMultiple_args getEmptyArgsInstance() {
1425 return new deleteMultiple_args();
1426 }
1427
1428 protected deleteMultiple_result getResult(I iface, deleteMultiple_args args) throws org.apache.thrift.TException {
1429 deleteMultiple_result result = new deleteMultiple_result();
1430 try {
1431 result.success = iface.deleteMultiple(args.table, args.deletes);
1432 } catch (TIOError io) {
1433 result.io = io;
1434 }
1435 return result;
1436 }
1437 }
1438
1439 private static class checkAndDelete<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndDelete_args> {
1440 public checkAndDelete() {
1441 super("checkAndDelete");
1442 }
1443
1444 protected checkAndDelete_args getEmptyArgsInstance() {
1445 return new checkAndDelete_args();
1446 }
1447
1448 protected checkAndDelete_result getResult(I iface, checkAndDelete_args args) throws org.apache.thrift.TException {
1449 checkAndDelete_result result = new checkAndDelete_result();
1450 try {
1451 result.success = iface.checkAndDelete(args.table, args.row, args.family, args.qualifier, args.value, args.deleteSingle);
1452 result.setSuccessIsSet(true);
1453 } catch (TIOError io) {
1454 result.io = io;
1455 }
1456 return result;
1457 }
1458 }
1459
1460 private static class increment<I extends Iface> extends org.apache.thrift.ProcessFunction<I, increment_args> {
1461 public increment() {
1462 super("increment");
1463 }
1464
1465 protected increment_args getEmptyArgsInstance() {
1466 return new increment_args();
1467 }
1468
1469 protected increment_result getResult(I iface, increment_args args) throws org.apache.thrift.TException {
1470 increment_result result = new increment_result();
1471 try {
1472 result.success = iface.increment(args.table, args.increment);
1473 } catch (TIOError io) {
1474 result.io = io;
1475 }
1476 return result;
1477 }
1478 }
1479
1480 private static class openScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, openScanner_args> {
1481 public openScanner() {
1482 super("openScanner");
1483 }
1484
1485 protected openScanner_args getEmptyArgsInstance() {
1486 return new openScanner_args();
1487 }
1488
1489 protected openScanner_result getResult(I iface, openScanner_args args) throws org.apache.thrift.TException {
1490 openScanner_result result = new openScanner_result();
1491 try {
1492 result.success = iface.openScanner(args.table, args.scan);
1493 result.setSuccessIsSet(true);
1494 } catch (TIOError io) {
1495 result.io = io;
1496 }
1497 return result;
1498 }
1499 }
1500
1501 private static class getScannerRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerRows_args> {
1502 public getScannerRows() {
1503 super("getScannerRows");
1504 }
1505
1506 protected getScannerRows_args getEmptyArgsInstance() {
1507 return new getScannerRows_args();
1508 }
1509
1510 protected getScannerRows_result getResult(I iface, getScannerRows_args args) throws org.apache.thrift.TException {
1511 getScannerRows_result result = new getScannerRows_result();
1512 try {
1513 result.success = iface.getScannerRows(args.scannerId, args.numRows);
1514 } catch (TIOError io) {
1515 result.io = io;
1516 } catch (TIllegalArgument ia) {
1517 result.ia = ia;
1518 }
1519 return result;
1520 }
1521 }
1522
1523 private static class closeScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeScanner_args> {
1524 public closeScanner() {
1525 super("closeScanner");
1526 }
1527
1528 protected closeScanner_args getEmptyArgsInstance() {
1529 return new closeScanner_args();
1530 }
1531
1532 protected closeScanner_result getResult(I iface, closeScanner_args args) throws org.apache.thrift.TException {
1533 closeScanner_result result = new closeScanner_result();
1534 try {
1535 iface.closeScanner(args.scannerId);
1536 } catch (TIOError io) {
1537 result.io = io;
1538 } catch (TIllegalArgument ia) {
1539 result.ia = ia;
1540 }
1541 return result;
1542 }
1543 }
1544
1545 private static class mutateRow<I extends Iface> extends org.apache.thrift.ProcessFunction<I, mutateRow_args> {
1546 public mutateRow() {
1547 super("mutateRow");
1548 }
1549
1550 protected mutateRow_args getEmptyArgsInstance() {
1551 return new mutateRow_args();
1552 }
1553
1554 protected mutateRow_result getResult(I iface, mutateRow_args args) throws org.apache.thrift.TException {
1555 mutateRow_result result = new mutateRow_result();
1556 try {
1557 iface.mutateRow(args.table, args.rowMutations);
1558 } catch (TIOError io) {
1559 result.io = io;
1560 }
1561 return result;
1562 }
1563 }
1564
1565 private static class getScannerResults<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerResults_args> {
1566 public getScannerResults() {
1567 super("getScannerResults");
1568 }
1569
1570 protected getScannerResults_args getEmptyArgsInstance() {
1571 return new getScannerResults_args();
1572 }
1573
1574 protected getScannerResults_result getResult(I iface, getScannerResults_args args) throws org.apache.thrift.TException {
1575 getScannerResults_result result = new getScannerResults_result();
1576 try {
1577 result.success = iface.getScannerResults(args.table, args.scan, args.numRows);
1578 } catch (TIOError io) {
1579 result.io = io;
1580 }
1581 return result;
1582 }
1583 }
1584
1585 }
1586
1587 public static class exists_args implements org.apache.thrift.TBase<exists_args, exists_args._Fields>, java.io.Serializable, Cloneable {
1588 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_args");
1589
1590 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);
1591 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);
1592
1593 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
1594 static {
1595 schemes.put(StandardScheme.class, new exists_argsStandardSchemeFactory());
1596 schemes.put(TupleScheme.class, new exists_argsTupleSchemeFactory());
1597 }
1598
1599
1600
1601
1602 public ByteBuffer table;
1603
1604
1605
1606 public TGet get;
1607
1608
1609 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
1610
1611
1612
1613 TABLE((short)1, "table"),
1614
1615
1616
1617 GET((short)2, "get");
1618
1619 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
1620
1621 static {
1622 for (_Fields field : EnumSet.allOf(_Fields.class)) {
1623 byName.put(field.getFieldName(), field);
1624 }
1625 }
1626
1627
1628
1629
1630 public static _Fields findByThriftId(int fieldId) {
1631 switch(fieldId) {
1632 case 1:
1633 return TABLE;
1634 case 2:
1635 return GET;
1636 default:
1637 return null;
1638 }
1639 }
1640
1641
1642
1643
1644
1645 public static _Fields findByThriftIdOrThrow(int fieldId) {
1646 _Fields fields = findByThriftId(fieldId);
1647 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
1648 return fields;
1649 }
1650
1651
1652
1653
1654 public static _Fields findByName(String name) {
1655 return byName.get(name);
1656 }
1657
1658 private final short _thriftId;
1659 private final String _fieldName;
1660
1661 _Fields(short thriftId, String fieldName) {
1662 _thriftId = thriftId;
1663 _fieldName = fieldName;
1664 }
1665
1666 public short getThriftFieldId() {
1667 return _thriftId;
1668 }
1669
1670 public String getFieldName() {
1671 return _fieldName;
1672 }
1673 }
1674
1675
1676 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
1677 static {
1678 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
1679 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
1680 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
1681 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
1682 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
1683 metaDataMap = Collections.unmodifiableMap(tmpMap);
1684 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_args.class, metaDataMap);
1685 }
1686
1687 public exists_args() {
1688 }
1689
1690 public exists_args(
1691 ByteBuffer table,
1692 TGet get)
1693 {
1694 this();
1695 this.table = table;
1696 this.get = get;
1697 }
1698
1699
1700
1701
1702 public exists_args(exists_args other) {
1703 if (other.isSetTable()) {
1704 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
1705 ;
1706 }
1707 if (other.isSetGet()) {
1708 this.get = new TGet(other.get);
1709 }
1710 }
1711
1712 public exists_args deepCopy() {
1713 return new exists_args(this);
1714 }
1715
1716 @Override
1717 public void clear() {
1718 this.table = null;
1719 this.get = null;
1720 }
1721
1722
1723
1724
1725 public byte[] getTable() {
1726 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
1727 return table == null ? null : table.array();
1728 }
1729
1730 public ByteBuffer bufferForTable() {
1731 return table;
1732 }
1733
1734
1735
1736
1737 public exists_args setTable(byte[] table) {
1738 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
1739 return this;
1740 }
1741
1742 public exists_args setTable(ByteBuffer table) {
1743 this.table = table;
1744 return this;
1745 }
1746
1747 public void unsetTable() {
1748 this.table = null;
1749 }
1750
1751
1752 public boolean isSetTable() {
1753 return this.table != null;
1754 }
1755
1756 public void setTableIsSet(boolean value) {
1757 if (!value) {
1758 this.table = null;
1759 }
1760 }
1761
1762
1763
1764
1765 public TGet getGet() {
1766 return this.get;
1767 }
1768
1769
1770
1771
1772 public exists_args setGet(TGet get) {
1773 this.get = get;
1774 return this;
1775 }
1776
1777 public void unsetGet() {
1778 this.get = null;
1779 }
1780
1781
1782 public boolean isSetGet() {
1783 return this.get != null;
1784 }
1785
1786 public void setGetIsSet(boolean value) {
1787 if (!value) {
1788 this.get = null;
1789 }
1790 }
1791
1792 public void setFieldValue(_Fields field, Object value) {
1793 switch (field) {
1794 case TABLE:
1795 if (value == null) {
1796 unsetTable();
1797 } else {
1798 setTable((ByteBuffer)value);
1799 }
1800 break;
1801
1802 case GET:
1803 if (value == null) {
1804 unsetGet();
1805 } else {
1806 setGet((TGet)value);
1807 }
1808 break;
1809
1810 }
1811 }
1812
1813 public Object getFieldValue(_Fields field) {
1814 switch (field) {
1815 case TABLE:
1816 return getTable();
1817
1818 case GET:
1819 return getGet();
1820
1821 }
1822 throw new IllegalStateException();
1823 }
1824
1825
1826 public boolean isSet(_Fields field) {
1827 if (field == null) {
1828 throw new IllegalArgumentException();
1829 }
1830
1831 switch (field) {
1832 case TABLE:
1833 return isSetTable();
1834 case GET:
1835 return isSetGet();
1836 }
1837 throw new IllegalStateException();
1838 }
1839
1840 @Override
1841 public boolean equals(Object that) {
1842 if (that == null)
1843 return false;
1844 if (that instanceof exists_args)
1845 return this.equals((exists_args)that);
1846 return false;
1847 }
1848
1849 public boolean equals(exists_args that) {
1850 if (that == null)
1851 return false;
1852
1853 boolean this_present_table = true && this.isSetTable();
1854 boolean that_present_table = true && that.isSetTable();
1855 if (this_present_table || that_present_table) {
1856 if (!(this_present_table && that_present_table))
1857 return false;
1858 if (!this.table.equals(that.table))
1859 return false;
1860 }
1861
1862 boolean this_present_get = true && this.isSetGet();
1863 boolean that_present_get = true && that.isSetGet();
1864 if (this_present_get || that_present_get) {
1865 if (!(this_present_get && that_present_get))
1866 return false;
1867 if (!this.get.equals(that.get))
1868 return false;
1869 }
1870
1871 return true;
1872 }
1873
1874 @Override
1875 public int hashCode() {
1876 return 0;
1877 }
1878
1879 public int compareTo(exists_args other) {
1880 if (!getClass().equals(other.getClass())) {
1881 return getClass().getName().compareTo(other.getClass().getName());
1882 }
1883
1884 int lastComparison = 0;
1885 exists_args typedOther = (exists_args)other;
1886
1887 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
1888 if (lastComparison != 0) {
1889 return lastComparison;
1890 }
1891 if (isSetTable()) {
1892 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
1893 if (lastComparison != 0) {
1894 return lastComparison;
1895 }
1896 }
1897 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
1898 if (lastComparison != 0) {
1899 return lastComparison;
1900 }
1901 if (isSetGet()) {
1902 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
1903 if (lastComparison != 0) {
1904 return lastComparison;
1905 }
1906 }
1907 return 0;
1908 }
1909
1910 public _Fields fieldForId(int fieldId) {
1911 return _Fields.findByThriftId(fieldId);
1912 }
1913
1914 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
1915 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
1916 }
1917
1918 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
1919 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
1920 }
1921
1922 @Override
1923 public String toString() {
1924 StringBuilder sb = new StringBuilder("exists_args(");
1925 boolean first = true;
1926
1927 sb.append("table:");
1928 if (this.table == null) {
1929 sb.append("null");
1930 } else {
1931 org.apache.thrift.TBaseHelper.toString(this.table, sb);
1932 }
1933 first = false;
1934 if (!first) sb.append(", ");
1935 sb.append("get:");
1936 if (this.get == null) {
1937 sb.append("null");
1938 } else {
1939 sb.append(this.get);
1940 }
1941 first = false;
1942 sb.append(")");
1943 return sb.toString();
1944 }
1945
1946 public void validate() throws org.apache.thrift.TException {
1947
1948 if (table == null) {
1949 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
1950 }
1951 if (get == null) {
1952 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
1953 }
1954 }
1955
1956 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
1957 try {
1958 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
1959 } catch (org.apache.thrift.TException te) {
1960 throw new java.io.IOException(te);
1961 }
1962 }
1963
1964 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
1965 try {
1966 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
1967 } catch (org.apache.thrift.TException te) {
1968 throw new java.io.IOException(te);
1969 }
1970 }
1971
1972 private static class exists_argsStandardSchemeFactory implements SchemeFactory {
1973 public exists_argsStandardScheme getScheme() {
1974 return new exists_argsStandardScheme();
1975 }
1976 }
1977
1978 private static class exists_argsStandardScheme extends StandardScheme<exists_args> {
1979
1980 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_args struct) throws org.apache.thrift.TException {
1981 org.apache.thrift.protocol.TField schemeField;
1982 iprot.readStructBegin();
1983 while (true)
1984 {
1985 schemeField = iprot.readFieldBegin();
1986 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
1987 break;
1988 }
1989 switch (schemeField.id) {
1990 case 1:
1991 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
1992 struct.table = iprot.readBinary();
1993 struct.setTableIsSet(true);
1994 } else {
1995 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1996 }
1997 break;
1998 case 2:
1999 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2000 struct.get = new TGet();
2001 struct.get.read(iprot);
2002 struct.setGetIsSet(true);
2003 } else {
2004 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2005 }
2006 break;
2007 default:
2008 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2009 }
2010 iprot.readFieldEnd();
2011 }
2012 iprot.readStructEnd();
2013
2014
2015 struct.validate();
2016 }
2017
2018 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_args struct) throws org.apache.thrift.TException {
2019 struct.validate();
2020
2021 oprot.writeStructBegin(STRUCT_DESC);
2022 if (struct.table != null) {
2023 oprot.writeFieldBegin(TABLE_FIELD_DESC);
2024 oprot.writeBinary(struct.table);
2025 oprot.writeFieldEnd();
2026 }
2027 if (struct.get != null) {
2028 oprot.writeFieldBegin(GET_FIELD_DESC);
2029 struct.get.write(oprot);
2030 oprot.writeFieldEnd();
2031 }
2032 oprot.writeFieldStop();
2033 oprot.writeStructEnd();
2034 }
2035
2036 }
2037
2038 private static class exists_argsTupleSchemeFactory implements SchemeFactory {
2039 public exists_argsTupleScheme getScheme() {
2040 return new exists_argsTupleScheme();
2041 }
2042 }
2043
2044 private static class exists_argsTupleScheme extends TupleScheme<exists_args> {
2045
2046 @Override
2047 public void write(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
2048 TTupleProtocol oprot = (TTupleProtocol) prot;
2049 oprot.writeBinary(struct.table);
2050 struct.get.write(oprot);
2051 }
2052
2053 @Override
2054 public void read(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
2055 TTupleProtocol iprot = (TTupleProtocol) prot;
2056 struct.table = iprot.readBinary();
2057 struct.setTableIsSet(true);
2058 struct.get = new TGet();
2059 struct.get.read(iprot);
2060 struct.setGetIsSet(true);
2061 }
2062 }
2063
2064 }
2065
2066 public static class exists_result implements org.apache.thrift.TBase<exists_result, exists_result._Fields>, java.io.Serializable, Cloneable {
2067 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_result");
2068
2069 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);
2070 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);
2071
2072 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2073 static {
2074 schemes.put(StandardScheme.class, new exists_resultStandardSchemeFactory());
2075 schemes.put(TupleScheme.class, new exists_resultTupleSchemeFactory());
2076 }
2077
2078 public boolean success;
2079 public TIOError io;
2080
2081
2082 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2083 SUCCESS((short)0, "success"),
2084 IO((short)1, "io");
2085
2086 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2087
2088 static {
2089 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2090 byName.put(field.getFieldName(), field);
2091 }
2092 }
2093
2094
2095
2096
2097 public static _Fields findByThriftId(int fieldId) {
2098 switch(fieldId) {
2099 case 0:
2100 return SUCCESS;
2101 case 1:
2102 return IO;
2103 default:
2104 return null;
2105 }
2106 }
2107
2108
2109
2110
2111
2112 public static _Fields findByThriftIdOrThrow(int fieldId) {
2113 _Fields fields = findByThriftId(fieldId);
2114 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2115 return fields;
2116 }
2117
2118
2119
2120
2121 public static _Fields findByName(String name) {
2122 return byName.get(name);
2123 }
2124
2125 private final short _thriftId;
2126 private final String _fieldName;
2127
2128 _Fields(short thriftId, String fieldName) {
2129 _thriftId = thriftId;
2130 _fieldName = fieldName;
2131 }
2132
2133 public short getThriftFieldId() {
2134 return _thriftId;
2135 }
2136
2137 public String getFieldName() {
2138 return _fieldName;
2139 }
2140 }
2141
2142
2143 private static final int __SUCCESS_ISSET_ID = 0;
2144 private BitSet __isset_bit_vector = new BitSet(1);
2145 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2146 static {
2147 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2148 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
2149 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
2150 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
2151 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
2152 metaDataMap = Collections.unmodifiableMap(tmpMap);
2153 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_result.class, metaDataMap);
2154 }
2155
2156 public exists_result() {
2157 }
2158
2159 public exists_result(
2160 boolean success,
2161 TIOError io)
2162 {
2163 this();
2164 this.success = success;
2165 setSuccessIsSet(true);
2166 this.io = io;
2167 }
2168
2169
2170
2171
2172 public exists_result(exists_result other) {
2173 __isset_bit_vector.clear();
2174 __isset_bit_vector.or(other.__isset_bit_vector);
2175 this.success = other.success;
2176 if (other.isSetIo()) {
2177 this.io = new TIOError(other.io);
2178 }
2179 }
2180
2181 public exists_result deepCopy() {
2182 return new exists_result(this);
2183 }
2184
2185 @Override
2186 public void clear() {
2187 setSuccessIsSet(false);
2188 this.success = false;
2189 this.io = null;
2190 }
2191
2192 public boolean isSuccess() {
2193 return this.success;
2194 }
2195
2196 public exists_result setSuccess(boolean success) {
2197 this.success = success;
2198 setSuccessIsSet(true);
2199 return this;
2200 }
2201
2202 public void unsetSuccess() {
2203 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
2204 }
2205
2206
2207 public boolean isSetSuccess() {
2208 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
2209 }
2210
2211 public void setSuccessIsSet(boolean value) {
2212 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
2213 }
2214
2215 public TIOError getIo() {
2216 return this.io;
2217 }
2218
2219 public exists_result setIo(TIOError io) {
2220 this.io = io;
2221 return this;
2222 }
2223
2224 public void unsetIo() {
2225 this.io = null;
2226 }
2227
2228
2229 public boolean isSetIo() {
2230 return this.io != null;
2231 }
2232
2233 public void setIoIsSet(boolean value) {
2234 if (!value) {
2235 this.io = null;
2236 }
2237 }
2238
2239 public void setFieldValue(_Fields field, Object value) {
2240 switch (field) {
2241 case SUCCESS:
2242 if (value == null) {
2243 unsetSuccess();
2244 } else {
2245 setSuccess((Boolean)value);
2246 }
2247 break;
2248
2249 case IO:
2250 if (value == null) {
2251 unsetIo();
2252 } else {
2253 setIo((TIOError)value);
2254 }
2255 break;
2256
2257 }
2258 }
2259
2260 public Object getFieldValue(_Fields field) {
2261 switch (field) {
2262 case SUCCESS:
2263 return Boolean.valueOf(isSuccess());
2264
2265 case IO:
2266 return getIo();
2267
2268 }
2269 throw new IllegalStateException();
2270 }
2271
2272
2273 public boolean isSet(_Fields field) {
2274 if (field == null) {
2275 throw new IllegalArgumentException();
2276 }
2277
2278 switch (field) {
2279 case SUCCESS:
2280 return isSetSuccess();
2281 case IO:
2282 return isSetIo();
2283 }
2284 throw new IllegalStateException();
2285 }
2286
2287 @Override
2288 public boolean equals(Object that) {
2289 if (that == null)
2290 return false;
2291 if (that instanceof exists_result)
2292 return this.equals((exists_result)that);
2293 return false;
2294 }
2295
2296 public boolean equals(exists_result that) {
2297 if (that == null)
2298 return false;
2299
2300 boolean this_present_success = true;
2301 boolean that_present_success = true;
2302 if (this_present_success || that_present_success) {
2303 if (!(this_present_success && that_present_success))
2304 return false;
2305 if (this.success != that.success)
2306 return false;
2307 }
2308
2309 boolean this_present_io = true && this.isSetIo();
2310 boolean that_present_io = true && that.isSetIo();
2311 if (this_present_io || that_present_io) {
2312 if (!(this_present_io && that_present_io))
2313 return false;
2314 if (!this.io.equals(that.io))
2315 return false;
2316 }
2317
2318 return true;
2319 }
2320
2321 @Override
2322 public int hashCode() {
2323 return 0;
2324 }
2325
2326 public int compareTo(exists_result other) {
2327 if (!getClass().equals(other.getClass())) {
2328 return getClass().getName().compareTo(other.getClass().getName());
2329 }
2330
2331 int lastComparison = 0;
2332 exists_result typedOther = (exists_result)other;
2333
2334 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
2335 if (lastComparison != 0) {
2336 return lastComparison;
2337 }
2338 if (isSetSuccess()) {
2339 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
2340 if (lastComparison != 0) {
2341 return lastComparison;
2342 }
2343 }
2344 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
2345 if (lastComparison != 0) {
2346 return lastComparison;
2347 }
2348 if (isSetIo()) {
2349 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
2350 if (lastComparison != 0) {
2351 return lastComparison;
2352 }
2353 }
2354 return 0;
2355 }
2356
2357 public _Fields fieldForId(int fieldId) {
2358 return _Fields.findByThriftId(fieldId);
2359 }
2360
2361 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2362 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2363 }
2364
2365 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2366 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2367 }
2368
2369 @Override
2370 public String toString() {
2371 StringBuilder sb = new StringBuilder("exists_result(");
2372 boolean first = true;
2373
2374 sb.append("success:");
2375 sb.append(this.success);
2376 first = false;
2377 if (!first) sb.append(", ");
2378 sb.append("io:");
2379 if (this.io == null) {
2380 sb.append("null");
2381 } else {
2382 sb.append(this.io);
2383 }
2384 first = false;
2385 sb.append(")");
2386 return sb.toString();
2387 }
2388
2389 public void validate() throws org.apache.thrift.TException {
2390
2391 }
2392
2393 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2394 try {
2395 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2396 } catch (org.apache.thrift.TException te) {
2397 throw new java.io.IOException(te);
2398 }
2399 }
2400
2401 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2402 try {
2403
2404 __isset_bit_vector = new BitSet(1);
2405 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2406 } catch (org.apache.thrift.TException te) {
2407 throw new java.io.IOException(te);
2408 }
2409 }
2410
2411 private static class exists_resultStandardSchemeFactory implements SchemeFactory {
2412 public exists_resultStandardScheme getScheme() {
2413 return new exists_resultStandardScheme();
2414 }
2415 }
2416
2417 private static class exists_resultStandardScheme extends StandardScheme<exists_result> {
2418
2419 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_result struct) throws org.apache.thrift.TException {
2420 org.apache.thrift.protocol.TField schemeField;
2421 iprot.readStructBegin();
2422 while (true)
2423 {
2424 schemeField = iprot.readFieldBegin();
2425 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2426 break;
2427 }
2428 switch (schemeField.id) {
2429 case 0:
2430 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
2431 struct.success = iprot.readBool();
2432 struct.setSuccessIsSet(true);
2433 } else {
2434 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2435 }
2436 break;
2437 case 1:
2438 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2439 struct.io = new TIOError();
2440 struct.io.read(iprot);
2441 struct.setIoIsSet(true);
2442 } else {
2443 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2444 }
2445 break;
2446 default:
2447 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2448 }
2449 iprot.readFieldEnd();
2450 }
2451 iprot.readStructEnd();
2452
2453
2454 struct.validate();
2455 }
2456
2457 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_result struct) throws org.apache.thrift.TException {
2458 struct.validate();
2459
2460 oprot.writeStructBegin(STRUCT_DESC);
2461 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
2462 oprot.writeBool(struct.success);
2463 oprot.writeFieldEnd();
2464 if (struct.io != null) {
2465 oprot.writeFieldBegin(IO_FIELD_DESC);
2466 struct.io.write(oprot);
2467 oprot.writeFieldEnd();
2468 }
2469 oprot.writeFieldStop();
2470 oprot.writeStructEnd();
2471 }
2472
2473 }
2474
2475 private static class exists_resultTupleSchemeFactory implements SchemeFactory {
2476 public exists_resultTupleScheme getScheme() {
2477 return new exists_resultTupleScheme();
2478 }
2479 }
2480
2481 private static class exists_resultTupleScheme extends TupleScheme<exists_result> {
2482
2483 @Override
2484 public void write(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2485 TTupleProtocol oprot = (TTupleProtocol) prot;
2486 BitSet optionals = new BitSet();
2487 if (struct.isSetSuccess()) {
2488 optionals.set(0);
2489 }
2490 if (struct.isSetIo()) {
2491 optionals.set(1);
2492 }
2493 oprot.writeBitSet(optionals, 2);
2494 if (struct.isSetSuccess()) {
2495 oprot.writeBool(struct.success);
2496 }
2497 if (struct.isSetIo()) {
2498 struct.io.write(oprot);
2499 }
2500 }
2501
2502 @Override
2503 public void read(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2504 TTupleProtocol iprot = (TTupleProtocol) prot;
2505 BitSet incoming = iprot.readBitSet(2);
2506 if (incoming.get(0)) {
2507 struct.success = iprot.readBool();
2508 struct.setSuccessIsSet(true);
2509 }
2510 if (incoming.get(1)) {
2511 struct.io = new TIOError();
2512 struct.io.read(iprot);
2513 struct.setIoIsSet(true);
2514 }
2515 }
2516 }
2517
2518 }
2519
2520 public static class get_args implements org.apache.thrift.TBase<get_args, get_args._Fields>, java.io.Serializable, Cloneable {
2521 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_args");
2522
2523 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);
2524 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);
2525
2526 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2527 static {
2528 schemes.put(StandardScheme.class, new get_argsStandardSchemeFactory());
2529 schemes.put(TupleScheme.class, new get_argsTupleSchemeFactory());
2530 }
2531
2532
2533
2534
2535 public ByteBuffer table;
2536
2537
2538
2539 public TGet get;
2540
2541
2542 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2543
2544
2545
2546 TABLE((short)1, "table"),
2547
2548
2549
2550 GET((short)2, "get");
2551
2552 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2553
2554 static {
2555 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2556 byName.put(field.getFieldName(), field);
2557 }
2558 }
2559
2560
2561
2562
2563 public static _Fields findByThriftId(int fieldId) {
2564 switch(fieldId) {
2565 case 1:
2566 return TABLE;
2567 case 2:
2568 return GET;
2569 default:
2570 return null;
2571 }
2572 }
2573
2574
2575
2576
2577
2578 public static _Fields findByThriftIdOrThrow(int fieldId) {
2579 _Fields fields = findByThriftId(fieldId);
2580 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2581 return fields;
2582 }
2583
2584
2585
2586
2587 public static _Fields findByName(String name) {
2588 return byName.get(name);
2589 }
2590
2591 private final short _thriftId;
2592 private final String _fieldName;
2593
2594 _Fields(short thriftId, String fieldName) {
2595 _thriftId = thriftId;
2596 _fieldName = fieldName;
2597 }
2598
2599 public short getThriftFieldId() {
2600 return _thriftId;
2601 }
2602
2603 public String getFieldName() {
2604 return _fieldName;
2605 }
2606 }
2607
2608
2609 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2610 static {
2611 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2612 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
2613 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
2614 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
2615 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
2616 metaDataMap = Collections.unmodifiableMap(tmpMap);
2617 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
2618 }
2619
2620 public get_args() {
2621 }
2622
2623 public get_args(
2624 ByteBuffer table,
2625 TGet get)
2626 {
2627 this();
2628 this.table = table;
2629 this.get = get;
2630 }
2631
2632
2633
2634
2635 public get_args(get_args other) {
2636 if (other.isSetTable()) {
2637 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
2638 ;
2639 }
2640 if (other.isSetGet()) {
2641 this.get = new TGet(other.get);
2642 }
2643 }
2644
2645 public get_args deepCopy() {
2646 return new get_args(this);
2647 }
2648
2649 @Override
2650 public void clear() {
2651 this.table = null;
2652 this.get = null;
2653 }
2654
2655
2656
2657
2658 public byte[] getTable() {
2659 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
2660 return table == null ? null : table.array();
2661 }
2662
2663 public ByteBuffer bufferForTable() {
2664 return table;
2665 }
2666
2667
2668
2669
2670 public get_args setTable(byte[] table) {
2671 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
2672 return this;
2673 }
2674
2675 public get_args setTable(ByteBuffer table) {
2676 this.table = table;
2677 return this;
2678 }
2679
2680 public void unsetTable() {
2681 this.table = null;
2682 }
2683
2684
2685 public boolean isSetTable() {
2686 return this.table != null;
2687 }
2688
2689 public void setTableIsSet(boolean value) {
2690 if (!value) {
2691 this.table = null;
2692 }
2693 }
2694
2695
2696
2697
2698 public TGet getGet() {
2699 return this.get;
2700 }
2701
2702
2703
2704
2705 public get_args setGet(TGet get) {
2706 this.get = get;
2707 return this;
2708 }
2709
2710 public void unsetGet() {
2711 this.get = null;
2712 }
2713
2714
2715 public boolean isSetGet() {
2716 return this.get != null;
2717 }
2718
2719 public void setGetIsSet(boolean value) {
2720 if (!value) {
2721 this.get = null;
2722 }
2723 }
2724
2725 public void setFieldValue(_Fields field, Object value) {
2726 switch (field) {
2727 case TABLE:
2728 if (value == null) {
2729 unsetTable();
2730 } else {
2731 setTable((ByteBuffer)value);
2732 }
2733 break;
2734
2735 case GET:
2736 if (value == null) {
2737 unsetGet();
2738 } else {
2739 setGet((TGet)value);
2740 }
2741 break;
2742
2743 }
2744 }
2745
2746 public Object getFieldValue(_Fields field) {
2747 switch (field) {
2748 case TABLE:
2749 return getTable();
2750
2751 case GET:
2752 return getGet();
2753
2754 }
2755 throw new IllegalStateException();
2756 }
2757
2758
2759 public boolean isSet(_Fields field) {
2760 if (field == null) {
2761 throw new IllegalArgumentException();
2762 }
2763
2764 switch (field) {
2765 case TABLE:
2766 return isSetTable();
2767 case GET:
2768 return isSetGet();
2769 }
2770 throw new IllegalStateException();
2771 }
2772
2773 @Override
2774 public boolean equals(Object that) {
2775 if (that == null)
2776 return false;
2777 if (that instanceof get_args)
2778 return this.equals((get_args)that);
2779 return false;
2780 }
2781
2782 public boolean equals(get_args that) {
2783 if (that == null)
2784 return false;
2785
2786 boolean this_present_table = true && this.isSetTable();
2787 boolean that_present_table = true && that.isSetTable();
2788 if (this_present_table || that_present_table) {
2789 if (!(this_present_table && that_present_table))
2790 return false;
2791 if (!this.table.equals(that.table))
2792 return false;
2793 }
2794
2795 boolean this_present_get = true && this.isSetGet();
2796 boolean that_present_get = true && that.isSetGet();
2797 if (this_present_get || that_present_get) {
2798 if (!(this_present_get && that_present_get))
2799 return false;
2800 if (!this.get.equals(that.get))
2801 return false;
2802 }
2803
2804 return true;
2805 }
2806
2807 @Override
2808 public int hashCode() {
2809 return 0;
2810 }
2811
2812 public int compareTo(get_args other) {
2813 if (!getClass().equals(other.getClass())) {
2814 return getClass().getName().compareTo(other.getClass().getName());
2815 }
2816
2817 int lastComparison = 0;
2818 get_args typedOther = (get_args)other;
2819
2820 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
2821 if (lastComparison != 0) {
2822 return lastComparison;
2823 }
2824 if (isSetTable()) {
2825 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
2826 if (lastComparison != 0) {
2827 return lastComparison;
2828 }
2829 }
2830 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
2831 if (lastComparison != 0) {
2832 return lastComparison;
2833 }
2834 if (isSetGet()) {
2835 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
2836 if (lastComparison != 0) {
2837 return lastComparison;
2838 }
2839 }
2840 return 0;
2841 }
2842
2843 public _Fields fieldForId(int fieldId) {
2844 return _Fields.findByThriftId(fieldId);
2845 }
2846
2847 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2848 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2849 }
2850
2851 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2852 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2853 }
2854
2855 @Override
2856 public String toString() {
2857 StringBuilder sb = new StringBuilder("get_args(");
2858 boolean first = true;
2859
2860 sb.append("table:");
2861 if (this.table == null) {
2862 sb.append("null");
2863 } else {
2864 org.apache.thrift.TBaseHelper.toString(this.table, sb);
2865 }
2866 first = false;
2867 if (!first) sb.append(", ");
2868 sb.append("get:");
2869 if (this.get == null) {
2870 sb.append("null");
2871 } else {
2872 sb.append(this.get);
2873 }
2874 first = false;
2875 sb.append(")");
2876 return sb.toString();
2877 }
2878
2879 public void validate() throws org.apache.thrift.TException {
2880
2881 if (table == null) {
2882 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
2883 }
2884 if (get == null) {
2885 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
2886 }
2887 }
2888
2889 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2890 try {
2891 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2892 } catch (org.apache.thrift.TException te) {
2893 throw new java.io.IOException(te);
2894 }
2895 }
2896
2897 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2898 try {
2899 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2900 } catch (org.apache.thrift.TException te) {
2901 throw new java.io.IOException(te);
2902 }
2903 }
2904
2905 private static class get_argsStandardSchemeFactory implements SchemeFactory {
2906 public get_argsStandardScheme getScheme() {
2907 return new get_argsStandardScheme();
2908 }
2909 }
2910
2911 private static class get_argsStandardScheme extends StandardScheme<get_args> {
2912
2913 public void read(org.apache.thrift.protocol.TProtocol iprot, get_args struct) throws org.apache.thrift.TException {
2914 org.apache.thrift.protocol.TField schemeField;
2915 iprot.readStructBegin();
2916 while (true)
2917 {
2918 schemeField = iprot.readFieldBegin();
2919 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2920 break;
2921 }
2922 switch (schemeField.id) {
2923 case 1:
2924 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
2925 struct.table = iprot.readBinary();
2926 struct.setTableIsSet(true);
2927 } else {
2928 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2929 }
2930 break;
2931 case 2:
2932 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2933 struct.get = new TGet();
2934 struct.get.read(iprot);
2935 struct.setGetIsSet(true);
2936 } else {
2937 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2938 }
2939 break;
2940 default:
2941 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2942 }
2943 iprot.readFieldEnd();
2944 }
2945 iprot.readStructEnd();
2946
2947
2948 struct.validate();
2949 }
2950
2951 public void write(org.apache.thrift.protocol.TProtocol oprot, get_args struct) throws org.apache.thrift.TException {
2952 struct.validate();
2953
2954 oprot.writeStructBegin(STRUCT_DESC);
2955 if (struct.table != null) {
2956 oprot.writeFieldBegin(TABLE_FIELD_DESC);
2957 oprot.writeBinary(struct.table);
2958 oprot.writeFieldEnd();
2959 }
2960 if (struct.get != null) {
2961 oprot.writeFieldBegin(GET_FIELD_DESC);
2962 struct.get.write(oprot);
2963 oprot.writeFieldEnd();
2964 }
2965 oprot.writeFieldStop();
2966 oprot.writeStructEnd();
2967 }
2968
2969 }
2970
2971 private static class get_argsTupleSchemeFactory implements SchemeFactory {
2972 public get_argsTupleScheme getScheme() {
2973 return new get_argsTupleScheme();
2974 }
2975 }
2976
2977 private static class get_argsTupleScheme extends TupleScheme<get_args> {
2978
2979 @Override
2980 public void write(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2981 TTupleProtocol oprot = (TTupleProtocol) prot;
2982 oprot.writeBinary(struct.table);
2983 struct.get.write(oprot);
2984 }
2985
2986 @Override
2987 public void read(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2988 TTupleProtocol iprot = (TTupleProtocol) prot;
2989 struct.table = iprot.readBinary();
2990 struct.setTableIsSet(true);
2991 struct.get = new TGet();
2992 struct.get.read(iprot);
2993 struct.setGetIsSet(true);
2994 }
2995 }
2996
2997 }
2998
2999 public static class get_result implements org.apache.thrift.TBase<get_result, get_result._Fields>, java.io.Serializable, Cloneable {
3000 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_result");
3001
3002 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);
3003 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);
3004
3005 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3006 static {
3007 schemes.put(StandardScheme.class, new get_resultStandardSchemeFactory());
3008 schemes.put(TupleScheme.class, new get_resultTupleSchemeFactory());
3009 }
3010
3011 public TResult success;
3012 public TIOError io;
3013
3014
3015 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3016 SUCCESS((short)0, "success"),
3017 IO((short)1, "io");
3018
3019 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3020
3021 static {
3022 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3023 byName.put(field.getFieldName(), field);
3024 }
3025 }
3026
3027
3028
3029
3030 public static _Fields findByThriftId(int fieldId) {
3031 switch(fieldId) {
3032 case 0:
3033 return SUCCESS;
3034 case 1:
3035 return IO;
3036 default:
3037 return null;
3038 }
3039 }
3040
3041
3042
3043
3044
3045 public static _Fields findByThriftIdOrThrow(int fieldId) {
3046 _Fields fields = findByThriftId(fieldId);
3047 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3048 return fields;
3049 }
3050
3051
3052
3053
3054 public static _Fields findByName(String name) {
3055 return byName.get(name);
3056 }
3057
3058 private final short _thriftId;
3059 private final String _fieldName;
3060
3061 _Fields(short thriftId, String fieldName) {
3062 _thriftId = thriftId;
3063 _fieldName = fieldName;
3064 }
3065
3066 public short getThriftFieldId() {
3067 return _thriftId;
3068 }
3069
3070 public String getFieldName() {
3071 return _fieldName;
3072 }
3073 }
3074
3075
3076 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3077 static {
3078 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3079 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
3080 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
3081 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
3082 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
3083 metaDataMap = Collections.unmodifiableMap(tmpMap);
3084 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
3085 }
3086
3087 public get_result() {
3088 }
3089
3090 public get_result(
3091 TResult success,
3092 TIOError io)
3093 {
3094 this();
3095 this.success = success;
3096 this.io = io;
3097 }
3098
3099
3100
3101
3102 public get_result(get_result other) {
3103 if (other.isSetSuccess()) {
3104 this.success = new TResult(other.success);
3105 }
3106 if (other.isSetIo()) {
3107 this.io = new TIOError(other.io);
3108 }
3109 }
3110
3111 public get_result deepCopy() {
3112 return new get_result(this);
3113 }
3114
3115 @Override
3116 public void clear() {
3117 this.success = null;
3118 this.io = null;
3119 }
3120
3121 public TResult getSuccess() {
3122 return this.success;
3123 }
3124
3125 public get_result setSuccess(TResult success) {
3126 this.success = success;
3127 return this;
3128 }
3129
3130 public void unsetSuccess() {
3131 this.success = null;
3132 }
3133
3134
3135 public boolean isSetSuccess() {
3136 return this.success != null;
3137 }
3138
3139 public void setSuccessIsSet(boolean value) {
3140 if (!value) {
3141 this.success = null;
3142 }
3143 }
3144
3145 public TIOError getIo() {
3146 return this.io;
3147 }
3148
3149 public get_result setIo(TIOError io) {
3150 this.io = io;
3151 return this;
3152 }
3153
3154 public void unsetIo() {
3155 this.io = null;
3156 }
3157
3158
3159 public boolean isSetIo() {
3160 return this.io != null;
3161 }
3162
3163 public void setIoIsSet(boolean value) {
3164 if (!value) {
3165 this.io = null;
3166 }
3167 }
3168
3169 public void setFieldValue(_Fields field, Object value) {
3170 switch (field) {
3171 case SUCCESS:
3172 if (value == null) {
3173 unsetSuccess();
3174 } else {
3175 setSuccess((TResult)value);
3176 }
3177 break;
3178
3179 case IO:
3180 if (value == null) {
3181 unsetIo();
3182 } else {
3183 setIo((TIOError)value);
3184 }
3185 break;
3186
3187 }
3188 }
3189
3190 public Object getFieldValue(_Fields field) {
3191 switch (field) {
3192 case SUCCESS:
3193 return getSuccess();
3194
3195 case IO:
3196 return getIo();
3197
3198 }
3199 throw new IllegalStateException();
3200 }
3201
3202
3203 public boolean isSet(_Fields field) {
3204 if (field == null) {
3205 throw new IllegalArgumentException();
3206 }
3207
3208 switch (field) {
3209 case SUCCESS:
3210 return isSetSuccess();
3211 case IO:
3212 return isSetIo();
3213 }
3214 throw new IllegalStateException();
3215 }
3216
3217 @Override
3218 public boolean equals(Object that) {
3219 if (that == null)
3220 return false;
3221 if (that instanceof get_result)
3222 return this.equals((get_result)that);
3223 return false;
3224 }
3225
3226 public boolean equals(get_result that) {
3227 if (that == null)
3228 return false;
3229
3230 boolean this_present_success = true && this.isSetSuccess();
3231 boolean that_present_success = true && that.isSetSuccess();
3232 if (this_present_success || that_present_success) {
3233 if (!(this_present_success && that_present_success))
3234 return false;
3235 if (!this.success.equals(that.success))
3236 return false;
3237 }
3238
3239 boolean this_present_io = true && this.isSetIo();
3240 boolean that_present_io = true && that.isSetIo();
3241 if (this_present_io || that_present_io) {
3242 if (!(this_present_io && that_present_io))
3243 return false;
3244 if (!this.io.equals(that.io))
3245 return false;
3246 }
3247
3248 return true;
3249 }
3250
3251 @Override
3252 public int hashCode() {
3253 return 0;
3254 }
3255
3256 public int compareTo(get_result other) {
3257 if (!getClass().equals(other.getClass())) {
3258 return getClass().getName().compareTo(other.getClass().getName());
3259 }
3260
3261 int lastComparison = 0;
3262 get_result typedOther = (get_result)other;
3263
3264 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
3265 if (lastComparison != 0) {
3266 return lastComparison;
3267 }
3268 if (isSetSuccess()) {
3269 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
3270 if (lastComparison != 0) {
3271 return lastComparison;
3272 }
3273 }
3274 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
3275 if (lastComparison != 0) {
3276 return lastComparison;
3277 }
3278 if (isSetIo()) {
3279 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
3280 if (lastComparison != 0) {
3281 return lastComparison;
3282 }
3283 }
3284 return 0;
3285 }
3286
3287 public _Fields fieldForId(int fieldId) {
3288 return _Fields.findByThriftId(fieldId);
3289 }
3290
3291 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3292 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3293 }
3294
3295 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3296 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3297 }
3298
3299 @Override
3300 public String toString() {
3301 StringBuilder sb = new StringBuilder("get_result(");
3302 boolean first = true;
3303
3304 sb.append("success:");
3305 if (this.success == null) {
3306 sb.append("null");
3307 } else {
3308 sb.append(this.success);
3309 }
3310 first = false;
3311 if (!first) sb.append(", ");
3312 sb.append("io:");
3313 if (this.io == null) {
3314 sb.append("null");
3315 } else {
3316 sb.append(this.io);
3317 }
3318 first = false;
3319 sb.append(")");
3320 return sb.toString();
3321 }
3322
3323 public void validate() throws org.apache.thrift.TException {
3324
3325 }
3326
3327 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3328 try {
3329 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3330 } catch (org.apache.thrift.TException te) {
3331 throw new java.io.IOException(te);
3332 }
3333 }
3334
3335 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3336 try {
3337 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3338 } catch (org.apache.thrift.TException te) {
3339 throw new java.io.IOException(te);
3340 }
3341 }
3342
3343 private static class get_resultStandardSchemeFactory implements SchemeFactory {
3344 public get_resultStandardScheme getScheme() {
3345 return new get_resultStandardScheme();
3346 }
3347 }
3348
3349 private static class get_resultStandardScheme extends StandardScheme<get_result> {
3350
3351 public void read(org.apache.thrift.protocol.TProtocol iprot, get_result struct) throws org.apache.thrift.TException {
3352 org.apache.thrift.protocol.TField schemeField;
3353 iprot.readStructBegin();
3354 while (true)
3355 {
3356 schemeField = iprot.readFieldBegin();
3357 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3358 break;
3359 }
3360 switch (schemeField.id) {
3361 case 0:
3362 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3363 struct.success = new TResult();
3364 struct.success.read(iprot);
3365 struct.setSuccessIsSet(true);
3366 } else {
3367 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3368 }
3369 break;
3370 case 1:
3371 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3372 struct.io = new TIOError();
3373 struct.io.read(iprot);
3374 struct.setIoIsSet(true);
3375 } else {
3376 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3377 }
3378 break;
3379 default:
3380 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3381 }
3382 iprot.readFieldEnd();
3383 }
3384 iprot.readStructEnd();
3385
3386
3387 struct.validate();
3388 }
3389
3390 public void write(org.apache.thrift.protocol.TProtocol oprot, get_result struct) throws org.apache.thrift.TException {
3391 struct.validate();
3392
3393 oprot.writeStructBegin(STRUCT_DESC);
3394 if (struct.success != null) {
3395 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3396 struct.success.write(oprot);
3397 oprot.writeFieldEnd();
3398 }
3399 if (struct.io != null) {
3400 oprot.writeFieldBegin(IO_FIELD_DESC);
3401 struct.io.write(oprot);
3402 oprot.writeFieldEnd();
3403 }
3404 oprot.writeFieldStop();
3405 oprot.writeStructEnd();
3406 }
3407
3408 }
3409
3410 private static class get_resultTupleSchemeFactory implements SchemeFactory {
3411 public get_resultTupleScheme getScheme() {
3412 return new get_resultTupleScheme();
3413 }
3414 }
3415
3416 private static class get_resultTupleScheme extends TupleScheme<get_result> {
3417
3418 @Override
3419 public void write(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3420 TTupleProtocol oprot = (TTupleProtocol) prot;
3421 BitSet optionals = new BitSet();
3422 if (struct.isSetSuccess()) {
3423 optionals.set(0);
3424 }
3425 if (struct.isSetIo()) {
3426 optionals.set(1);
3427 }
3428 oprot.writeBitSet(optionals, 2);
3429 if (struct.isSetSuccess()) {
3430 struct.success.write(oprot);
3431 }
3432 if (struct.isSetIo()) {
3433 struct.io.write(oprot);
3434 }
3435 }
3436
3437 @Override
3438 public void read(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3439 TTupleProtocol iprot = (TTupleProtocol) prot;
3440 BitSet incoming = iprot.readBitSet(2);
3441 if (incoming.get(0)) {
3442 struct.success = new TResult();
3443 struct.success.read(iprot);
3444 struct.setSuccessIsSet(true);
3445 }
3446 if (incoming.get(1)) {
3447 struct.io = new TIOError();
3448 struct.io.read(iprot);
3449 struct.setIoIsSet(true);
3450 }
3451 }
3452 }
3453
3454 }
3455
3456 public static class getMultiple_args implements org.apache.thrift.TBase<getMultiple_args, getMultiple_args._Fields>, java.io.Serializable, Cloneable {
3457 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_args");
3458
3459 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);
3460 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);
3461
3462 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3463 static {
3464 schemes.put(StandardScheme.class, new getMultiple_argsStandardSchemeFactory());
3465 schemes.put(TupleScheme.class, new getMultiple_argsTupleSchemeFactory());
3466 }
3467
3468
3469
3470
3471 public ByteBuffer table;
3472
3473
3474
3475
3476
3477 public List<TGet> gets;
3478
3479
3480 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3481
3482
3483
3484 TABLE((short)1, "table"),
3485
3486
3487
3488
3489
3490 GETS((short)2, "gets");
3491
3492 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3493
3494 static {
3495 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3496 byName.put(field.getFieldName(), field);
3497 }
3498 }
3499
3500
3501
3502
3503 public static _Fields findByThriftId(int fieldId) {
3504 switch(fieldId) {
3505 case 1:
3506 return TABLE;
3507 case 2:
3508 return GETS;
3509 default:
3510 return null;
3511 }
3512 }
3513
3514
3515
3516
3517
3518 public static _Fields findByThriftIdOrThrow(int fieldId) {
3519 _Fields fields = findByThriftId(fieldId);
3520 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3521 return fields;
3522 }
3523
3524
3525
3526
3527 public static _Fields findByName(String name) {
3528 return byName.get(name);
3529 }
3530
3531 private final short _thriftId;
3532 private final String _fieldName;
3533
3534 _Fields(short thriftId, String fieldName) {
3535 _thriftId = thriftId;
3536 _fieldName = fieldName;
3537 }
3538
3539 public short getThriftFieldId() {
3540 return _thriftId;
3541 }
3542
3543 public String getFieldName() {
3544 return _fieldName;
3545 }
3546 }
3547
3548
3549 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3550 static {
3551 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3552 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
3553 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
3554 tmpMap.put(_Fields.GETS, new org.apache.thrift.meta_data.FieldMetaData("gets", org.apache.thrift.TFieldRequirementType.REQUIRED,
3555 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
3556 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class))));
3557 metaDataMap = Collections.unmodifiableMap(tmpMap);
3558 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_args.class, metaDataMap);
3559 }
3560
3561 public getMultiple_args() {
3562 }
3563
3564 public getMultiple_args(
3565 ByteBuffer table,
3566 List<TGet> gets)
3567 {
3568 this();
3569 this.table = table;
3570 this.gets = gets;
3571 }
3572
3573
3574
3575
3576 public getMultiple_args(getMultiple_args other) {
3577 if (other.isSetTable()) {
3578 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
3579 ;
3580 }
3581 if (other.isSetGets()) {
3582 List<TGet> __this__gets = new ArrayList<TGet>();
3583 for (TGet other_element : other.gets) {
3584 __this__gets.add(new TGet(other_element));
3585 }
3586 this.gets = __this__gets;
3587 }
3588 }
3589
3590 public getMultiple_args deepCopy() {
3591 return new getMultiple_args(this);
3592 }
3593
3594 @Override
3595 public void clear() {
3596 this.table = null;
3597 this.gets = null;
3598 }
3599
3600
3601
3602
3603 public byte[] getTable() {
3604 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
3605 return table == null ? null : table.array();
3606 }
3607
3608 public ByteBuffer bufferForTable() {
3609 return table;
3610 }
3611
3612
3613
3614
3615 public getMultiple_args setTable(byte[] table) {
3616 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
3617 return this;
3618 }
3619
3620 public getMultiple_args setTable(ByteBuffer table) {
3621 this.table = table;
3622 return this;
3623 }
3624
3625 public void unsetTable() {
3626 this.table = null;
3627 }
3628
3629
3630 public boolean isSetTable() {
3631 return this.table != null;
3632 }
3633
3634 public void setTableIsSet(boolean value) {
3635 if (!value) {
3636 this.table = null;
3637 }
3638 }
3639
3640 public int getGetsSize() {
3641 return (this.gets == null) ? 0 : this.gets.size();
3642 }
3643
3644 public java.util.Iterator<TGet> getGetsIterator() {
3645 return (this.gets == null) ? null : this.gets.iterator();
3646 }
3647
3648 public void addToGets(TGet elem) {
3649 if (this.gets == null) {
3650 this.gets = new ArrayList<TGet>();
3651 }
3652 this.gets.add(elem);
3653 }
3654
3655
3656
3657
3658
3659
3660 public List<TGet> getGets() {
3661 return this.gets;
3662 }
3663
3664
3665
3666
3667
3668
3669 public getMultiple_args setGets(List<TGet> gets) {
3670 this.gets = gets;
3671 return this;
3672 }
3673
3674 public void unsetGets() {
3675 this.gets = null;
3676 }
3677
3678
3679 public boolean isSetGets() {
3680 return this.gets != null;
3681 }
3682
3683 public void setGetsIsSet(boolean value) {
3684 if (!value) {
3685 this.gets = null;
3686 }
3687 }
3688
3689 public void setFieldValue(_Fields field, Object value) {
3690 switch (field) {
3691 case TABLE:
3692 if (value == null) {
3693 unsetTable();
3694 } else {
3695 setTable((ByteBuffer)value);
3696 }
3697 break;
3698
3699 case GETS:
3700 if (value == null) {
3701 unsetGets();
3702 } else {
3703 setGets((List<TGet>)value);
3704 }
3705 break;
3706
3707 }
3708 }
3709
3710 public Object getFieldValue(_Fields field) {
3711 switch (field) {
3712 case TABLE:
3713 return getTable();
3714
3715 case GETS:
3716 return getGets();
3717
3718 }
3719 throw new IllegalStateException();
3720 }
3721
3722
3723 public boolean isSet(_Fields field) {
3724 if (field == null) {
3725 throw new IllegalArgumentException();
3726 }
3727
3728 switch (field) {
3729 case TABLE:
3730 return isSetTable();
3731 case GETS:
3732 return isSetGets();
3733 }
3734 throw new IllegalStateException();
3735 }
3736
3737 @Override
3738 public boolean equals(Object that) {
3739 if (that == null)
3740 return false;
3741 if (that instanceof getMultiple_args)
3742 return this.equals((getMultiple_args)that);
3743 return false;
3744 }
3745
3746 public boolean equals(getMultiple_args that) {
3747 if (that == null)
3748 return false;
3749
3750 boolean this_present_table = true && this.isSetTable();
3751 boolean that_present_table = true && that.isSetTable();
3752 if (this_present_table || that_present_table) {
3753 if (!(this_present_table && that_present_table))
3754 return false;
3755 if (!this.table.equals(that.table))
3756 return false;
3757 }
3758
3759 boolean this_present_gets = true && this.isSetGets();
3760 boolean that_present_gets = true && that.isSetGets();
3761 if (this_present_gets || that_present_gets) {
3762 if (!(this_present_gets && that_present_gets))
3763 return false;
3764 if (!this.gets.equals(that.gets))
3765 return false;
3766 }
3767
3768 return true;
3769 }
3770
3771 @Override
3772 public int hashCode() {
3773 return 0;
3774 }
3775
3776 public int compareTo(getMultiple_args other) {
3777 if (!getClass().equals(other.getClass())) {
3778 return getClass().getName().compareTo(other.getClass().getName());
3779 }
3780
3781 int lastComparison = 0;
3782 getMultiple_args typedOther = (getMultiple_args)other;
3783
3784 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
3785 if (lastComparison != 0) {
3786 return lastComparison;
3787 }
3788 if (isSetTable()) {
3789 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
3790 if (lastComparison != 0) {
3791 return lastComparison;
3792 }
3793 }
3794 lastComparison = Boolean.valueOf(isSetGets()).compareTo(typedOther.isSetGets());
3795 if (lastComparison != 0) {
3796 return lastComparison;
3797 }
3798 if (isSetGets()) {
3799 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gets, typedOther.gets);
3800 if (lastComparison != 0) {
3801 return lastComparison;
3802 }
3803 }
3804 return 0;
3805 }
3806
3807 public _Fields fieldForId(int fieldId) {
3808 return _Fields.findByThriftId(fieldId);
3809 }
3810
3811 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3812 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3813 }
3814
3815 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3816 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3817 }
3818
3819 @Override
3820 public String toString() {
3821 StringBuilder sb = new StringBuilder("getMultiple_args(");
3822 boolean first = true;
3823
3824 sb.append("table:");
3825 if (this.table == null) {
3826 sb.append("null");
3827 } else {
3828 org.apache.thrift.TBaseHelper.toString(this.table, sb);
3829 }
3830 first = false;
3831 if (!first) sb.append(", ");
3832 sb.append("gets:");
3833 if (this.gets == null) {
3834 sb.append("null");
3835 } else {
3836 sb.append(this.gets);
3837 }
3838 first = false;
3839 sb.append(")");
3840 return sb.toString();
3841 }
3842
3843 public void validate() throws org.apache.thrift.TException {
3844
3845 if (table == null) {
3846 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
3847 }
3848 if (gets == null) {
3849 throw new org.apache.thrift.protocol.TProtocolException("Required field 'gets' was not present! Struct: " + toString());
3850 }
3851 }
3852
3853 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3854 try {
3855 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3856 } catch (org.apache.thrift.TException te) {
3857 throw new java.io.IOException(te);
3858 }
3859 }
3860
3861 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3862 try {
3863 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3864 } catch (org.apache.thrift.TException te) {
3865 throw new java.io.IOException(te);
3866 }
3867 }
3868
3869 private static class getMultiple_argsStandardSchemeFactory implements SchemeFactory {
3870 public getMultiple_argsStandardScheme getScheme() {
3871 return new getMultiple_argsStandardScheme();
3872 }
3873 }
3874
3875 private static class getMultiple_argsStandardScheme extends StandardScheme<getMultiple_args> {
3876
3877 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_args struct) throws org.apache.thrift.TException {
3878 org.apache.thrift.protocol.TField schemeField;
3879 iprot.readStructBegin();
3880 while (true)
3881 {
3882 schemeField = iprot.readFieldBegin();
3883 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3884 break;
3885 }
3886 switch (schemeField.id) {
3887 case 1:
3888 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
3889 struct.table = iprot.readBinary();
3890 struct.setTableIsSet(true);
3891 } else {
3892 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3893 }
3894 break;
3895 case 2:
3896 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
3897 {
3898 org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
3899 struct.gets = new ArrayList<TGet>(_list96.size);
3900 for (int _i97 = 0; _i97 < _list96.size; ++_i97)
3901 {
3902 TGet _elem98;
3903 _elem98 = new TGet();
3904 _elem98.read(iprot);
3905 struct.gets.add(_elem98);
3906 }
3907 iprot.readListEnd();
3908 }
3909 struct.setGetsIsSet(true);
3910 } else {
3911 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3912 }
3913 break;
3914 default:
3915 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3916 }
3917 iprot.readFieldEnd();
3918 }
3919 iprot.readStructEnd();
3920
3921
3922 struct.validate();
3923 }
3924
3925 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_args struct) throws org.apache.thrift.TException {
3926 struct.validate();
3927
3928 oprot.writeStructBegin(STRUCT_DESC);
3929 if (struct.table != null) {
3930 oprot.writeFieldBegin(TABLE_FIELD_DESC);
3931 oprot.writeBinary(struct.table);
3932 oprot.writeFieldEnd();
3933 }
3934 if (struct.gets != null) {
3935 oprot.writeFieldBegin(GETS_FIELD_DESC);
3936 {
3937 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.gets.size()));
3938 for (TGet _iter99 : struct.gets)
3939 {
3940 _iter99.write(oprot);
3941 }
3942 oprot.writeListEnd();
3943 }
3944 oprot.writeFieldEnd();
3945 }
3946 oprot.writeFieldStop();
3947 oprot.writeStructEnd();
3948 }
3949
3950 }
3951
3952 private static class getMultiple_argsTupleSchemeFactory implements SchemeFactory {
3953 public getMultiple_argsTupleScheme getScheme() {
3954 return new getMultiple_argsTupleScheme();
3955 }
3956 }
3957
3958 private static class getMultiple_argsTupleScheme extends TupleScheme<getMultiple_args> {
3959
3960 @Override
3961 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3962 TTupleProtocol oprot = (TTupleProtocol) prot;
3963 oprot.writeBinary(struct.table);
3964 {
3965 oprot.writeI32(struct.gets.size());
3966 for (TGet _iter100 : struct.gets)
3967 {
3968 _iter100.write(oprot);
3969 }
3970 }
3971 }
3972
3973 @Override
3974 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3975 TTupleProtocol iprot = (TTupleProtocol) prot;
3976 struct.table = iprot.readBinary();
3977 struct.setTableIsSet(true);
3978 {
3979 org.apache.thrift.protocol.TList _list101 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
3980 struct.gets = new ArrayList<TGet>(_list101.size);
3981 for (int _i102 = 0; _i102 < _list101.size; ++_i102)
3982 {
3983 TGet _elem103;
3984 _elem103 = new TGet();
3985 _elem103.read(iprot);
3986 struct.gets.add(_elem103);
3987 }
3988 }
3989 struct.setGetsIsSet(true);
3990 }
3991 }
3992
3993 }
3994
3995 public static class getMultiple_result implements org.apache.thrift.TBase<getMultiple_result, getMultiple_result._Fields>, java.io.Serializable, Cloneable {
3996 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_result");
3997
3998 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);
3999 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);
4000
4001 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4002 static {
4003 schemes.put(StandardScheme.class, new getMultiple_resultStandardSchemeFactory());
4004 schemes.put(TupleScheme.class, new getMultiple_resultTupleSchemeFactory());
4005 }
4006
4007 public List<TResult> success;
4008 public TIOError io;
4009
4010
4011 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4012 SUCCESS((short)0, "success"),
4013 IO((short)1, "io");
4014
4015 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4016
4017 static {
4018 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4019 byName.put(field.getFieldName(), field);
4020 }
4021 }
4022
4023
4024
4025
4026 public static _Fields findByThriftId(int fieldId) {
4027 switch(fieldId) {
4028 case 0:
4029 return SUCCESS;
4030 case 1:
4031 return IO;
4032 default:
4033 return null;
4034 }
4035 }
4036
4037
4038
4039
4040
4041 public static _Fields findByThriftIdOrThrow(int fieldId) {
4042 _Fields fields = findByThriftId(fieldId);
4043 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4044 return fields;
4045 }
4046
4047
4048
4049
4050 public static _Fields findByName(String name) {
4051 return byName.get(name);
4052 }
4053
4054 private final short _thriftId;
4055 private final String _fieldName;
4056
4057 _Fields(short thriftId, String fieldName) {
4058 _thriftId = thriftId;
4059 _fieldName = fieldName;
4060 }
4061
4062 public short getThriftFieldId() {
4063 return _thriftId;
4064 }
4065
4066 public String getFieldName() {
4067 return _fieldName;
4068 }
4069 }
4070
4071
4072 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4073 static {
4074 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4075 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
4076 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
4077 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
4078 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
4079 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
4080 metaDataMap = Collections.unmodifiableMap(tmpMap);
4081 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_result.class, metaDataMap);
4082 }
4083
4084 public getMultiple_result() {
4085 }
4086
4087 public getMultiple_result(
4088 List<TResult> success,
4089 TIOError io)
4090 {
4091 this();
4092 this.success = success;
4093 this.io = io;
4094 }
4095
4096
4097
4098
4099 public getMultiple_result(getMultiple_result other) {
4100 if (other.isSetSuccess()) {
4101 List<TResult> __this__success = new ArrayList<TResult>();
4102 for (TResult other_element : other.success) {
4103 __this__success.add(new TResult(other_element));
4104 }
4105 this.success = __this__success;
4106 }
4107 if (other.isSetIo()) {
4108 this.io = new TIOError(other.io);
4109 }
4110 }
4111
4112 public getMultiple_result deepCopy() {
4113 return new getMultiple_result(this);
4114 }
4115
4116 @Override
4117 public void clear() {
4118 this.success = null;
4119 this.io = null;
4120 }
4121
4122 public int getSuccessSize() {
4123 return (this.success == null) ? 0 : this.success.size();
4124 }
4125
4126 public java.util.Iterator<TResult> getSuccessIterator() {
4127 return (this.success == null) ? null : this.success.iterator();
4128 }
4129
4130 public void addToSuccess(TResult elem) {
4131 if (this.success == null) {
4132 this.success = new ArrayList<TResult>();
4133 }
4134 this.success.add(elem);
4135 }
4136
4137 public List<TResult> getSuccess() {
4138 return this.success;
4139 }
4140
4141 public getMultiple_result setSuccess(List<TResult> success) {
4142 this.success = success;
4143 return this;
4144 }
4145
4146 public void unsetSuccess() {
4147 this.success = null;
4148 }
4149
4150
4151 public boolean isSetSuccess() {
4152 return this.success != null;
4153 }
4154
4155 public void setSuccessIsSet(boolean value) {
4156 if (!value) {
4157 this.success = null;
4158 }
4159 }
4160
4161 public TIOError getIo() {
4162 return this.io;
4163 }
4164
4165 public getMultiple_result setIo(TIOError io) {
4166 this.io = io;
4167 return this;
4168 }
4169
4170 public void unsetIo() {
4171 this.io = null;
4172 }
4173
4174
4175 public boolean isSetIo() {
4176 return this.io != null;
4177 }
4178
4179 public void setIoIsSet(boolean value) {
4180 if (!value) {
4181 this.io = null;
4182 }
4183 }
4184
4185 public void setFieldValue(_Fields field, Object value) {
4186 switch (field) {
4187 case SUCCESS:
4188 if (value == null) {
4189 unsetSuccess();
4190 } else {
4191 setSuccess((List<TResult>)value);
4192 }
4193 break;
4194
4195 case IO:
4196 if (value == null) {
4197 unsetIo();
4198 } else {
4199 setIo((TIOError)value);
4200 }
4201 break;
4202
4203 }
4204 }
4205
4206 public Object getFieldValue(_Fields field) {
4207 switch (field) {
4208 case SUCCESS:
4209 return getSuccess();
4210
4211 case IO:
4212 return getIo();
4213
4214 }
4215 throw new IllegalStateException();
4216 }
4217
4218
4219 public boolean isSet(_Fields field) {
4220 if (field == null) {
4221 throw new IllegalArgumentException();
4222 }
4223
4224 switch (field) {
4225 case SUCCESS:
4226 return isSetSuccess();
4227 case IO:
4228 return isSetIo();
4229 }
4230 throw new IllegalStateException();
4231 }
4232
4233 @Override
4234 public boolean equals(Object that) {
4235 if (that == null)
4236 return false;
4237 if (that instanceof getMultiple_result)
4238 return this.equals((getMultiple_result)that);
4239 return false;
4240 }
4241
4242 public boolean equals(getMultiple_result that) {
4243 if (that == null)
4244 return false;
4245
4246 boolean this_present_success = true && this.isSetSuccess();
4247 boolean that_present_success = true && that.isSetSuccess();
4248 if (this_present_success || that_present_success) {
4249 if (!(this_present_success && that_present_success))
4250 return false;
4251 if (!this.success.equals(that.success))
4252 return false;
4253 }
4254
4255 boolean this_present_io = true && this.isSetIo();
4256 boolean that_present_io = true && that.isSetIo();
4257 if (this_present_io || that_present_io) {
4258 if (!(this_present_io && that_present_io))
4259 return false;
4260 if (!this.io.equals(that.io))
4261 return false;
4262 }
4263
4264 return true;
4265 }
4266
4267 @Override
4268 public int hashCode() {
4269 return 0;
4270 }
4271
4272 public int compareTo(getMultiple_result other) {
4273 if (!getClass().equals(other.getClass())) {
4274 return getClass().getName().compareTo(other.getClass().getName());
4275 }
4276
4277 int lastComparison = 0;
4278 getMultiple_result typedOther = (getMultiple_result)other;
4279
4280 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
4281 if (lastComparison != 0) {
4282 return lastComparison;
4283 }
4284 if (isSetSuccess()) {
4285 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
4286 if (lastComparison != 0) {
4287 return lastComparison;
4288 }
4289 }
4290 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
4291 if (lastComparison != 0) {
4292 return lastComparison;
4293 }
4294 if (isSetIo()) {
4295 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
4296 if (lastComparison != 0) {
4297 return lastComparison;
4298 }
4299 }
4300 return 0;
4301 }
4302
4303 public _Fields fieldForId(int fieldId) {
4304 return _Fields.findByThriftId(fieldId);
4305 }
4306
4307 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4308 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4309 }
4310
4311 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4312 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4313 }
4314
4315 @Override
4316 public String toString() {
4317 StringBuilder sb = new StringBuilder("getMultiple_result(");
4318 boolean first = true;
4319
4320 sb.append("success:");
4321 if (this.success == null) {
4322 sb.append("null");
4323 } else {
4324 sb.append(this.success);
4325 }
4326 first = false;
4327 if (!first) sb.append(", ");
4328 sb.append("io:");
4329 if (this.io == null) {
4330 sb.append("null");
4331 } else {
4332 sb.append(this.io);
4333 }
4334 first = false;
4335 sb.append(")");
4336 return sb.toString();
4337 }
4338
4339 public void validate() throws org.apache.thrift.TException {
4340
4341 }
4342
4343 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4344 try {
4345 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4346 } catch (org.apache.thrift.TException te) {
4347 throw new java.io.IOException(te);
4348 }
4349 }
4350
4351 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4352 try {
4353 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4354 } catch (org.apache.thrift.TException te) {
4355 throw new java.io.IOException(te);
4356 }
4357 }
4358
4359 private static class getMultiple_resultStandardSchemeFactory implements SchemeFactory {
4360 public getMultiple_resultStandardScheme getScheme() {
4361 return new getMultiple_resultStandardScheme();
4362 }
4363 }
4364
4365 private static class getMultiple_resultStandardScheme extends StandardScheme<getMultiple_result> {
4366
4367 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_result struct) throws org.apache.thrift.TException {
4368 org.apache.thrift.protocol.TField schemeField;
4369 iprot.readStructBegin();
4370 while (true)
4371 {
4372 schemeField = iprot.readFieldBegin();
4373 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4374 break;
4375 }
4376 switch (schemeField.id) {
4377 case 0:
4378 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
4379 {
4380 org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();
4381 struct.success = new ArrayList<TResult>(_list104.size);
4382 for (int _i105 = 0; _i105 < _list104.size; ++_i105)
4383 {
4384 TResult _elem106;
4385 _elem106 = new TResult();
4386 _elem106.read(iprot);
4387 struct.success.add(_elem106);
4388 }
4389 iprot.readListEnd();
4390 }
4391 struct.setSuccessIsSet(true);
4392 } else {
4393 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4394 }
4395 break;
4396 case 1:
4397 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4398 struct.io = new TIOError();
4399 struct.io.read(iprot);
4400 struct.setIoIsSet(true);
4401 } else {
4402 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4403 }
4404 break;
4405 default:
4406 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4407 }
4408 iprot.readFieldEnd();
4409 }
4410 iprot.readStructEnd();
4411
4412
4413 struct.validate();
4414 }
4415
4416 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_result struct) throws org.apache.thrift.TException {
4417 struct.validate();
4418
4419 oprot.writeStructBegin(STRUCT_DESC);
4420 if (struct.success != null) {
4421 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4422 {
4423 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
4424 for (TResult _iter107 : struct.success)
4425 {
4426 _iter107.write(oprot);
4427 }
4428 oprot.writeListEnd();
4429 }
4430 oprot.writeFieldEnd();
4431 }
4432 if (struct.io != null) {
4433 oprot.writeFieldBegin(IO_FIELD_DESC);
4434 struct.io.write(oprot);
4435 oprot.writeFieldEnd();
4436 }
4437 oprot.writeFieldStop();
4438 oprot.writeStructEnd();
4439 }
4440
4441 }
4442
4443 private static class getMultiple_resultTupleSchemeFactory implements SchemeFactory {
4444 public getMultiple_resultTupleScheme getScheme() {
4445 return new getMultiple_resultTupleScheme();
4446 }
4447 }
4448
4449 private static class getMultiple_resultTupleScheme extends TupleScheme<getMultiple_result> {
4450
4451 @Override
4452 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4453 TTupleProtocol oprot = (TTupleProtocol) prot;
4454 BitSet optionals = new BitSet();
4455 if (struct.isSetSuccess()) {
4456 optionals.set(0);
4457 }
4458 if (struct.isSetIo()) {
4459 optionals.set(1);
4460 }
4461 oprot.writeBitSet(optionals, 2);
4462 if (struct.isSetSuccess()) {
4463 {
4464 oprot.writeI32(struct.success.size());
4465 for (TResult _iter108 : struct.success)
4466 {
4467 _iter108.write(oprot);
4468 }
4469 }
4470 }
4471 if (struct.isSetIo()) {
4472 struct.io.write(oprot);
4473 }
4474 }
4475
4476 @Override
4477 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4478 TTupleProtocol iprot = (TTupleProtocol) prot;
4479 BitSet incoming = iprot.readBitSet(2);
4480 if (incoming.get(0)) {
4481 {
4482 org.apache.thrift.protocol.TList _list109 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
4483 struct.success = new ArrayList<TResult>(_list109.size);
4484 for (int _i110 = 0; _i110 < _list109.size; ++_i110)
4485 {
4486 TResult _elem111;
4487 _elem111 = new TResult();
4488 _elem111.read(iprot);
4489 struct.success.add(_elem111);
4490 }
4491 }
4492 struct.setSuccessIsSet(true);
4493 }
4494 if (incoming.get(1)) {
4495 struct.io = new TIOError();
4496 struct.io.read(iprot);
4497 struct.setIoIsSet(true);
4498 }
4499 }
4500 }
4501
4502 }
4503
4504 public static class put_args implements org.apache.thrift.TBase<put_args, put_args._Fields>, java.io.Serializable, Cloneable {
4505 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_args");
4506
4507 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);
4508 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);
4509
4510 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4511 static {
4512 schemes.put(StandardScheme.class, new put_argsStandardSchemeFactory());
4513 schemes.put(TupleScheme.class, new put_argsTupleSchemeFactory());
4514 }
4515
4516
4517
4518
4519 public ByteBuffer table;
4520
4521
4522
4523 public TPut put;
4524
4525
4526 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4527
4528
4529
4530 TABLE((short)1, "table"),
4531
4532
4533
4534 PUT((short)2, "put");
4535
4536 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4537
4538 static {
4539 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4540 byName.put(field.getFieldName(), field);
4541 }
4542 }
4543
4544
4545
4546
4547 public static _Fields findByThriftId(int fieldId) {
4548 switch(fieldId) {
4549 case 1:
4550 return TABLE;
4551 case 2:
4552 return PUT;
4553 default:
4554 return null;
4555 }
4556 }
4557
4558
4559
4560
4561
4562 public static _Fields findByThriftIdOrThrow(int fieldId) {
4563 _Fields fields = findByThriftId(fieldId);
4564 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4565 return fields;
4566 }
4567
4568
4569
4570
4571 public static _Fields findByName(String name) {
4572 return byName.get(name);
4573 }
4574
4575 private final short _thriftId;
4576 private final String _fieldName;
4577
4578 _Fields(short thriftId, String fieldName) {
4579 _thriftId = thriftId;
4580 _fieldName = fieldName;
4581 }
4582
4583 public short getThriftFieldId() {
4584 return _thriftId;
4585 }
4586
4587 public String getFieldName() {
4588 return _fieldName;
4589 }
4590 }
4591
4592
4593 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4594 static {
4595 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4596 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
4597 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
4598 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
4599 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
4600 metaDataMap = Collections.unmodifiableMap(tmpMap);
4601 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_args.class, metaDataMap);
4602 }
4603
4604 public put_args() {
4605 }
4606
4607 public put_args(
4608 ByteBuffer table,
4609 TPut put)
4610 {
4611 this();
4612 this.table = table;
4613 this.put = put;
4614 }
4615
4616
4617
4618
4619 public put_args(put_args other) {
4620 if (other.isSetTable()) {
4621 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
4622 ;
4623 }
4624 if (other.isSetPut()) {
4625 this.put = new TPut(other.put);
4626 }
4627 }
4628
4629 public put_args deepCopy() {
4630 return new put_args(this);
4631 }
4632
4633 @Override
4634 public void clear() {
4635 this.table = null;
4636 this.put = null;
4637 }
4638
4639
4640
4641
4642 public byte[] getTable() {
4643 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
4644 return table == null ? null : table.array();
4645 }
4646
4647 public ByteBuffer bufferForTable() {
4648 return table;
4649 }
4650
4651
4652
4653
4654 public put_args setTable(byte[] table) {
4655 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
4656 return this;
4657 }
4658
4659 public put_args setTable(ByteBuffer table) {
4660 this.table = table;
4661 return this;
4662 }
4663
4664 public void unsetTable() {
4665 this.table = null;
4666 }
4667
4668
4669 public boolean isSetTable() {
4670 return this.table != null;
4671 }
4672
4673 public void setTableIsSet(boolean value) {
4674 if (!value) {
4675 this.table = null;
4676 }
4677 }
4678
4679
4680
4681
4682 public TPut getPut() {
4683 return this.put;
4684 }
4685
4686
4687
4688
4689 public put_args setPut(TPut put) {
4690 this.put = put;
4691 return this;
4692 }
4693
4694 public void unsetPut() {
4695 this.put = null;
4696 }
4697
4698
4699 public boolean isSetPut() {
4700 return this.put != null;
4701 }
4702
4703 public void setPutIsSet(boolean value) {
4704 if (!value) {
4705 this.put = null;
4706 }
4707 }
4708
4709 public void setFieldValue(_Fields field, Object value) {
4710 switch (field) {
4711 case TABLE:
4712 if (value == null) {
4713 unsetTable();
4714 } else {
4715 setTable((ByteBuffer)value);
4716 }
4717 break;
4718
4719 case PUT:
4720 if (value == null) {
4721 unsetPut();
4722 } else {
4723 setPut((TPut)value);
4724 }
4725 break;
4726
4727 }
4728 }
4729
4730 public Object getFieldValue(_Fields field) {
4731 switch (field) {
4732 case TABLE:
4733 return getTable();
4734
4735 case PUT:
4736 return getPut();
4737
4738 }
4739 throw new IllegalStateException();
4740 }
4741
4742
4743 public boolean isSet(_Fields field) {
4744 if (field == null) {
4745 throw new IllegalArgumentException();
4746 }
4747
4748 switch (field) {
4749 case TABLE:
4750 return isSetTable();
4751 case PUT:
4752 return isSetPut();
4753 }
4754 throw new IllegalStateException();
4755 }
4756
4757 @Override
4758 public boolean equals(Object that) {
4759 if (that == null)
4760 return false;
4761 if (that instanceof put_args)
4762 return this.equals((put_args)that);
4763 return false;
4764 }
4765
4766 public boolean equals(put_args that) {
4767 if (that == null)
4768 return false;
4769
4770 boolean this_present_table = true && this.isSetTable();
4771 boolean that_present_table = true && that.isSetTable();
4772 if (this_present_table || that_present_table) {
4773 if (!(this_present_table && that_present_table))
4774 return false;
4775 if (!this.table.equals(that.table))
4776 return false;
4777 }
4778
4779 boolean this_present_put = true && this.isSetPut();
4780 boolean that_present_put = true && that.isSetPut();
4781 if (this_present_put || that_present_put) {
4782 if (!(this_present_put && that_present_put))
4783 return false;
4784 if (!this.put.equals(that.put))
4785 return false;
4786 }
4787
4788 return true;
4789 }
4790
4791 @Override
4792 public int hashCode() {
4793 return 0;
4794 }
4795
4796 public int compareTo(put_args other) {
4797 if (!getClass().equals(other.getClass())) {
4798 return getClass().getName().compareTo(other.getClass().getName());
4799 }
4800
4801 int lastComparison = 0;
4802 put_args typedOther = (put_args)other;
4803
4804 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
4805 if (lastComparison != 0) {
4806 return lastComparison;
4807 }
4808 if (isSetTable()) {
4809 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
4810 if (lastComparison != 0) {
4811 return lastComparison;
4812 }
4813 }
4814 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
4815 if (lastComparison != 0) {
4816 return lastComparison;
4817 }
4818 if (isSetPut()) {
4819 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
4820 if (lastComparison != 0) {
4821 return lastComparison;
4822 }
4823 }
4824 return 0;
4825 }
4826
4827 public _Fields fieldForId(int fieldId) {
4828 return _Fields.findByThriftId(fieldId);
4829 }
4830
4831 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4832 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4833 }
4834
4835 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4836 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4837 }
4838
4839 @Override
4840 public String toString() {
4841 StringBuilder sb = new StringBuilder("put_args(");
4842 boolean first = true;
4843
4844 sb.append("table:");
4845 if (this.table == null) {
4846 sb.append("null");
4847 } else {
4848 org.apache.thrift.TBaseHelper.toString(this.table, sb);
4849 }
4850 first = false;
4851 if (!first) sb.append(", ");
4852 sb.append("put:");
4853 if (this.put == null) {
4854 sb.append("null");
4855 } else {
4856 sb.append(this.put);
4857 }
4858 first = false;
4859 sb.append(")");
4860 return sb.toString();
4861 }
4862
4863 public void validate() throws org.apache.thrift.TException {
4864
4865 if (table == null) {
4866 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
4867 }
4868 if (put == null) {
4869 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
4870 }
4871 }
4872
4873 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4874 try {
4875 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4876 } catch (org.apache.thrift.TException te) {
4877 throw new java.io.IOException(te);
4878 }
4879 }
4880
4881 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4882 try {
4883 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4884 } catch (org.apache.thrift.TException te) {
4885 throw new java.io.IOException(te);
4886 }
4887 }
4888
4889 private static class put_argsStandardSchemeFactory implements SchemeFactory {
4890 public put_argsStandardScheme getScheme() {
4891 return new put_argsStandardScheme();
4892 }
4893 }
4894
4895 private static class put_argsStandardScheme extends StandardScheme<put_args> {
4896
4897 public void read(org.apache.thrift.protocol.TProtocol iprot, put_args struct) throws org.apache.thrift.TException {
4898 org.apache.thrift.protocol.TField schemeField;
4899 iprot.readStructBegin();
4900 while (true)
4901 {
4902 schemeField = iprot.readFieldBegin();
4903 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4904 break;
4905 }
4906 switch (schemeField.id) {
4907 case 1:
4908 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
4909 struct.table = iprot.readBinary();
4910 struct.setTableIsSet(true);
4911 } else {
4912 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4913 }
4914 break;
4915 case 2:
4916 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4917 struct.put = new TPut();
4918 struct.put.read(iprot);
4919 struct.setPutIsSet(true);
4920 } else {
4921 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4922 }
4923 break;
4924 default:
4925 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4926 }
4927 iprot.readFieldEnd();
4928 }
4929 iprot.readStructEnd();
4930
4931
4932 struct.validate();
4933 }
4934
4935 public void write(org.apache.thrift.protocol.TProtocol oprot, put_args struct) throws org.apache.thrift.TException {
4936 struct.validate();
4937
4938 oprot.writeStructBegin(STRUCT_DESC);
4939 if (struct.table != null) {
4940 oprot.writeFieldBegin(TABLE_FIELD_DESC);
4941 oprot.writeBinary(struct.table);
4942 oprot.writeFieldEnd();
4943 }
4944 if (struct.put != null) {
4945 oprot.writeFieldBegin(PUT_FIELD_DESC);
4946 struct.put.write(oprot);
4947 oprot.writeFieldEnd();
4948 }
4949 oprot.writeFieldStop();
4950 oprot.writeStructEnd();
4951 }
4952
4953 }
4954
4955 private static class put_argsTupleSchemeFactory implements SchemeFactory {
4956 public put_argsTupleScheme getScheme() {
4957 return new put_argsTupleScheme();
4958 }
4959 }
4960
4961 private static class put_argsTupleScheme extends TupleScheme<put_args> {
4962
4963 @Override
4964 public void write(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4965 TTupleProtocol oprot = (TTupleProtocol) prot;
4966 oprot.writeBinary(struct.table);
4967 struct.put.write(oprot);
4968 }
4969
4970 @Override
4971 public void read(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4972 TTupleProtocol iprot = (TTupleProtocol) prot;
4973 struct.table = iprot.readBinary();
4974 struct.setTableIsSet(true);
4975 struct.put = new TPut();
4976 struct.put.read(iprot);
4977 struct.setPutIsSet(true);
4978 }
4979 }
4980
4981 }
4982
4983 public static class put_result implements org.apache.thrift.TBase<put_result, put_result._Fields>, java.io.Serializable, Cloneable {
4984 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_result");
4985
4986 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);
4987
4988 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4989 static {
4990 schemes.put(StandardScheme.class, new put_resultStandardSchemeFactory());
4991 schemes.put(TupleScheme.class, new put_resultTupleSchemeFactory());
4992 }
4993
4994 public TIOError io;
4995
4996
4997 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4998 IO((short)1, "io");
4999
5000 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5001
5002 static {
5003 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5004 byName.put(field.getFieldName(), field);
5005 }
5006 }
5007
5008
5009
5010
5011 public static _Fields findByThriftId(int fieldId) {
5012 switch(fieldId) {
5013 case 1:
5014 return IO;
5015 default:
5016 return null;
5017 }
5018 }
5019
5020
5021
5022
5023
5024 public static _Fields findByThriftIdOrThrow(int fieldId) {
5025 _Fields fields = findByThriftId(fieldId);
5026 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5027 return fields;
5028 }
5029
5030
5031
5032
5033 public static _Fields findByName(String name) {
5034 return byName.get(name);
5035 }
5036
5037 private final short _thriftId;
5038 private final String _fieldName;
5039
5040 _Fields(short thriftId, String fieldName) {
5041 _thriftId = thriftId;
5042 _fieldName = fieldName;
5043 }
5044
5045 public short getThriftFieldId() {
5046 return _thriftId;
5047 }
5048
5049 public String getFieldName() {
5050 return _fieldName;
5051 }
5052 }
5053
5054
5055 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
5056 static {
5057 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
5058 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
5059 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
5060 metaDataMap = Collections.unmodifiableMap(tmpMap);
5061 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_result.class, metaDataMap);
5062 }
5063
5064 public put_result() {
5065 }
5066
5067 public put_result(
5068 TIOError io)
5069 {
5070 this();
5071 this.io = io;
5072 }
5073
5074
5075
5076
5077 public put_result(put_result other) {
5078 if (other.isSetIo()) {
5079 this.io = new TIOError(other.io);
5080 }
5081 }
5082
5083 public put_result deepCopy() {
5084 return new put_result(this);
5085 }
5086
5087 @Override
5088 public void clear() {
5089 this.io = null;
5090 }
5091
5092 public TIOError getIo() {
5093 return this.io;
5094 }
5095
5096 public put_result setIo(TIOError io) {
5097 this.io = io;
5098 return this;
5099 }
5100
5101 public void unsetIo() {
5102 this.io = null;
5103 }
5104
5105
5106 public boolean isSetIo() {
5107 return this.io != null;
5108 }
5109
5110 public void setIoIsSet(boolean value) {
5111 if (!value) {
5112 this.io = null;
5113 }
5114 }
5115
5116 public void setFieldValue(_Fields field, Object value) {
5117 switch (field) {
5118 case IO:
5119 if (value == null) {
5120 unsetIo();
5121 } else {
5122 setIo((TIOError)value);
5123 }
5124 break;
5125
5126 }
5127 }
5128
5129 public Object getFieldValue(_Fields field) {
5130 switch (field) {
5131 case IO:
5132 return getIo();
5133
5134 }
5135 throw new IllegalStateException();
5136 }
5137
5138
5139 public boolean isSet(_Fields field) {
5140 if (field == null) {
5141 throw new IllegalArgumentException();
5142 }
5143
5144 switch (field) {
5145 case IO:
5146 return isSetIo();
5147 }
5148 throw new IllegalStateException();
5149 }
5150
5151 @Override
5152 public boolean equals(Object that) {
5153 if (that == null)
5154 return false;
5155 if (that instanceof put_result)
5156 return this.equals((put_result)that);
5157 return false;
5158 }
5159
5160 public boolean equals(put_result that) {
5161 if (that == null)
5162 return false;
5163
5164 boolean this_present_io = true && this.isSetIo();
5165 boolean that_present_io = true && that.isSetIo();
5166 if (this_present_io || that_present_io) {
5167 if (!(this_present_io && that_present_io))
5168 return false;
5169 if (!this.io.equals(that.io))
5170 return false;
5171 }
5172
5173 return true;
5174 }
5175
5176 @Override
5177 public int hashCode() {
5178 return 0;
5179 }
5180
5181 public int compareTo(put_result other) {
5182 if (!getClass().equals(other.getClass())) {
5183 return getClass().getName().compareTo(other.getClass().getName());
5184 }
5185
5186 int lastComparison = 0;
5187 put_result typedOther = (put_result)other;
5188
5189 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
5190 if (lastComparison != 0) {
5191 return lastComparison;
5192 }
5193 if (isSetIo()) {
5194 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
5195 if (lastComparison != 0) {
5196 return lastComparison;
5197 }
5198 }
5199 return 0;
5200 }
5201
5202 public _Fields fieldForId(int fieldId) {
5203 return _Fields.findByThriftId(fieldId);
5204 }
5205
5206 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
5207 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
5208 }
5209
5210 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
5211 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
5212 }
5213
5214 @Override
5215 public String toString() {
5216 StringBuilder sb = new StringBuilder("put_result(");
5217 boolean first = true;
5218
5219 sb.append("io:");
5220 if (this.io == null) {
5221 sb.append("null");
5222 } else {
5223 sb.append(this.io);
5224 }
5225 first = false;
5226 sb.append(")");
5227 return sb.toString();
5228 }
5229
5230 public void validate() throws org.apache.thrift.TException {
5231
5232 }
5233
5234 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
5235 try {
5236 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
5237 } catch (org.apache.thrift.TException te) {
5238 throw new java.io.IOException(te);
5239 }
5240 }
5241
5242 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
5243 try {
5244 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
5245 } catch (org.apache.thrift.TException te) {
5246 throw new java.io.IOException(te);
5247 }
5248 }
5249
5250 private static class put_resultStandardSchemeFactory implements SchemeFactory {
5251 public put_resultStandardScheme getScheme() {
5252 return new put_resultStandardScheme();
5253 }
5254 }
5255
5256 private static class put_resultStandardScheme extends StandardScheme<put_result> {
5257
5258 public void read(org.apache.thrift.protocol.TProtocol iprot, put_result struct) throws org.apache.thrift.TException {
5259 org.apache.thrift.protocol.TField schemeField;
5260 iprot.readStructBegin();
5261 while (true)
5262 {
5263 schemeField = iprot.readFieldBegin();
5264 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
5265 break;
5266 }
5267 switch (schemeField.id) {
5268 case 1:
5269 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
5270 struct.io = new TIOError();
5271 struct.io.read(iprot);
5272 struct.setIoIsSet(true);
5273 } else {
5274 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5275 }
5276 break;
5277 default:
5278 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5279 }
5280 iprot.readFieldEnd();
5281 }
5282 iprot.readStructEnd();
5283
5284
5285 struct.validate();
5286 }
5287
5288 public void write(org.apache.thrift.protocol.TProtocol oprot, put_result struct) throws org.apache.thrift.TException {
5289 struct.validate();
5290
5291 oprot.writeStructBegin(STRUCT_DESC);
5292 if (struct.io != null) {
5293 oprot.writeFieldBegin(IO_FIELD_DESC);
5294 struct.io.write(oprot);
5295 oprot.writeFieldEnd();
5296 }
5297 oprot.writeFieldStop();
5298 oprot.writeStructEnd();
5299 }
5300
5301 }
5302
5303 private static class put_resultTupleSchemeFactory implements SchemeFactory {
5304 public put_resultTupleScheme getScheme() {
5305 return new put_resultTupleScheme();
5306 }
5307 }
5308
5309 private static class put_resultTupleScheme extends TupleScheme<put_result> {
5310
5311 @Override
5312 public void write(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5313 TTupleProtocol oprot = (TTupleProtocol) prot;
5314 BitSet optionals = new BitSet();
5315 if (struct.isSetIo()) {
5316 optionals.set(0);
5317 }
5318 oprot.writeBitSet(optionals, 1);
5319 if (struct.isSetIo()) {
5320 struct.io.write(oprot);
5321 }
5322 }
5323
5324 @Override
5325 public void read(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5326 TTupleProtocol iprot = (TTupleProtocol) prot;
5327 BitSet incoming = iprot.readBitSet(1);
5328 if (incoming.get(0)) {
5329 struct.io = new TIOError();
5330 struct.io.read(iprot);
5331 struct.setIoIsSet(true);
5332 }
5333 }
5334 }
5335
5336 }
5337
5338 public static class checkAndPut_args implements org.apache.thrift.TBase<checkAndPut_args, checkAndPut_args._Fields>, java.io.Serializable, Cloneable {
5339 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_args");
5340
5341 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);
5342 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);
5343 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);
5344 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);
5345 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);
5346 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);
5347
5348 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
5349 static {
5350 schemes.put(StandardScheme.class, new checkAndPut_argsStandardSchemeFactory());
5351 schemes.put(TupleScheme.class, new checkAndPut_argsTupleSchemeFactory());
5352 }
5353
5354
5355
5356
5357 public ByteBuffer table;
5358
5359
5360
5361 public ByteBuffer row;
5362
5363
5364
5365 public ByteBuffer family;
5366
5367
5368
5369 public ByteBuffer qualifier;
5370
5371
5372
5373
5374
5375 public ByteBuffer value;
5376
5377
5378
5379 public TPut put;
5380
5381
5382 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
5383
5384
5385
5386 TABLE((short)1, "table"),
5387
5388
5389
5390 ROW((short)2, "row"),
5391
5392
5393
5394 FAMILY((short)3, "family"),
5395
5396
5397
5398 QUALIFIER((short)4, "qualifier"),
5399
5400
5401
5402
5403
5404 VALUE((short)5, "value"),
5405
5406
5407
5408 PUT((short)6, "put");
5409
5410 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5411
5412 static {
5413 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5414 byName.put(field.getFieldName(), field);
5415 }
5416 }
5417
5418
5419
5420
5421 public static _Fields findByThriftId(int fieldId) {
5422 switch(fieldId) {
5423 case 1:
5424 return TABLE;
5425 case 2:
5426 return ROW;
5427 case 3:
5428 return FAMILY;
5429 case 4:
5430 return QUALIFIER;
5431 case 5:
5432 return VALUE;
5433 case 6:
5434 return PUT;
5435 default:
5436 return null;
5437 }
5438 }
5439
5440
5441
5442
5443
5444 public static _Fields findByThriftIdOrThrow(int fieldId) {
5445 _Fields fields = findByThriftId(fieldId);
5446 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5447 return fields;
5448 }
5449
5450
5451
5452
5453 public static _Fields findByName(String name) {
5454 return byName.get(name);
5455 }
5456
5457 private final short _thriftId;
5458 private final String _fieldName;
5459
5460 _Fields(short thriftId, String fieldName) {
5461 _thriftId = thriftId;
5462 _fieldName = fieldName;
5463 }
5464
5465 public short getThriftFieldId() {
5466 return _thriftId;
5467 }
5468
5469 public String getFieldName() {
5470 return _fieldName;
5471 }
5472 }
5473
5474
5475 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
5476 static {
5477 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
5478 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
5479 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5480 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
5481 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5482 tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
5483 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5484 tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
5485 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5486 tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT,
5487 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5488 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
5489 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
5490 metaDataMap = Collections.unmodifiableMap(tmpMap);
5491 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_args.class, metaDataMap);
5492 }
5493
5494 public checkAndPut_args() {
5495 }
5496
5497 public checkAndPut_args(
5498 ByteBuffer table,
5499 ByteBuffer row,
5500 ByteBuffer family,
5501 ByteBuffer qualifier,
5502 ByteBuffer value,
5503 TPut put)
5504 {
5505 this();
5506 this.table = table;
5507 this.row = row;
5508 this.family = family;
5509 this.qualifier = qualifier;
5510 this.value = value;
5511 this.put = put;
5512 }
5513
5514
5515
5516
5517 public checkAndPut_args(checkAndPut_args other) {
5518 if (other.isSetTable()) {
5519 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
5520 ;
5521 }
5522 if (other.isSetRow()) {
5523 this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
5524 ;
5525 }
5526 if (other.isSetFamily()) {
5527 this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
5528 ;
5529 }
5530 if (other.isSetQualifier()) {
5531 this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
5532 ;
5533 }
5534 if (other.isSetValue()) {
5535 this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
5536 ;
5537 }
5538 if (other.isSetPut()) {
5539 this.put = new TPut(other.put);
5540 }
5541 }
5542
5543 public checkAndPut_args deepCopy() {
5544 return new checkAndPut_args(this);
5545 }
5546
5547 @Override
5548 public void clear() {
5549 this.table = null;
5550 this.row = null;
5551 this.family = null;
5552 this.qualifier = null;
5553 this.value = null;
5554 this.put = null;
5555 }
5556
5557
5558
5559
5560 public byte[] getTable() {
5561 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
5562 return table == null ? null : table.array();
5563 }
5564
5565 public ByteBuffer bufferForTable() {
5566 return table;
5567 }
5568
5569
5570
5571
5572 public checkAndPut_args setTable(byte[] table) {
5573 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
5574 return this;
5575 }
5576
5577 public checkAndPut_args setTable(ByteBuffer table) {
5578 this.table = table;
5579 return this;
5580 }
5581
5582 public void unsetTable() {
5583 this.table = null;
5584 }
5585
5586
5587 public boolean isSetTable() {
5588 return this.table != null;
5589 }
5590
5591 public void setTableIsSet(boolean value) {
5592 if (!value) {
5593 this.table = null;
5594 }
5595 }
5596
5597
5598
5599
5600 public byte[] getRow() {
5601 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
5602 return row == null ? null : row.array();
5603 }
5604
5605 public ByteBuffer bufferForRow() {
5606 return row;
5607 }
5608
5609
5610
5611
5612 public checkAndPut_args setRow(byte[] row) {
5613 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
5614 return this;
5615 }
5616
5617 public checkAndPut_args setRow(ByteBuffer row) {
5618 this.row = row;
5619 return this;
5620 }
5621
5622 public void unsetRow() {
5623 this.row = null;
5624 }
5625
5626
5627 public boolean isSetRow() {
5628 return this.row != null;
5629 }
5630
5631 public void setRowIsSet(boolean value) {
5632 if (!value) {
5633 this.row = null;
5634 }
5635 }
5636
5637
5638
5639
5640 public byte[] getFamily() {
5641 setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
5642 return family == null ? null : family.array();
5643 }
5644
5645 public ByteBuffer bufferForFamily() {
5646 return family;
5647 }
5648
5649
5650
5651
5652 public checkAndPut_args setFamily(byte[] family) {
5653 setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
5654 return this;
5655 }
5656
5657 public checkAndPut_args setFamily(ByteBuffer family) {
5658 this.family = family;
5659 return this;
5660 }
5661
5662 public void unsetFamily() {
5663 this.family = null;
5664 }
5665
5666
5667 public boolean isSetFamily() {
5668 return this.family != null;
5669 }
5670
5671 public void setFamilyIsSet(boolean value) {
5672 if (!value) {
5673 this.family = null;
5674 }
5675 }
5676
5677
5678
5679
5680 public byte[] getQualifier() {
5681 setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
5682 return qualifier == null ? null : qualifier.array();
5683 }
5684
5685 public ByteBuffer bufferForQualifier() {
5686 return qualifier;
5687 }
5688
5689
5690
5691
5692 public checkAndPut_args setQualifier(byte[] qualifier) {
5693 setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
5694 return this;
5695 }
5696
5697 public checkAndPut_args setQualifier(ByteBuffer qualifier) {
5698 this.qualifier = qualifier;
5699 return this;
5700 }
5701
5702 public void unsetQualifier() {
5703 this.qualifier = null;
5704 }
5705
5706
5707 public boolean isSetQualifier() {
5708 return this.qualifier != null;
5709 }
5710
5711 public void setQualifierIsSet(boolean value) {
5712 if (!value) {
5713 this.qualifier = null;
5714 }
5715 }
5716
5717
5718
5719
5720
5721
5722 public byte[] getValue() {
5723 setValue(org.apache.thrift.TBaseHelper.rightSize(value));
5724 return value == null ? null : value.array();
5725 }
5726
5727 public ByteBuffer bufferForValue() {
5728 return value;
5729 }
5730
5731
5732
5733
5734
5735
5736 public checkAndPut_args setValue(byte[] value) {
5737 setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
5738 return this;
5739 }
5740
5741 public checkAndPut_args setValue(ByteBuffer value) {
5742 this.value = value;
5743 return this;
5744 }
5745
5746 public void unsetValue() {
5747 this.value = null;
5748 }
5749
5750
5751 public boolean isSetValue() {
5752 return this.value != null;
5753 }
5754
5755 public void setValueIsSet(boolean value) {
5756 if (!value) {
5757 this.value = null;
5758 }
5759 }
5760
5761
5762
5763
5764 public TPut getPut() {
5765 return this.put;
5766 }
5767
5768
5769
5770
5771 public checkAndPut_args setPut(TPut put) {
5772 this.put = put;
5773 return this;
5774 }
5775
5776 public void unsetPut() {
5777 this.put = null;
5778 }
5779
5780
5781 public boolean isSetPut() {
5782 return this.put != null;
5783 }
5784
5785 public void setPutIsSet(boolean value) {
5786 if (!value) {
5787 this.put = null;
5788 }
5789 }
5790
5791 public void setFieldValue(_Fields field, Object value) {
5792 switch (field) {
5793 case TABLE:
5794 if (value == null) {
5795 unsetTable();
5796 } else {
5797 setTable((ByteBuffer)value);
5798 }
5799 break;
5800
5801 case ROW:
5802 if (value == null) {
5803 unsetRow();
5804 } else {
5805 setRow((ByteBuffer)value);
5806 }
5807 break;
5808
5809 case FAMILY:
5810 if (value == null) {
5811 unsetFamily();
5812 } else {
5813 setFamily((ByteBuffer)value);
5814 }
5815 break;
5816
5817 case QUALIFIER:
5818 if (value == null) {
5819 unsetQualifier();
5820 } else {
5821 setQualifier((ByteBuffer)value);
5822 }
5823 break;
5824
5825 case VALUE:
5826 if (value == null) {
5827 unsetValue();
5828 } else {
5829 setValue((ByteBuffer)value);
5830 }
5831 break;
5832
5833 case PUT:
5834 if (value == null) {
5835 unsetPut();
5836 } else {
5837 setPut((TPut)value);
5838 }
5839 break;
5840
5841 }
5842 }
5843
5844 public Object getFieldValue(_Fields field) {
5845 switch (field) {
5846 case TABLE:
5847 return getTable();
5848
5849 case ROW:
5850 return getRow();
5851
5852 case FAMILY:
5853 return getFamily();
5854
5855 case QUALIFIER:
5856 return getQualifier();
5857
5858 case VALUE:
5859 return getValue();
5860
5861 case PUT:
5862 return getPut();
5863
5864 }
5865 throw new IllegalStateException();
5866 }
5867
5868
5869 public boolean isSet(_Fields field) {
5870 if (field == null) {
5871 throw new IllegalArgumentException();
5872 }
5873
5874 switch (field) {
5875 case TABLE:
5876 return isSetTable();
5877 case ROW:
5878 return isSetRow();
5879 case FAMILY:
5880 return isSetFamily();
5881 case QUALIFIER:
5882 return isSetQualifier();
5883 case VALUE:
5884 return isSetValue();
5885 case PUT:
5886 return isSetPut();
5887 }
5888 throw new IllegalStateException();
5889 }
5890
5891 @Override
5892 public boolean equals(Object that) {
5893 if (that == null)
5894 return false;
5895 if (that instanceof checkAndPut_args)
5896 return this.equals((checkAndPut_args)that);
5897 return false;
5898 }
5899
5900 public boolean equals(checkAndPut_args that) {
5901 if (that == null)
5902 return false;
5903
5904 boolean this_present_table = true && this.isSetTable();
5905 boolean that_present_table = true && that.isSetTable();
5906 if (this_present_table || that_present_table) {
5907 if (!(this_present_table && that_present_table))
5908 return false;
5909 if (!this.table.equals(that.table))
5910 return false;
5911 }
5912
5913 boolean this_present_row = true && this.isSetRow();
5914 boolean that_present_row = true && that.isSetRow();
5915 if (this_present_row || that_present_row) {
5916 if (!(this_present_row && that_present_row))
5917 return false;
5918 if (!this.row.equals(that.row))
5919 return false;
5920 }
5921
5922 boolean this_present_family = true && this.isSetFamily();
5923 boolean that_present_family = true && that.isSetFamily();
5924 if (this_present_family || that_present_family) {
5925 if (!(this_present_family && that_present_family))
5926 return false;
5927 if (!this.family.equals(that.family))
5928 return false;
5929 }
5930
5931 boolean this_present_qualifier = true && this.isSetQualifier();
5932 boolean that_present_qualifier = true && that.isSetQualifier();
5933 if (this_present_qualifier || that_present_qualifier) {
5934 if (!(this_present_qualifier && that_present_qualifier))
5935 return false;
5936 if (!this.qualifier.equals(that.qualifier))
5937 return false;
5938 }
5939
5940 boolean this_present_value = true && this.isSetValue();
5941 boolean that_present_value = true && that.isSetValue();
5942 if (this_present_value || that_present_value) {
5943 if (!(this_present_value && that_present_value))
5944 return false;
5945 if (!this.value.equals(that.value))
5946 return false;
5947 }
5948
5949 boolean this_present_put = true && this.isSetPut();
5950 boolean that_present_put = true && that.isSetPut();
5951 if (this_present_put || that_present_put) {
5952 if (!(this_present_put && that_present_put))
5953 return false;
5954 if (!this.put.equals(that.put))
5955 return false;
5956 }
5957
5958 return true;
5959 }
5960
5961 @Override
5962 public int hashCode() {
5963 return 0;
5964 }
5965
5966 public int compareTo(checkAndPut_args other) {
5967 if (!getClass().equals(other.getClass())) {
5968 return getClass().getName().compareTo(other.getClass().getName());
5969 }
5970
5971 int lastComparison = 0;
5972 checkAndPut_args typedOther = (checkAndPut_args)other;
5973
5974 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
5975 if (lastComparison != 0) {
5976 return lastComparison;
5977 }
5978 if (isSetTable()) {
5979 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
5980 if (lastComparison != 0) {
5981 return lastComparison;
5982 }
5983 }
5984 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
5985 if (lastComparison != 0) {
5986 return lastComparison;
5987 }
5988 if (isSetRow()) {
5989 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
5990 if (lastComparison != 0) {
5991 return lastComparison;
5992 }
5993 }
5994 lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
5995 if (lastComparison != 0) {
5996 return lastComparison;
5997 }
5998 if (isSetFamily()) {
5999 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
6000 if (lastComparison != 0) {
6001 return lastComparison;
6002 }
6003 }
6004 lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
6005 if (lastComparison != 0) {
6006 return lastComparison;
6007 }
6008 if (isSetQualifier()) {
6009 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
6010 if (lastComparison != 0) {
6011 return lastComparison;
6012 }
6013 }
6014 lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
6015 if (lastComparison != 0) {
6016 return lastComparison;
6017 }
6018 if (isSetValue()) {
6019 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
6020 if (lastComparison != 0) {
6021 return lastComparison;
6022 }
6023 }
6024 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
6025 if (lastComparison != 0) {
6026 return lastComparison;
6027 }
6028 if (isSetPut()) {
6029 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
6030 if (lastComparison != 0) {
6031 return lastComparison;
6032 }
6033 }
6034 return 0;
6035 }
6036
6037 public _Fields fieldForId(int fieldId) {
6038 return _Fields.findByThriftId(fieldId);
6039 }
6040
6041 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6042 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6043 }
6044
6045 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6046 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6047 }
6048
6049 @Override
6050 public String toString() {
6051 StringBuilder sb = new StringBuilder("checkAndPut_args(");
6052 boolean first = true;
6053
6054 sb.append("table:");
6055 if (this.table == null) {
6056 sb.append("null");
6057 } else {
6058 org.apache.thrift.TBaseHelper.toString(this.table, sb);
6059 }
6060 first = false;
6061 if (!first) sb.append(", ");
6062 sb.append("row:");
6063 if (this.row == null) {
6064 sb.append("null");
6065 } else {
6066 org.apache.thrift.TBaseHelper.toString(this.row, sb);
6067 }
6068 first = false;
6069 if (!first) sb.append(", ");
6070 sb.append("family:");
6071 if (this.family == null) {
6072 sb.append("null");
6073 } else {
6074 org.apache.thrift.TBaseHelper.toString(this.family, sb);
6075 }
6076 first = false;
6077 if (!first) sb.append(", ");
6078 sb.append("qualifier:");
6079 if (this.qualifier == null) {
6080 sb.append("null");
6081 } else {
6082 org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
6083 }
6084 first = false;
6085 if (!first) sb.append(", ");
6086 sb.append("value:");
6087 if (this.value == null) {
6088 sb.append("null");
6089 } else {
6090 org.apache.thrift.TBaseHelper.toString(this.value, sb);
6091 }
6092 first = false;
6093 if (!first) sb.append(", ");
6094 sb.append("put:");
6095 if (this.put == null) {
6096 sb.append("null");
6097 } else {
6098 sb.append(this.put);
6099 }
6100 first = false;
6101 sb.append(")");
6102 return sb.toString();
6103 }
6104
6105 public void validate() throws org.apache.thrift.TException {
6106
6107 if (table == null) {
6108 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
6109 }
6110 if (row == null) {
6111 throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
6112 }
6113 if (family == null) {
6114 throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
6115 }
6116 if (qualifier == null) {
6117 throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
6118 }
6119 if (put == null) {
6120 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
6121 }
6122 }
6123
6124 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6125 try {
6126 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6127 } catch (org.apache.thrift.TException te) {
6128 throw new java.io.IOException(te);
6129 }
6130 }
6131
6132 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6133 try {
6134 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6135 } catch (org.apache.thrift.TException te) {
6136 throw new java.io.IOException(te);
6137 }
6138 }
6139
6140 private static class checkAndPut_argsStandardSchemeFactory implements SchemeFactory {
6141 public checkAndPut_argsStandardScheme getScheme() {
6142 return new checkAndPut_argsStandardScheme();
6143 }
6144 }
6145
6146 private static class checkAndPut_argsStandardScheme extends StandardScheme<checkAndPut_args> {
6147
6148 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6149 org.apache.thrift.protocol.TField schemeField;
6150 iprot.readStructBegin();
6151 while (true)
6152 {
6153 schemeField = iprot.readFieldBegin();
6154 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6155 break;
6156 }
6157 switch (schemeField.id) {
6158 case 1:
6159 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6160 struct.table = iprot.readBinary();
6161 struct.setTableIsSet(true);
6162 } else {
6163 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6164 }
6165 break;
6166 case 2:
6167 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6168 struct.row = iprot.readBinary();
6169 struct.setRowIsSet(true);
6170 } else {
6171 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6172 }
6173 break;
6174 case 3:
6175 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6176 struct.family = iprot.readBinary();
6177 struct.setFamilyIsSet(true);
6178 } else {
6179 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6180 }
6181 break;
6182 case 4:
6183 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6184 struct.qualifier = iprot.readBinary();
6185 struct.setQualifierIsSet(true);
6186 } else {
6187 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6188 }
6189 break;
6190 case 5:
6191 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6192 struct.value = iprot.readBinary();
6193 struct.setValueIsSet(true);
6194 } else {
6195 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6196 }
6197 break;
6198 case 6:
6199 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6200 struct.put = new TPut();
6201 struct.put.read(iprot);
6202 struct.setPutIsSet(true);
6203 } else {
6204 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6205 }
6206 break;
6207 default:
6208 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6209 }
6210 iprot.readFieldEnd();
6211 }
6212 iprot.readStructEnd();
6213
6214
6215 struct.validate();
6216 }
6217
6218 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6219 struct.validate();
6220
6221 oprot.writeStructBegin(STRUCT_DESC);
6222 if (struct.table != null) {
6223 oprot.writeFieldBegin(TABLE_FIELD_DESC);
6224 oprot.writeBinary(struct.table);
6225 oprot.writeFieldEnd();
6226 }
6227 if (struct.row != null) {
6228 oprot.writeFieldBegin(ROW_FIELD_DESC);
6229 oprot.writeBinary(struct.row);
6230 oprot.writeFieldEnd();
6231 }
6232 if (struct.family != null) {
6233 oprot.writeFieldBegin(FAMILY_FIELD_DESC);
6234 oprot.writeBinary(struct.family);
6235 oprot.writeFieldEnd();
6236 }
6237 if (struct.qualifier != null) {
6238 oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
6239 oprot.writeBinary(struct.qualifier);
6240 oprot.writeFieldEnd();
6241 }
6242 if (struct.value != null) {
6243 oprot.writeFieldBegin(VALUE_FIELD_DESC);
6244 oprot.writeBinary(struct.value);
6245 oprot.writeFieldEnd();
6246 }
6247 if (struct.put != null) {
6248 oprot.writeFieldBegin(PUT_FIELD_DESC);
6249 struct.put.write(oprot);
6250 oprot.writeFieldEnd();
6251 }
6252 oprot.writeFieldStop();
6253 oprot.writeStructEnd();
6254 }
6255
6256 }
6257
6258 private static class checkAndPut_argsTupleSchemeFactory implements SchemeFactory {
6259 public checkAndPut_argsTupleScheme getScheme() {
6260 return new checkAndPut_argsTupleScheme();
6261 }
6262 }
6263
6264 private static class checkAndPut_argsTupleScheme extends TupleScheme<checkAndPut_args> {
6265
6266 @Override
6267 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6268 TTupleProtocol oprot = (TTupleProtocol) prot;
6269 oprot.writeBinary(struct.table);
6270 oprot.writeBinary(struct.row);
6271 oprot.writeBinary(struct.family);
6272 oprot.writeBinary(struct.qualifier);
6273 struct.put.write(oprot);
6274 BitSet optionals = new BitSet();
6275 if (struct.isSetValue()) {
6276 optionals.set(0);
6277 }
6278 oprot.writeBitSet(optionals, 1);
6279 if (struct.isSetValue()) {
6280 oprot.writeBinary(struct.value);
6281 }
6282 }
6283
6284 @Override
6285 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6286 TTupleProtocol iprot = (TTupleProtocol) prot;
6287 struct.table = iprot.readBinary();
6288 struct.setTableIsSet(true);
6289 struct.row = iprot.readBinary();
6290 struct.setRowIsSet(true);
6291 struct.family = iprot.readBinary();
6292 struct.setFamilyIsSet(true);
6293 struct.qualifier = iprot.readBinary();
6294 struct.setQualifierIsSet(true);
6295 struct.put = new TPut();
6296 struct.put.read(iprot);
6297 struct.setPutIsSet(true);
6298 BitSet incoming = iprot.readBitSet(1);
6299 if (incoming.get(0)) {
6300 struct.value = iprot.readBinary();
6301 struct.setValueIsSet(true);
6302 }
6303 }
6304 }
6305
6306 }
6307
6308 public static class checkAndPut_result implements org.apache.thrift.TBase<checkAndPut_result, checkAndPut_result._Fields>, java.io.Serializable, Cloneable {
6309 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_result");
6310
6311 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);
6312 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);
6313
6314 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6315 static {
6316 schemes.put(StandardScheme.class, new checkAndPut_resultStandardSchemeFactory());
6317 schemes.put(TupleScheme.class, new checkAndPut_resultTupleSchemeFactory());
6318 }
6319
6320 public boolean success;
6321 public TIOError io;
6322
6323
6324 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6325 SUCCESS((short)0, "success"),
6326 IO((short)1, "io");
6327
6328 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6329
6330 static {
6331 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6332 byName.put(field.getFieldName(), field);
6333 }
6334 }
6335
6336
6337
6338
6339 public static _Fields findByThriftId(int fieldId) {
6340 switch(fieldId) {
6341 case 0:
6342 return SUCCESS;
6343 case 1:
6344 return IO;
6345 default:
6346 return null;
6347 }
6348 }
6349
6350
6351
6352
6353
6354 public static _Fields findByThriftIdOrThrow(int fieldId) {
6355 _Fields fields = findByThriftId(fieldId);
6356 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6357 return fields;
6358 }
6359
6360
6361
6362
6363 public static _Fields findByName(String name) {
6364 return byName.get(name);
6365 }
6366
6367 private final short _thriftId;
6368 private final String _fieldName;
6369
6370 _Fields(short thriftId, String fieldName) {
6371 _thriftId = thriftId;
6372 _fieldName = fieldName;
6373 }
6374
6375 public short getThriftFieldId() {
6376 return _thriftId;
6377 }
6378
6379 public String getFieldName() {
6380 return _fieldName;
6381 }
6382 }
6383
6384
6385 private static final int __SUCCESS_ISSET_ID = 0;
6386 private BitSet __isset_bit_vector = new BitSet(1);
6387 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6388 static {
6389 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6390 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
6391 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
6392 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
6393 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
6394 metaDataMap = Collections.unmodifiableMap(tmpMap);
6395 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_result.class, metaDataMap);
6396 }
6397
6398 public checkAndPut_result() {
6399 }
6400
6401 public checkAndPut_result(
6402 boolean success,
6403 TIOError io)
6404 {
6405 this();
6406 this.success = success;
6407 setSuccessIsSet(true);
6408 this.io = io;
6409 }
6410
6411
6412
6413
6414 public checkAndPut_result(checkAndPut_result other) {
6415 __isset_bit_vector.clear();
6416 __isset_bit_vector.or(other.__isset_bit_vector);
6417 this.success = other.success;
6418 if (other.isSetIo()) {
6419 this.io = new TIOError(other.io);
6420 }
6421 }
6422
6423 public checkAndPut_result deepCopy() {
6424 return new checkAndPut_result(this);
6425 }
6426
6427 @Override
6428 public void clear() {
6429 setSuccessIsSet(false);
6430 this.success = false;
6431 this.io = null;
6432 }
6433
6434 public boolean isSuccess() {
6435 return this.success;
6436 }
6437
6438 public checkAndPut_result setSuccess(boolean success) {
6439 this.success = success;
6440 setSuccessIsSet(true);
6441 return this;
6442 }
6443
6444 public void unsetSuccess() {
6445 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
6446 }
6447
6448
6449 public boolean isSetSuccess() {
6450 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
6451 }
6452
6453 public void setSuccessIsSet(boolean value) {
6454 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
6455 }
6456
6457 public TIOError getIo() {
6458 return this.io;
6459 }
6460
6461 public checkAndPut_result setIo(TIOError io) {
6462 this.io = io;
6463 return this;
6464 }
6465
6466 public void unsetIo() {
6467 this.io = null;
6468 }
6469
6470
6471 public boolean isSetIo() {
6472 return this.io != null;
6473 }
6474
6475 public void setIoIsSet(boolean value) {
6476 if (!value) {
6477 this.io = null;
6478 }
6479 }
6480
6481 public void setFieldValue(_Fields field, Object value) {
6482 switch (field) {
6483 case SUCCESS:
6484 if (value == null) {
6485 unsetSuccess();
6486 } else {
6487 setSuccess((Boolean)value);
6488 }
6489 break;
6490
6491 case IO:
6492 if (value == null) {
6493 unsetIo();
6494 } else {
6495 setIo((TIOError)value);
6496 }
6497 break;
6498
6499 }
6500 }
6501
6502 public Object getFieldValue(_Fields field) {
6503 switch (field) {
6504 case SUCCESS:
6505 return Boolean.valueOf(isSuccess());
6506
6507 case IO:
6508 return getIo();
6509
6510 }
6511 throw new IllegalStateException();
6512 }
6513
6514
6515 public boolean isSet(_Fields field) {
6516 if (field == null) {
6517 throw new IllegalArgumentException();
6518 }
6519
6520 switch (field) {
6521 case SUCCESS:
6522 return isSetSuccess();
6523 case IO:
6524 return isSetIo();
6525 }
6526 throw new IllegalStateException();
6527 }
6528
6529 @Override
6530 public boolean equals(Object that) {
6531 if (that == null)
6532 return false;
6533 if (that instanceof checkAndPut_result)
6534 return this.equals((checkAndPut_result)that);
6535 return false;
6536 }
6537
6538 public boolean equals(checkAndPut_result that) {
6539 if (that == null)
6540 return false;
6541
6542 boolean this_present_success = true;
6543 boolean that_present_success = true;
6544 if (this_present_success || that_present_success) {
6545 if (!(this_present_success && that_present_success))
6546 return false;
6547 if (this.success != that.success)
6548 return false;
6549 }
6550
6551 boolean this_present_io = true && this.isSetIo();
6552 boolean that_present_io = true && that.isSetIo();
6553 if (this_present_io || that_present_io) {
6554 if (!(this_present_io && that_present_io))
6555 return false;
6556 if (!this.io.equals(that.io))
6557 return false;
6558 }
6559
6560 return true;
6561 }
6562
6563 @Override
6564 public int hashCode() {
6565 return 0;
6566 }
6567
6568 public int compareTo(checkAndPut_result other) {
6569 if (!getClass().equals(other.getClass())) {
6570 return getClass().getName().compareTo(other.getClass().getName());
6571 }
6572
6573 int lastComparison = 0;
6574 checkAndPut_result typedOther = (checkAndPut_result)other;
6575
6576 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
6577 if (lastComparison != 0) {
6578 return lastComparison;
6579 }
6580 if (isSetSuccess()) {
6581 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
6582 if (lastComparison != 0) {
6583 return lastComparison;
6584 }
6585 }
6586 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
6587 if (lastComparison != 0) {
6588 return lastComparison;
6589 }
6590 if (isSetIo()) {
6591 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
6592 if (lastComparison != 0) {
6593 return lastComparison;
6594 }
6595 }
6596 return 0;
6597 }
6598
6599 public _Fields fieldForId(int fieldId) {
6600 return _Fields.findByThriftId(fieldId);
6601 }
6602
6603 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6604 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6605 }
6606
6607 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6608 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6609 }
6610
6611 @Override
6612 public String toString() {
6613 StringBuilder sb = new StringBuilder("checkAndPut_result(");
6614 boolean first = true;
6615
6616 sb.append("success:");
6617 sb.append(this.success);
6618 first = false;
6619 if (!first) sb.append(", ");
6620 sb.append("io:");
6621 if (this.io == null) {
6622 sb.append("null");
6623 } else {
6624 sb.append(this.io);
6625 }
6626 first = false;
6627 sb.append(")");
6628 return sb.toString();
6629 }
6630
6631 public void validate() throws org.apache.thrift.TException {
6632
6633 }
6634
6635 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6636 try {
6637 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6638 } catch (org.apache.thrift.TException te) {
6639 throw new java.io.IOException(te);
6640 }
6641 }
6642
6643 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6644 try {
6645
6646 __isset_bit_vector = new BitSet(1);
6647 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6648 } catch (org.apache.thrift.TException te) {
6649 throw new java.io.IOException(te);
6650 }
6651 }
6652
6653 private static class checkAndPut_resultStandardSchemeFactory implements SchemeFactory {
6654 public checkAndPut_resultStandardScheme getScheme() {
6655 return new checkAndPut_resultStandardScheme();
6656 }
6657 }
6658
6659 private static class checkAndPut_resultStandardScheme extends StandardScheme<checkAndPut_result> {
6660
6661 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6662 org.apache.thrift.protocol.TField schemeField;
6663 iprot.readStructBegin();
6664 while (true)
6665 {
6666 schemeField = iprot.readFieldBegin();
6667 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6668 break;
6669 }
6670 switch (schemeField.id) {
6671 case 0:
6672 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
6673 struct.success = iprot.readBool();
6674 struct.setSuccessIsSet(true);
6675 } else {
6676 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6677 }
6678 break;
6679 case 1:
6680 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6681 struct.io = new TIOError();
6682 struct.io.read(iprot);
6683 struct.setIoIsSet(true);
6684 } else {
6685 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6686 }
6687 break;
6688 default:
6689 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6690 }
6691 iprot.readFieldEnd();
6692 }
6693 iprot.readStructEnd();
6694
6695
6696 struct.validate();
6697 }
6698
6699 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6700 struct.validate();
6701
6702 oprot.writeStructBegin(STRUCT_DESC);
6703 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6704 oprot.writeBool(struct.success);
6705 oprot.writeFieldEnd();
6706 if (struct.io != null) {
6707 oprot.writeFieldBegin(IO_FIELD_DESC);
6708 struct.io.write(oprot);
6709 oprot.writeFieldEnd();
6710 }
6711 oprot.writeFieldStop();
6712 oprot.writeStructEnd();
6713 }
6714
6715 }
6716
6717 private static class checkAndPut_resultTupleSchemeFactory implements SchemeFactory {
6718 public checkAndPut_resultTupleScheme getScheme() {
6719 return new checkAndPut_resultTupleScheme();
6720 }
6721 }
6722
6723 private static class checkAndPut_resultTupleScheme extends TupleScheme<checkAndPut_result> {
6724
6725 @Override
6726 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6727 TTupleProtocol oprot = (TTupleProtocol) prot;
6728 BitSet optionals = new BitSet();
6729 if (struct.isSetSuccess()) {
6730 optionals.set(0);
6731 }
6732 if (struct.isSetIo()) {
6733 optionals.set(1);
6734 }
6735 oprot.writeBitSet(optionals, 2);
6736 if (struct.isSetSuccess()) {
6737 oprot.writeBool(struct.success);
6738 }
6739 if (struct.isSetIo()) {
6740 struct.io.write(oprot);
6741 }
6742 }
6743
6744 @Override
6745 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6746 TTupleProtocol iprot = (TTupleProtocol) prot;
6747 BitSet incoming = iprot.readBitSet(2);
6748 if (incoming.get(0)) {
6749 struct.success = iprot.readBool();
6750 struct.setSuccessIsSet(true);
6751 }
6752 if (incoming.get(1)) {
6753 struct.io = new TIOError();
6754 struct.io.read(iprot);
6755 struct.setIoIsSet(true);
6756 }
6757 }
6758 }
6759
6760 }
6761
6762 public static class putMultiple_args implements org.apache.thrift.TBase<putMultiple_args, putMultiple_args._Fields>, java.io.Serializable, Cloneable {
6763 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_args");
6764
6765 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);
6766 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);
6767
6768 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6769 static {
6770 schemes.put(StandardScheme.class, new putMultiple_argsStandardSchemeFactory());
6771 schemes.put(TupleScheme.class, new putMultiple_argsTupleSchemeFactory());
6772 }
6773
6774
6775
6776
6777 public ByteBuffer table;
6778
6779
6780
6781 public List<TPut> puts;
6782
6783
6784 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6785
6786
6787
6788 TABLE((short)1, "table"),
6789
6790
6791
6792 PUTS((short)2, "puts");
6793
6794 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6795
6796 static {
6797 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6798 byName.put(field.getFieldName(), field);
6799 }
6800 }
6801
6802
6803
6804
6805 public static _Fields findByThriftId(int fieldId) {
6806 switch(fieldId) {
6807 case 1:
6808 return TABLE;
6809 case 2:
6810 return PUTS;
6811 default:
6812 return null;
6813 }
6814 }
6815
6816
6817
6818
6819
6820 public static _Fields findByThriftIdOrThrow(int fieldId) {
6821 _Fields fields = findByThriftId(fieldId);
6822 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6823 return fields;
6824 }
6825
6826
6827
6828
6829 public static _Fields findByName(String name) {
6830 return byName.get(name);
6831 }
6832
6833 private final short _thriftId;
6834 private final String _fieldName;
6835
6836 _Fields(short thriftId, String fieldName) {
6837 _thriftId = thriftId;
6838 _fieldName = fieldName;
6839 }
6840
6841 public short getThriftFieldId() {
6842 return _thriftId;
6843 }
6844
6845 public String getFieldName() {
6846 return _fieldName;
6847 }
6848 }
6849
6850
6851 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6852 static {
6853 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6854 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
6855 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
6856 tmpMap.put(_Fields.PUTS, new org.apache.thrift.meta_data.FieldMetaData("puts", org.apache.thrift.TFieldRequirementType.REQUIRED,
6857 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
6858 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class))));
6859 metaDataMap = Collections.unmodifiableMap(tmpMap);
6860 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_args.class, metaDataMap);
6861 }
6862
6863 public putMultiple_args() {
6864 }
6865
6866 public putMultiple_args(
6867 ByteBuffer table,
6868 List<TPut> puts)
6869 {
6870 this();
6871 this.table = table;
6872 this.puts = puts;
6873 }
6874
6875
6876
6877
6878 public putMultiple_args(putMultiple_args other) {
6879 if (other.isSetTable()) {
6880 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
6881 ;
6882 }
6883 if (other.isSetPuts()) {
6884 List<TPut> __this__puts = new ArrayList<TPut>();
6885 for (TPut other_element : other.puts) {
6886 __this__puts.add(new TPut(other_element));
6887 }
6888 this.puts = __this__puts;
6889 }
6890 }
6891
6892 public putMultiple_args deepCopy() {
6893 return new putMultiple_args(this);
6894 }
6895
6896 @Override
6897 public void clear() {
6898 this.table = null;
6899 this.puts = null;
6900 }
6901
6902
6903
6904
6905 public byte[] getTable() {
6906 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
6907 return table == null ? null : table.array();
6908 }
6909
6910 public ByteBuffer bufferForTable() {
6911 return table;
6912 }
6913
6914
6915
6916
6917 public putMultiple_args setTable(byte[] table) {
6918 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
6919 return this;
6920 }
6921
6922 public putMultiple_args setTable(ByteBuffer table) {
6923 this.table = table;
6924 return this;
6925 }
6926
6927 public void unsetTable() {
6928 this.table = null;
6929 }
6930
6931
6932 public boolean isSetTable() {
6933 return this.table != null;
6934 }
6935
6936 public void setTableIsSet(boolean value) {
6937 if (!value) {
6938 this.table = null;
6939 }
6940 }
6941
6942 public int getPutsSize() {
6943 return (this.puts == null) ? 0 : this.puts.size();
6944 }
6945
6946 public java.util.Iterator<TPut> getPutsIterator() {
6947 return (this.puts == null) ? null : this.puts.iterator();
6948 }
6949
6950 public void addToPuts(TPut elem) {
6951 if (this.puts == null) {
6952 this.puts = new ArrayList<TPut>();
6953 }
6954 this.puts.add(elem);
6955 }
6956
6957
6958
6959
6960 public List<TPut> getPuts() {
6961 return this.puts;
6962 }
6963
6964
6965
6966
6967 public putMultiple_args setPuts(List<TPut> puts) {
6968 this.puts = puts;
6969 return this;
6970 }
6971
6972 public void unsetPuts() {
6973 this.puts = null;
6974 }
6975
6976
6977 public boolean isSetPuts() {
6978 return this.puts != null;
6979 }
6980
6981 public void setPutsIsSet(boolean value) {
6982 if (!value) {
6983 this.puts = null;
6984 }
6985 }
6986
6987 public void setFieldValue(_Fields field, Object value) {
6988 switch (field) {
6989 case TABLE:
6990 if (value == null) {
6991 unsetTable();
6992 } else {
6993 setTable((ByteBuffer)value);
6994 }
6995 break;
6996
6997 case PUTS:
6998 if (value == null) {
6999 unsetPuts();
7000 } else {
7001 setPuts((List<TPut>)value);
7002 }
7003 break;
7004
7005 }
7006 }
7007
7008 public Object getFieldValue(_Fields field) {
7009 switch (field) {
7010 case TABLE:
7011 return getTable();
7012
7013 case PUTS:
7014 return getPuts();
7015
7016 }
7017 throw new IllegalStateException();
7018 }
7019
7020
7021 public boolean isSet(_Fields field) {
7022 if (field == null) {
7023 throw new IllegalArgumentException();
7024 }
7025
7026 switch (field) {
7027 case TABLE:
7028 return isSetTable();
7029 case PUTS:
7030 return isSetPuts();
7031 }
7032 throw new IllegalStateException();
7033 }
7034
7035 @Override
7036 public boolean equals(Object that) {
7037 if (that == null)
7038 return false;
7039 if (that instanceof putMultiple_args)
7040 return this.equals((putMultiple_args)that);
7041 return false;
7042 }
7043
7044 public boolean equals(putMultiple_args that) {
7045 if (that == null)
7046 return false;
7047
7048 boolean this_present_table = true && this.isSetTable();
7049 boolean that_present_table = true && that.isSetTable();
7050 if (this_present_table || that_present_table) {
7051 if (!(this_present_table && that_present_table))
7052 return false;
7053 if (!this.table.equals(that.table))
7054 return false;
7055 }
7056
7057 boolean this_present_puts = true && this.isSetPuts();
7058 boolean that_present_puts = true && that.isSetPuts();
7059 if (this_present_puts || that_present_puts) {
7060 if (!(this_present_puts && that_present_puts))
7061 return false;
7062 if (!this.puts.equals(that.puts))
7063 return false;
7064 }
7065
7066 return true;
7067 }
7068
7069 @Override
7070 public int hashCode() {
7071 return 0;
7072 }
7073
7074 public int compareTo(putMultiple_args other) {
7075 if (!getClass().equals(other.getClass())) {
7076 return getClass().getName().compareTo(other.getClass().getName());
7077 }
7078
7079 int lastComparison = 0;
7080 putMultiple_args typedOther = (putMultiple_args)other;
7081
7082 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
7083 if (lastComparison != 0) {
7084 return lastComparison;
7085 }
7086 if (isSetTable()) {
7087 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
7088 if (lastComparison != 0) {
7089 return lastComparison;
7090 }
7091 }
7092 lastComparison = Boolean.valueOf(isSetPuts()).compareTo(typedOther.isSetPuts());
7093 if (lastComparison != 0) {
7094 return lastComparison;
7095 }
7096 if (isSetPuts()) {
7097 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.puts, typedOther.puts);
7098 if (lastComparison != 0) {
7099 return lastComparison;
7100 }
7101 }
7102 return 0;
7103 }
7104
7105 public _Fields fieldForId(int fieldId) {
7106 return _Fields.findByThriftId(fieldId);
7107 }
7108
7109 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7110 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7111 }
7112
7113 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7114 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7115 }
7116
7117 @Override
7118 public String toString() {
7119 StringBuilder sb = new StringBuilder("putMultiple_args(");
7120 boolean first = true;
7121
7122 sb.append("table:");
7123 if (this.table == null) {
7124 sb.append("null");
7125 } else {
7126 org.apache.thrift.TBaseHelper.toString(this.table, sb);
7127 }
7128 first = false;
7129 if (!first) sb.append(", ");
7130 sb.append("puts:");
7131 if (this.puts == null) {
7132 sb.append("null");
7133 } else {
7134 sb.append(this.puts);
7135 }
7136 first = false;
7137 sb.append(")");
7138 return sb.toString();
7139 }
7140
7141 public void validate() throws org.apache.thrift.TException {
7142
7143 if (table == null) {
7144 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
7145 }
7146 if (puts == null) {
7147 throw new org.apache.thrift.protocol.TProtocolException("Required field 'puts' was not present! Struct: " + toString());
7148 }
7149 }
7150
7151 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7152 try {
7153 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7154 } catch (org.apache.thrift.TException te) {
7155 throw new java.io.IOException(te);
7156 }
7157 }
7158
7159 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7160 try {
7161 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7162 } catch (org.apache.thrift.TException te) {
7163 throw new java.io.IOException(te);
7164 }
7165 }
7166
7167 private static class putMultiple_argsStandardSchemeFactory implements SchemeFactory {
7168 public putMultiple_argsStandardScheme getScheme() {
7169 return new putMultiple_argsStandardScheme();
7170 }
7171 }
7172
7173 private static class putMultiple_argsStandardScheme extends StandardScheme<putMultiple_args> {
7174
7175 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_args struct) throws org.apache.thrift.TException {
7176 org.apache.thrift.protocol.TField schemeField;
7177 iprot.readStructBegin();
7178 while (true)
7179 {
7180 schemeField = iprot.readFieldBegin();
7181 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7182 break;
7183 }
7184 switch (schemeField.id) {
7185 case 1:
7186 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
7187 struct.table = iprot.readBinary();
7188 struct.setTableIsSet(true);
7189 } else {
7190 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7191 }
7192 break;
7193 case 2:
7194 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
7195 {
7196 org.apache.thrift.protocol.TList _list112 = iprot.readListBegin();
7197 struct.puts = new ArrayList<TPut>(_list112.size);
7198 for (int _i113 = 0; _i113 < _list112.size; ++_i113)
7199 {
7200 TPut _elem114;
7201 _elem114 = new TPut();
7202 _elem114.read(iprot);
7203 struct.puts.add(_elem114);
7204 }
7205 iprot.readListEnd();
7206 }
7207 struct.setPutsIsSet(true);
7208 } else {
7209 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7210 }
7211 break;
7212 default:
7213 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7214 }
7215 iprot.readFieldEnd();
7216 }
7217 iprot.readStructEnd();
7218
7219
7220 struct.validate();
7221 }
7222
7223 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_args struct) throws org.apache.thrift.TException {
7224 struct.validate();
7225
7226 oprot.writeStructBegin(STRUCT_DESC);
7227 if (struct.table != null) {
7228 oprot.writeFieldBegin(TABLE_FIELD_DESC);
7229 oprot.writeBinary(struct.table);
7230 oprot.writeFieldEnd();
7231 }
7232 if (struct.puts != null) {
7233 oprot.writeFieldBegin(PUTS_FIELD_DESC);
7234 {
7235 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.puts.size()));
7236 for (TPut _iter115 : struct.puts)
7237 {
7238 _iter115.write(oprot);
7239 }
7240 oprot.writeListEnd();
7241 }
7242 oprot.writeFieldEnd();
7243 }
7244 oprot.writeFieldStop();
7245 oprot.writeStructEnd();
7246 }
7247
7248 }
7249
7250 private static class putMultiple_argsTupleSchemeFactory implements SchemeFactory {
7251 public putMultiple_argsTupleScheme getScheme() {
7252 return new putMultiple_argsTupleScheme();
7253 }
7254 }
7255
7256 private static class putMultiple_argsTupleScheme extends TupleScheme<putMultiple_args> {
7257
7258 @Override
7259 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7260 TTupleProtocol oprot = (TTupleProtocol) prot;
7261 oprot.writeBinary(struct.table);
7262 {
7263 oprot.writeI32(struct.puts.size());
7264 for (TPut _iter116 : struct.puts)
7265 {
7266 _iter116.write(oprot);
7267 }
7268 }
7269 }
7270
7271 @Override
7272 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7273 TTupleProtocol iprot = (TTupleProtocol) prot;
7274 struct.table = iprot.readBinary();
7275 struct.setTableIsSet(true);
7276 {
7277 org.apache.thrift.protocol.TList _list117 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
7278 struct.puts = new ArrayList<TPut>(_list117.size);
7279 for (int _i118 = 0; _i118 < _list117.size; ++_i118)
7280 {
7281 TPut _elem119;
7282 _elem119 = new TPut();
7283 _elem119.read(iprot);
7284 struct.puts.add(_elem119);
7285 }
7286 }
7287 struct.setPutsIsSet(true);
7288 }
7289 }
7290
7291 }
7292
7293 public static class putMultiple_result implements org.apache.thrift.TBase<putMultiple_result, putMultiple_result._Fields>, java.io.Serializable, Cloneable {
7294 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_result");
7295
7296 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);
7297
7298 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7299 static {
7300 schemes.put(StandardScheme.class, new putMultiple_resultStandardSchemeFactory());
7301 schemes.put(TupleScheme.class, new putMultiple_resultTupleSchemeFactory());
7302 }
7303
7304 public TIOError io;
7305
7306
7307 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7308 IO((short)1, "io");
7309
7310 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7311
7312 static {
7313 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7314 byName.put(field.getFieldName(), field);
7315 }
7316 }
7317
7318
7319
7320
7321 public static _Fields findByThriftId(int fieldId) {
7322 switch(fieldId) {
7323 case 1:
7324 return IO;
7325 default:
7326 return null;
7327 }
7328 }
7329
7330
7331
7332
7333
7334 public static _Fields findByThriftIdOrThrow(int fieldId) {
7335 _Fields fields = findByThriftId(fieldId);
7336 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7337 return fields;
7338 }
7339
7340
7341
7342
7343 public static _Fields findByName(String name) {
7344 return byName.get(name);
7345 }
7346
7347 private final short _thriftId;
7348 private final String _fieldName;
7349
7350 _Fields(short thriftId, String fieldName) {
7351 _thriftId = thriftId;
7352 _fieldName = fieldName;
7353 }
7354
7355 public short getThriftFieldId() {
7356 return _thriftId;
7357 }
7358
7359 public String getFieldName() {
7360 return _fieldName;
7361 }
7362 }
7363
7364
7365 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7366 static {
7367 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7368 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
7369 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
7370 metaDataMap = Collections.unmodifiableMap(tmpMap);
7371 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_result.class, metaDataMap);
7372 }
7373
7374 public putMultiple_result() {
7375 }
7376
7377 public putMultiple_result(
7378 TIOError io)
7379 {
7380 this();
7381 this.io = io;
7382 }
7383
7384
7385
7386
7387 public putMultiple_result(putMultiple_result other) {
7388 if (other.isSetIo()) {
7389 this.io = new TIOError(other.io);
7390 }
7391 }
7392
7393 public putMultiple_result deepCopy() {
7394 return new putMultiple_result(this);
7395 }
7396
7397 @Override
7398 public void clear() {
7399 this.io = null;
7400 }
7401
7402 public TIOError getIo() {
7403 return this.io;
7404 }
7405
7406 public putMultiple_result setIo(TIOError io) {
7407 this.io = io;
7408 return this;
7409 }
7410
7411 public void unsetIo() {
7412 this.io = null;
7413 }
7414
7415
7416 public boolean isSetIo() {
7417 return this.io != null;
7418 }
7419
7420 public void setIoIsSet(boolean value) {
7421 if (!value) {
7422 this.io = null;
7423 }
7424 }
7425
7426 public void setFieldValue(_Fields field, Object value) {
7427 switch (field) {
7428 case IO:
7429 if (value == null) {
7430 unsetIo();
7431 } else {
7432 setIo((TIOError)value);
7433 }
7434 break;
7435
7436 }
7437 }
7438
7439 public Object getFieldValue(_Fields field) {
7440 switch (field) {
7441 case IO:
7442 return getIo();
7443
7444 }
7445 throw new IllegalStateException();
7446 }
7447
7448
7449 public boolean isSet(_Fields field) {
7450 if (field == null) {
7451 throw new IllegalArgumentException();
7452 }
7453
7454 switch (field) {
7455 case IO:
7456 return isSetIo();
7457 }
7458 throw new IllegalStateException();
7459 }
7460
7461 @Override
7462 public boolean equals(Object that) {
7463 if (that == null)
7464 return false;
7465 if (that instanceof putMultiple_result)
7466 return this.equals((putMultiple_result)that);
7467 return false;
7468 }
7469
7470 public boolean equals(putMultiple_result that) {
7471 if (that == null)
7472 return false;
7473
7474 boolean this_present_io = true && this.isSetIo();
7475 boolean that_present_io = true && that.isSetIo();
7476 if (this_present_io || that_present_io) {
7477 if (!(this_present_io && that_present_io))
7478 return false;
7479 if (!this.io.equals(that.io))
7480 return false;
7481 }
7482
7483 return true;
7484 }
7485
7486 @Override
7487 public int hashCode() {
7488 return 0;
7489 }
7490
7491 public int compareTo(putMultiple_result other) {
7492 if (!getClass().equals(other.getClass())) {
7493 return getClass().getName().compareTo(other.getClass().getName());
7494 }
7495
7496 int lastComparison = 0;
7497 putMultiple_result typedOther = (putMultiple_result)other;
7498
7499 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
7500 if (lastComparison != 0) {
7501 return lastComparison;
7502 }
7503 if (isSetIo()) {
7504 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
7505 if (lastComparison != 0) {
7506 return lastComparison;
7507 }
7508 }
7509 return 0;
7510 }
7511
7512 public _Fields fieldForId(int fieldId) {
7513 return _Fields.findByThriftId(fieldId);
7514 }
7515
7516 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7517 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7518 }
7519
7520 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7521 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7522 }
7523
7524 @Override
7525 public String toString() {
7526 StringBuilder sb = new StringBuilder("putMultiple_result(");
7527 boolean first = true;
7528
7529 sb.append("io:");
7530 if (this.io == null) {
7531 sb.append("null");
7532 } else {
7533 sb.append(this.io);
7534 }
7535 first = false;
7536 sb.append(")");
7537 return sb.toString();
7538 }
7539
7540 public void validate() throws org.apache.thrift.TException {
7541
7542 }
7543
7544 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7545 try {
7546 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7547 } catch (org.apache.thrift.TException te) {
7548 throw new java.io.IOException(te);
7549 }
7550 }
7551
7552 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7553 try {
7554 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7555 } catch (org.apache.thrift.TException te) {
7556 throw new java.io.IOException(te);
7557 }
7558 }
7559
7560 private static class putMultiple_resultStandardSchemeFactory implements SchemeFactory {
7561 public putMultiple_resultStandardScheme getScheme() {
7562 return new putMultiple_resultStandardScheme();
7563 }
7564 }
7565
7566 private static class putMultiple_resultStandardScheme extends StandardScheme<putMultiple_result> {
7567
7568 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_result struct) throws org.apache.thrift.TException {
7569 org.apache.thrift.protocol.TField schemeField;
7570 iprot.readStructBegin();
7571 while (true)
7572 {
7573 schemeField = iprot.readFieldBegin();
7574 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7575 break;
7576 }
7577 switch (schemeField.id) {
7578 case 1:
7579 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
7580 struct.io = new TIOError();
7581 struct.io.read(iprot);
7582 struct.setIoIsSet(true);
7583 } else {
7584 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7585 }
7586 break;
7587 default:
7588 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7589 }
7590 iprot.readFieldEnd();
7591 }
7592 iprot.readStructEnd();
7593
7594
7595 struct.validate();
7596 }
7597
7598 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_result struct) throws org.apache.thrift.TException {
7599 struct.validate();
7600
7601 oprot.writeStructBegin(STRUCT_DESC);
7602 if (struct.io != null) {
7603 oprot.writeFieldBegin(IO_FIELD_DESC);
7604 struct.io.write(oprot);
7605 oprot.writeFieldEnd();
7606 }
7607 oprot.writeFieldStop();
7608 oprot.writeStructEnd();
7609 }
7610
7611 }
7612
7613 private static class putMultiple_resultTupleSchemeFactory implements SchemeFactory {
7614 public putMultiple_resultTupleScheme getScheme() {
7615 return new putMultiple_resultTupleScheme();
7616 }
7617 }
7618
7619 private static class putMultiple_resultTupleScheme extends TupleScheme<putMultiple_result> {
7620
7621 @Override
7622 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7623 TTupleProtocol oprot = (TTupleProtocol) prot;
7624 BitSet optionals = new BitSet();
7625 if (struct.isSetIo()) {
7626 optionals.set(0);
7627 }
7628 oprot.writeBitSet(optionals, 1);
7629 if (struct.isSetIo()) {
7630 struct.io.write(oprot);
7631 }
7632 }
7633
7634 @Override
7635 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7636 TTupleProtocol iprot = (TTupleProtocol) prot;
7637 BitSet incoming = iprot.readBitSet(1);
7638 if (incoming.get(0)) {
7639 struct.io = new TIOError();
7640 struct.io.read(iprot);
7641 struct.setIoIsSet(true);
7642 }
7643 }
7644 }
7645
7646 }
7647
7648 public static class deleteSingle_args implements org.apache.thrift.TBase<deleteSingle_args, deleteSingle_args._Fields>, java.io.Serializable, Cloneable {
7649 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_args");
7650
7651 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);
7652 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);
7653
7654 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7655 static {
7656 schemes.put(StandardScheme.class, new deleteSingle_argsStandardSchemeFactory());
7657 schemes.put(TupleScheme.class, new deleteSingle_argsTupleSchemeFactory());
7658 }
7659
7660
7661
7662
7663 public ByteBuffer table;
7664
7665
7666
7667 public TDelete deleteSingle;
7668
7669
7670 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7671
7672
7673
7674 TABLE((short)1, "table"),
7675
7676
7677
7678 DELETE_SINGLE((short)2, "deleteSingle");
7679
7680 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7681
7682 static {
7683 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7684 byName.put(field.getFieldName(), field);
7685 }
7686 }
7687
7688
7689
7690
7691 public static _Fields findByThriftId(int fieldId) {
7692 switch(fieldId) {
7693 case 1:
7694 return TABLE;
7695 case 2:
7696 return DELETE_SINGLE;
7697 default:
7698 return null;
7699 }
7700 }
7701
7702
7703
7704
7705
7706 public static _Fields findByThriftIdOrThrow(int fieldId) {
7707 _Fields fields = findByThriftId(fieldId);
7708 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7709 return fields;
7710 }
7711
7712
7713
7714
7715 public static _Fields findByName(String name) {
7716 return byName.get(name);
7717 }
7718
7719 private final short _thriftId;
7720 private final String _fieldName;
7721
7722 _Fields(short thriftId, String fieldName) {
7723 _thriftId = thriftId;
7724 _fieldName = fieldName;
7725 }
7726
7727 public short getThriftFieldId() {
7728 return _thriftId;
7729 }
7730
7731 public String getFieldName() {
7732 return _fieldName;
7733 }
7734 }
7735
7736
7737 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7738 static {
7739 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7740 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
7741 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
7742 tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED,
7743 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
7744 metaDataMap = Collections.unmodifiableMap(tmpMap);
7745 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_args.class, metaDataMap);
7746 }
7747
7748 public deleteSingle_args() {
7749 }
7750
7751 public deleteSingle_args(
7752 ByteBuffer table,
7753 TDelete deleteSingle)
7754 {
7755 this();
7756 this.table = table;
7757 this.deleteSingle = deleteSingle;
7758 }
7759
7760
7761
7762
7763 public deleteSingle_args(deleteSingle_args other) {
7764 if (other.isSetTable()) {
7765 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
7766 ;
7767 }
7768 if (other.isSetDeleteSingle()) {
7769 this.deleteSingle = new TDelete(other.deleteSingle);
7770 }
7771 }
7772
7773 public deleteSingle_args deepCopy() {
7774 return new deleteSingle_args(this);
7775 }
7776
7777 @Override
7778 public void clear() {
7779 this.table = null;
7780 this.deleteSingle = null;
7781 }
7782
7783
7784
7785
7786 public byte[] getTable() {
7787 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
7788 return table == null ? null : table.array();
7789 }
7790
7791 public ByteBuffer bufferForTable() {
7792 return table;
7793 }
7794
7795
7796
7797
7798 public deleteSingle_args setTable(byte[] table) {
7799 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
7800 return this;
7801 }
7802
7803 public deleteSingle_args setTable(ByteBuffer table) {
7804 this.table = table;
7805 return this;
7806 }
7807
7808 public void unsetTable() {
7809 this.table = null;
7810 }
7811
7812
7813 public boolean isSetTable() {
7814 return this.table != null;
7815 }
7816
7817 public void setTableIsSet(boolean value) {
7818 if (!value) {
7819 this.table = null;
7820 }
7821 }
7822
7823
7824
7825
7826 public TDelete getDeleteSingle() {
7827 return this.deleteSingle;
7828 }
7829
7830
7831
7832
7833 public deleteSingle_args setDeleteSingle(TDelete deleteSingle) {
7834 this.deleteSingle = deleteSingle;
7835 return this;
7836 }
7837
7838 public void unsetDeleteSingle() {
7839 this.deleteSingle = null;
7840 }
7841
7842
7843 public boolean isSetDeleteSingle() {
7844 return this.deleteSingle != null;
7845 }
7846
7847 public void setDeleteSingleIsSet(boolean value) {
7848 if (!value) {
7849 this.deleteSingle = null;
7850 }
7851 }
7852
7853 public void setFieldValue(_Fields field, Object value) {
7854 switch (field) {
7855 case TABLE:
7856 if (value == null) {
7857 unsetTable();
7858 } else {
7859 setTable((ByteBuffer)value);
7860 }
7861 break;
7862
7863 case DELETE_SINGLE:
7864 if (value == null) {
7865 unsetDeleteSingle();
7866 } else {
7867 setDeleteSingle((TDelete)value);
7868 }
7869 break;
7870
7871 }
7872 }
7873
7874 public Object getFieldValue(_Fields field) {
7875 switch (field) {
7876 case TABLE:
7877 return getTable();
7878
7879 case DELETE_SINGLE:
7880 return getDeleteSingle();
7881
7882 }
7883 throw new IllegalStateException();
7884 }
7885
7886
7887 public boolean isSet(_Fields field) {
7888 if (field == null) {
7889 throw new IllegalArgumentException();
7890 }
7891
7892 switch (field) {
7893 case TABLE:
7894 return isSetTable();
7895 case DELETE_SINGLE:
7896 return isSetDeleteSingle();
7897 }
7898 throw new IllegalStateException();
7899 }
7900
7901 @Override
7902 public boolean equals(Object that) {
7903 if (that == null)
7904 return false;
7905 if (that instanceof deleteSingle_args)
7906 return this.equals((deleteSingle_args)that);
7907 return false;
7908 }
7909
7910 public boolean equals(deleteSingle_args that) {
7911 if (that == null)
7912 return false;
7913
7914 boolean this_present_table = true && this.isSetTable();
7915 boolean that_present_table = true && that.isSetTable();
7916 if (this_present_table || that_present_table) {
7917 if (!(this_present_table && that_present_table))
7918 return false;
7919 if (!this.table.equals(that.table))
7920 return false;
7921 }
7922
7923 boolean this_present_deleteSingle = true && this.isSetDeleteSingle();
7924 boolean that_present_deleteSingle = true && that.isSetDeleteSingle();
7925 if (this_present_deleteSingle || that_present_deleteSingle) {
7926 if (!(this_present_deleteSingle && that_present_deleteSingle))
7927 return false;
7928 if (!this.deleteSingle.equals(that.deleteSingle))
7929 return false;
7930 }
7931
7932 return true;
7933 }
7934
7935 @Override
7936 public int hashCode() {
7937 return 0;
7938 }
7939
7940 public int compareTo(deleteSingle_args other) {
7941 if (!getClass().equals(other.getClass())) {
7942 return getClass().getName().compareTo(other.getClass().getName());
7943 }
7944
7945 int lastComparison = 0;
7946 deleteSingle_args typedOther = (deleteSingle_args)other;
7947
7948 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
7949 if (lastComparison != 0) {
7950 return lastComparison;
7951 }
7952 if (isSetTable()) {
7953 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
7954 if (lastComparison != 0) {
7955 return lastComparison;
7956 }
7957 }
7958 lastComparison = Boolean.valueOf(isSetDeleteSingle()).compareTo(typedOther.isSetDeleteSingle());
7959 if (lastComparison != 0) {
7960 return lastComparison;
7961 }
7962 if (isSetDeleteSingle()) {
7963 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteSingle, typedOther.deleteSingle);
7964 if (lastComparison != 0) {
7965 return lastComparison;
7966 }
7967 }
7968 return 0;
7969 }
7970
7971 public _Fields fieldForId(int fieldId) {
7972 return _Fields.findByThriftId(fieldId);
7973 }
7974
7975 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7976 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7977 }
7978
7979 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7980 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7981 }
7982
7983 @Override
7984 public String toString() {
7985 StringBuilder sb = new StringBuilder("deleteSingle_args(");
7986 boolean first = true;
7987
7988 sb.append("table:");
7989 if (this.table == null) {
7990 sb.append("null");
7991 } else {
7992 org.apache.thrift.TBaseHelper.toString(this.table, sb);
7993 }
7994 first = false;
7995 if (!first) sb.append(", ");
7996 sb.append("deleteSingle:");
7997 if (this.deleteSingle == null) {
7998 sb.append("null");
7999 } else {
8000 sb.append(this.deleteSingle);
8001 }
8002 first = false;
8003 sb.append(")");
8004 return sb.toString();
8005 }
8006
8007 public void validate() throws org.apache.thrift.TException {
8008
8009 if (table == null) {
8010 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
8011 }
8012 if (deleteSingle == null) {
8013 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deleteSingle' was not present! Struct: " + toString());
8014 }
8015 }
8016
8017 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8018 try {
8019 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8020 } catch (org.apache.thrift.TException te) {
8021 throw new java.io.IOException(te);
8022 }
8023 }
8024
8025 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8026 try {
8027 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8028 } catch (org.apache.thrift.TException te) {
8029 throw new java.io.IOException(te);
8030 }
8031 }
8032
8033 private static class deleteSingle_argsStandardSchemeFactory implements SchemeFactory {
8034 public deleteSingle_argsStandardScheme getScheme() {
8035 return new deleteSingle_argsStandardScheme();
8036 }
8037 }
8038
8039 private static class deleteSingle_argsStandardScheme extends StandardScheme<deleteSingle_args> {
8040
8041 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_args struct) throws org.apache.thrift.TException {
8042 org.apache.thrift.protocol.TField schemeField;
8043 iprot.readStructBegin();
8044 while (true)
8045 {
8046 schemeField = iprot.readFieldBegin();
8047 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
8048 break;
8049 }
8050 switch (schemeField.id) {
8051 case 1:
8052 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
8053 struct.table = iprot.readBinary();
8054 struct.setTableIsSet(true);
8055 } else {
8056 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8057 }
8058 break;
8059 case 2:
8060 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
8061 struct.deleteSingle = new TDelete();
8062 struct.deleteSingle.read(iprot);
8063 struct.setDeleteSingleIsSet(true);
8064 } else {
8065 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8066 }
8067 break;
8068 default:
8069 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8070 }
8071 iprot.readFieldEnd();
8072 }
8073 iprot.readStructEnd();
8074
8075
8076 struct.validate();
8077 }
8078
8079 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_args struct) throws org.apache.thrift.TException {
8080 struct.validate();
8081
8082 oprot.writeStructBegin(STRUCT_DESC);
8083 if (struct.table != null) {
8084 oprot.writeFieldBegin(TABLE_FIELD_DESC);
8085 oprot.writeBinary(struct.table);
8086 oprot.writeFieldEnd();
8087 }
8088 if (struct.deleteSingle != null) {
8089 oprot.writeFieldBegin(DELETE_SINGLE_FIELD_DESC);
8090 struct.deleteSingle.write(oprot);
8091 oprot.writeFieldEnd();
8092 }
8093 oprot.writeFieldStop();
8094 oprot.writeStructEnd();
8095 }
8096
8097 }
8098
8099 private static class deleteSingle_argsTupleSchemeFactory implements SchemeFactory {
8100 public deleteSingle_argsTupleScheme getScheme() {
8101 return new deleteSingle_argsTupleScheme();
8102 }
8103 }
8104
8105 private static class deleteSingle_argsTupleScheme extends TupleScheme<deleteSingle_args> {
8106
8107 @Override
8108 public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
8109 TTupleProtocol oprot = (TTupleProtocol) prot;
8110 oprot.writeBinary(struct.table);
8111 struct.deleteSingle.write(oprot);
8112 }
8113
8114 @Override
8115 public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
8116 TTupleProtocol iprot = (TTupleProtocol) prot;
8117 struct.table = iprot.readBinary();
8118 struct.setTableIsSet(true);
8119 struct.deleteSingle = new TDelete();
8120 struct.deleteSingle.read(iprot);
8121 struct.setDeleteSingleIsSet(true);
8122 }
8123 }
8124
8125 }
8126
8127 public static class deleteSingle_result implements org.apache.thrift.TBase<deleteSingle_result, deleteSingle_result._Fields>, java.io.Serializable, Cloneable {
8128 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_result");
8129
8130 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);
8131
8132 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8133 static {
8134 schemes.put(StandardScheme.class, new deleteSingle_resultStandardSchemeFactory());
8135 schemes.put(TupleScheme.class, new deleteSingle_resultTupleSchemeFactory());
8136 }
8137
8138 public TIOError io;
8139
8140
8141 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8142 IO((short)1, "io");
8143
8144 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8145
8146 static {
8147 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8148 byName.put(field.getFieldName(), field);
8149 }
8150 }
8151
8152
8153
8154
8155 public static _Fields findByThriftId(int fieldId) {
8156 switch(fieldId) {
8157 case 1:
8158 return IO;
8159 default:
8160 return null;
8161 }
8162 }
8163
8164
8165
8166
8167
8168 public static _Fields findByThriftIdOrThrow(int fieldId) {
8169 _Fields fields = findByThriftId(fieldId);
8170 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8171 return fields;
8172 }
8173
8174
8175
8176
8177 public static _Fields findByName(String name) {
8178 return byName.get(name);
8179 }
8180
8181 private final short _thriftId;
8182 private final String _fieldName;
8183
8184 _Fields(short thriftId, String fieldName) {
8185 _thriftId = thriftId;
8186 _fieldName = fieldName;
8187 }
8188
8189 public short getThriftFieldId() {
8190 return _thriftId;
8191 }
8192
8193 public String getFieldName() {
8194 return _fieldName;
8195 }
8196 }
8197
8198
8199 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8200 static {
8201 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8202 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
8203 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
8204 metaDataMap = Collections.unmodifiableMap(tmpMap);
8205 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_result.class, metaDataMap);
8206 }
8207
8208 public deleteSingle_result() {
8209 }
8210
8211 public deleteSingle_result(
8212 TIOError io)
8213 {
8214 this();
8215 this.io = io;
8216 }
8217
8218
8219
8220
8221 public deleteSingle_result(deleteSingle_result other) {
8222 if (other.isSetIo()) {
8223 this.io = new TIOError(other.io);
8224 }
8225 }
8226
8227 public deleteSingle_result deepCopy() {
8228 return new deleteSingle_result(this);
8229 }
8230
8231 @Override
8232 public void clear() {
8233 this.io = null;
8234 }
8235
8236 public TIOError getIo() {
8237 return this.io;
8238 }
8239
8240 public deleteSingle_result setIo(TIOError io) {
8241 this.io = io;
8242 return this;
8243 }
8244
8245 public void unsetIo() {
8246 this.io = null;
8247 }
8248
8249
8250 public boolean isSetIo() {
8251 return this.io != null;
8252 }
8253
8254 public void setIoIsSet(boolean value) {
8255 if (!value) {
8256 this.io = null;
8257 }
8258 }
8259
8260 public void setFieldValue(_Fields field, Object value) {
8261 switch (field) {
8262 case IO:
8263 if (value == null) {
8264 unsetIo();
8265 } else {
8266 setIo((TIOError)value);
8267 }
8268 break;
8269
8270 }
8271 }
8272
8273 public Object getFieldValue(_Fields field) {
8274 switch (field) {
8275 case IO:
8276 return getIo();
8277
8278 }
8279 throw new IllegalStateException();
8280 }
8281
8282
8283 public boolean isSet(_Fields field) {
8284 if (field == null) {
8285 throw new IllegalArgumentException();
8286 }
8287
8288 switch (field) {
8289 case IO:
8290 return isSetIo();
8291 }
8292 throw new IllegalStateException();
8293 }
8294
8295 @Override
8296 public boolean equals(Object that) {
8297 if (that == null)
8298 return false;
8299 if (that instanceof deleteSingle_result)
8300 return this.equals((deleteSingle_result)that);
8301 return false;
8302 }
8303
8304 public boolean equals(deleteSingle_result that) {
8305 if (that == null)
8306 return false;
8307
8308 boolean this_present_io = true && this.isSetIo();
8309 boolean that_present_io = true && that.isSetIo();
8310 if (this_present_io || that_present_io) {
8311 if (!(this_present_io && that_present_io))
8312 return false;
8313 if (!this.io.equals(that.io))
8314 return false;
8315 }
8316
8317 return true;
8318 }
8319
8320 @Override
8321 public int hashCode() {
8322 return 0;
8323 }
8324
8325 public int compareTo(deleteSingle_result other) {
8326 if (!getClass().equals(other.getClass())) {
8327 return getClass().getName().compareTo(other.getClass().getName());
8328 }
8329
8330 int lastComparison = 0;
8331 deleteSingle_result typedOther = (deleteSingle_result)other;
8332
8333 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
8334 if (lastComparison != 0) {
8335 return lastComparison;
8336 }
8337 if (isSetIo()) {
8338 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
8339 if (lastComparison != 0) {
8340 return lastComparison;
8341 }
8342 }
8343 return 0;
8344 }
8345
8346 public _Fields fieldForId(int fieldId) {
8347 return _Fields.findByThriftId(fieldId);
8348 }
8349
8350 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8351 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8352 }
8353
8354 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8355 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8356 }
8357
8358 @Override
8359 public String toString() {
8360 StringBuilder sb = new StringBuilder("deleteSingle_result(");
8361 boolean first = true;
8362
8363 sb.append("io:");
8364 if (this.io == null) {
8365 sb.append("null");
8366 } else {
8367 sb.append(this.io);
8368 }
8369 first = false;
8370 sb.append(")");
8371 return sb.toString();
8372 }
8373
8374 public void validate() throws org.apache.thrift.TException {
8375
8376 }
8377
8378 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8379 try {
8380 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8381 } catch (org.apache.thrift.TException te) {
8382 throw new java.io.IOException(te);
8383 }
8384 }
8385
8386 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8387 try {
8388 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8389 } catch (org.apache.thrift.TException te) {
8390 throw new java.io.IOException(te);
8391 }
8392 }
8393
8394 private static class deleteSingle_resultStandardSchemeFactory implements SchemeFactory {
8395 public deleteSingle_resultStandardScheme getScheme() {
8396 return new deleteSingle_resultStandardScheme();
8397 }
8398 }
8399
8400 private static class deleteSingle_resultStandardScheme extends StandardScheme<deleteSingle_result> {
8401
8402 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8403 org.apache.thrift.protocol.TField schemeField;
8404 iprot.readStructBegin();
8405 while (true)
8406 {
8407 schemeField = iprot.readFieldBegin();
8408 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
8409 break;
8410 }
8411 switch (schemeField.id) {
8412 case 1:
8413 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
8414 struct.io = new TIOError();
8415 struct.io.read(iprot);
8416 struct.setIoIsSet(true);
8417 } else {
8418 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8419 }
8420 break;
8421 default:
8422 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8423 }
8424 iprot.readFieldEnd();
8425 }
8426 iprot.readStructEnd();
8427
8428
8429 struct.validate();
8430 }
8431
8432 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8433 struct.validate();
8434
8435 oprot.writeStructBegin(STRUCT_DESC);
8436 if (struct.io != null) {
8437 oprot.writeFieldBegin(IO_FIELD_DESC);
8438 struct.io.write(oprot);
8439 oprot.writeFieldEnd();
8440 }
8441 oprot.writeFieldStop();
8442 oprot.writeStructEnd();
8443 }
8444
8445 }
8446
8447 private static class deleteSingle_resultTupleSchemeFactory implements SchemeFactory {
8448 public deleteSingle_resultTupleScheme getScheme() {
8449 return new deleteSingle_resultTupleScheme();
8450 }
8451 }
8452
8453 private static class deleteSingle_resultTupleScheme extends TupleScheme<deleteSingle_result> {
8454
8455 @Override
8456 public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8457 TTupleProtocol oprot = (TTupleProtocol) prot;
8458 BitSet optionals = new BitSet();
8459 if (struct.isSetIo()) {
8460 optionals.set(0);
8461 }
8462 oprot.writeBitSet(optionals, 1);
8463 if (struct.isSetIo()) {
8464 struct.io.write(oprot);
8465 }
8466 }
8467
8468 @Override
8469 public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8470 TTupleProtocol iprot = (TTupleProtocol) prot;
8471 BitSet incoming = iprot.readBitSet(1);
8472 if (incoming.get(0)) {
8473 struct.io = new TIOError();
8474 struct.io.read(iprot);
8475 struct.setIoIsSet(true);
8476 }
8477 }
8478 }
8479
8480 }
8481
8482 public static class deleteMultiple_args implements org.apache.thrift.TBase<deleteMultiple_args, deleteMultiple_args._Fields>, java.io.Serializable, Cloneable {
8483 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_args");
8484
8485 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);
8486 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);
8487
8488 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8489 static {
8490 schemes.put(StandardScheme.class, new deleteMultiple_argsStandardSchemeFactory());
8491 schemes.put(TupleScheme.class, new deleteMultiple_argsTupleSchemeFactory());
8492 }
8493
8494
8495
8496
8497 public ByteBuffer table;
8498
8499
8500
8501 public List<TDelete> deletes;
8502
8503
8504 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8505
8506
8507
8508 TABLE((short)1, "table"),
8509
8510
8511
8512 DELETES((short)2, "deletes");
8513
8514 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8515
8516 static {
8517 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8518 byName.put(field.getFieldName(), field);
8519 }
8520 }
8521
8522
8523
8524
8525 public static _Fields findByThriftId(int fieldId) {
8526 switch(fieldId) {
8527 case 1:
8528 return TABLE;
8529 case 2:
8530 return DELETES;
8531 default:
8532 return null;
8533 }
8534 }
8535
8536
8537
8538
8539
8540 public static _Fields findByThriftIdOrThrow(int fieldId) {
8541 _Fields fields = findByThriftId(fieldId);
8542 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8543 return fields;
8544 }
8545
8546
8547
8548
8549 public static _Fields findByName(String name) {
8550 return byName.get(name);
8551 }
8552
8553 private final short _thriftId;
8554 private final String _fieldName;
8555
8556 _Fields(short thriftId, String fieldName) {
8557 _thriftId = thriftId;
8558 _fieldName = fieldName;
8559 }
8560
8561 public short getThriftFieldId() {
8562 return _thriftId;
8563 }
8564
8565 public String getFieldName() {
8566 return _fieldName;
8567 }
8568 }
8569
8570
8571 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8572 static {
8573 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8574 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
8575 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
8576 tmpMap.put(_Fields.DELETES, new org.apache.thrift.meta_data.FieldMetaData("deletes", org.apache.thrift.TFieldRequirementType.REQUIRED,
8577 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
8578 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
8579 metaDataMap = Collections.unmodifiableMap(tmpMap);
8580 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_args.class, metaDataMap);
8581 }
8582
8583 public deleteMultiple_args() {
8584 }
8585
8586 public deleteMultiple_args(
8587 ByteBuffer table,
8588 List<TDelete> deletes)
8589 {
8590 this();
8591 this.table = table;
8592 this.deletes = deletes;
8593 }
8594
8595
8596
8597
8598 public deleteMultiple_args(deleteMultiple_args other) {
8599 if (other.isSetTable()) {
8600 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
8601 ;
8602 }
8603 if (other.isSetDeletes()) {
8604 List<TDelete> __this__deletes = new ArrayList<TDelete>();
8605 for (TDelete other_element : other.deletes) {
8606 __this__deletes.add(new TDelete(other_element));
8607 }
8608 this.deletes = __this__deletes;
8609 }
8610 }
8611
8612 public deleteMultiple_args deepCopy() {
8613 return new deleteMultiple_args(this);
8614 }
8615
8616 @Override
8617 public void clear() {
8618 this.table = null;
8619 this.deletes = null;
8620 }
8621
8622
8623
8624
8625 public byte[] getTable() {
8626 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
8627 return table == null ? null : table.array();
8628 }
8629
8630 public ByteBuffer bufferForTable() {
8631 return table;
8632 }
8633
8634
8635
8636
8637 public deleteMultiple_args setTable(byte[] table) {
8638 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
8639 return this;
8640 }
8641
8642 public deleteMultiple_args setTable(ByteBuffer table) {
8643 this.table = table;
8644 return this;
8645 }
8646
8647 public void unsetTable() {
8648 this.table = null;
8649 }
8650
8651
8652 public boolean isSetTable() {
8653 return this.table != null;
8654 }
8655
8656 public void setTableIsSet(boolean value) {
8657 if (!value) {
8658 this.table = null;
8659 }
8660 }
8661
8662 public int getDeletesSize() {
8663 return (this.deletes == null) ? 0 : this.deletes.size();
8664 }
8665
8666 public java.util.Iterator<TDelete> getDeletesIterator() {
8667 return (this.deletes == null) ? null : this.deletes.iterator();
8668 }
8669
8670 public void addToDeletes(TDelete elem) {
8671 if (this.deletes == null) {
8672 this.deletes = new ArrayList<TDelete>();
8673 }
8674 this.deletes.add(elem);
8675 }
8676
8677
8678
8679
8680 public List<TDelete> getDeletes() {
8681 return this.deletes;
8682 }
8683
8684
8685
8686
8687 public deleteMultiple_args setDeletes(List<TDelete> deletes) {
8688 this.deletes = deletes;
8689 return this;
8690 }
8691
8692 public void unsetDeletes() {
8693 this.deletes = null;
8694 }
8695
8696
8697 public boolean isSetDeletes() {
8698 return this.deletes != null;
8699 }
8700
8701 public void setDeletesIsSet(boolean value) {
8702 if (!value) {
8703 this.deletes = null;
8704 }
8705 }
8706
8707 public void setFieldValue(_Fields field, Object value) {
8708 switch (field) {
8709 case TABLE:
8710 if (value == null) {
8711 unsetTable();
8712 } else {
8713 setTable((ByteBuffer)value);
8714 }
8715 break;
8716
8717 case DELETES:
8718 if (value == null) {
8719 unsetDeletes();
8720 } else {
8721 setDeletes((List<TDelete>)value);
8722 }
8723 break;
8724
8725 }
8726 }
8727
8728 public Object getFieldValue(_Fields field) {
8729 switch (field) {
8730 case TABLE:
8731 return getTable();
8732
8733 case DELETES:
8734 return getDeletes();
8735
8736 }
8737 throw new IllegalStateException();
8738 }
8739
8740
8741 public boolean isSet(_Fields field) {
8742 if (field == null) {
8743 throw new IllegalArgumentException();
8744 }
8745
8746 switch (field) {
8747 case TABLE:
8748 return isSetTable();
8749 case DELETES:
8750 return isSetDeletes();
8751 }
8752 throw new IllegalStateException();
8753 }
8754
8755 @Override
8756 public boolean equals(Object that) {
8757 if (that == null)
8758 return false;
8759 if (that instanceof deleteMultiple_args)
8760 return this.equals((deleteMultiple_args)that);
8761 return false;
8762 }
8763
8764 public boolean equals(deleteMultiple_args that) {
8765 if (that == null)
8766 return false;
8767
8768 boolean this_present_table = true && this.isSetTable();
8769 boolean that_present_table = true && that.isSetTable();
8770 if (this_present_table || that_present_table) {
8771 if (!(this_present_table && that_present_table))
8772 return false;
8773 if (!this.table.equals(that.table))
8774 return false;
8775 }
8776
8777 boolean this_present_deletes = true && this.isSetDeletes();
8778 boolean that_present_deletes = true && that.isSetDeletes();
8779 if (this_present_deletes || that_present_deletes) {
8780 if (!(this_present_deletes && that_present_deletes))
8781 return false;
8782 if (!this.deletes.equals(that.deletes))
8783 return false;
8784 }
8785
8786 return true;
8787 }
8788
8789 @Override
8790 public int hashCode() {
8791 return 0;
8792 }
8793
8794 public int compareTo(deleteMultiple_args other) {
8795 if (!getClass().equals(other.getClass())) {
8796 return getClass().getName().compareTo(other.getClass().getName());
8797 }
8798
8799 int lastComparison = 0;
8800 deleteMultiple_args typedOther = (deleteMultiple_args)other;
8801
8802 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
8803 if (lastComparison != 0) {
8804 return lastComparison;
8805 }
8806 if (isSetTable()) {
8807 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
8808 if (lastComparison != 0) {
8809 return lastComparison;
8810 }
8811 }
8812 lastComparison = Boolean.valueOf(isSetDeletes()).compareTo(typedOther.isSetDeletes());
8813 if (lastComparison != 0) {
8814 return lastComparison;
8815 }
8816 if (isSetDeletes()) {
8817 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deletes, typedOther.deletes);
8818 if (lastComparison != 0) {
8819 return lastComparison;
8820 }
8821 }
8822 return 0;
8823 }
8824
8825 public _Fields fieldForId(int fieldId) {
8826 return _Fields.findByThriftId(fieldId);
8827 }
8828
8829 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8830 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8831 }
8832
8833 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8834 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8835 }
8836
8837 @Override
8838 public String toString() {
8839 StringBuilder sb = new StringBuilder("deleteMultiple_args(");
8840 boolean first = true;
8841
8842 sb.append("table:");
8843 if (this.table == null) {
8844 sb.append("null");
8845 } else {
8846 org.apache.thrift.TBaseHelper.toString(this.table, sb);
8847 }
8848 first = false;
8849 if (!first) sb.append(", ");
8850 sb.append("deletes:");
8851 if (this.deletes == null) {
8852 sb.append("null");
8853 } else {
8854 sb.append(this.deletes);
8855 }
8856 first = false;
8857 sb.append(")");
8858 return sb.toString();
8859 }
8860
8861 public void validate() throws org.apache.thrift.TException {
8862
8863 if (table == null) {
8864 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
8865 }
8866 if (deletes == null) {
8867 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deletes' was not present! Struct: " + toString());
8868 }
8869 }
8870
8871 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8872 try {
8873 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8874 } catch (org.apache.thrift.TException te) {
8875 throw new java.io.IOException(te);
8876 }
8877 }
8878
8879 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8880 try {
8881 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8882 } catch (org.apache.thrift.TException te) {
8883 throw new java.io.IOException(te);
8884 }
8885 }
8886
8887 private static class deleteMultiple_argsStandardSchemeFactory implements SchemeFactory {
8888 public deleteMultiple_argsStandardScheme getScheme() {
8889 return new deleteMultiple_argsStandardScheme();
8890 }
8891 }
8892
8893 private static class deleteMultiple_argsStandardScheme extends StandardScheme<deleteMultiple_args> {
8894
8895 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8896 org.apache.thrift.protocol.TField schemeField;
8897 iprot.readStructBegin();
8898 while (true)
8899 {
8900 schemeField = iprot.readFieldBegin();
8901 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
8902 break;
8903 }
8904 switch (schemeField.id) {
8905 case 1:
8906 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
8907 struct.table = iprot.readBinary();
8908 struct.setTableIsSet(true);
8909 } else {
8910 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8911 }
8912 break;
8913 case 2:
8914 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
8915 {
8916 org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
8917 struct.deletes = new ArrayList<TDelete>(_list120.size);
8918 for (int _i121 = 0; _i121 < _list120.size; ++_i121)
8919 {
8920 TDelete _elem122;
8921 _elem122 = new TDelete();
8922 _elem122.read(iprot);
8923 struct.deletes.add(_elem122);
8924 }
8925 iprot.readListEnd();
8926 }
8927 struct.setDeletesIsSet(true);
8928 } else {
8929 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8930 }
8931 break;
8932 default:
8933 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8934 }
8935 iprot.readFieldEnd();
8936 }
8937 iprot.readStructEnd();
8938
8939
8940 struct.validate();
8941 }
8942
8943 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8944 struct.validate();
8945
8946 oprot.writeStructBegin(STRUCT_DESC);
8947 if (struct.table != null) {
8948 oprot.writeFieldBegin(TABLE_FIELD_DESC);
8949 oprot.writeBinary(struct.table);
8950 oprot.writeFieldEnd();
8951 }
8952 if (struct.deletes != null) {
8953 oprot.writeFieldBegin(DELETES_FIELD_DESC);
8954 {
8955 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.deletes.size()));
8956 for (TDelete _iter123 : struct.deletes)
8957 {
8958 _iter123.write(oprot);
8959 }
8960 oprot.writeListEnd();
8961 }
8962 oprot.writeFieldEnd();
8963 }
8964 oprot.writeFieldStop();
8965 oprot.writeStructEnd();
8966 }
8967
8968 }
8969
8970 private static class deleteMultiple_argsTupleSchemeFactory implements SchemeFactory {
8971 public deleteMultiple_argsTupleScheme getScheme() {
8972 return new deleteMultiple_argsTupleScheme();
8973 }
8974 }
8975
8976 private static class deleteMultiple_argsTupleScheme extends TupleScheme<deleteMultiple_args> {
8977
8978 @Override
8979 public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8980 TTupleProtocol oprot = (TTupleProtocol) prot;
8981 oprot.writeBinary(struct.table);
8982 {
8983 oprot.writeI32(struct.deletes.size());
8984 for (TDelete _iter124 : struct.deletes)
8985 {
8986 _iter124.write(oprot);
8987 }
8988 }
8989 }
8990
8991 @Override
8992 public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8993 TTupleProtocol iprot = (TTupleProtocol) prot;
8994 struct.table = iprot.readBinary();
8995 struct.setTableIsSet(true);
8996 {
8997 org.apache.thrift.protocol.TList _list125 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
8998 struct.deletes = new ArrayList<TDelete>(_list125.size);
8999 for (int _i126 = 0; _i126 < _list125.size; ++_i126)
9000 {
9001 TDelete _elem127;
9002 _elem127 = new TDelete();
9003 _elem127.read(iprot);
9004 struct.deletes.add(_elem127);
9005 }
9006 }
9007 struct.setDeletesIsSet(true);
9008 }
9009 }
9010
9011 }
9012
9013 public static class deleteMultiple_result implements org.apache.thrift.TBase<deleteMultiple_result, deleteMultiple_result._Fields>, java.io.Serializable, Cloneable {
9014 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_result");
9015
9016 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);
9017 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);
9018
9019 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
9020 static {
9021 schemes.put(StandardScheme.class, new deleteMultiple_resultStandardSchemeFactory());
9022 schemes.put(TupleScheme.class, new deleteMultiple_resultTupleSchemeFactory());
9023 }
9024
9025 public List<TDelete> success;
9026 public TIOError io;
9027
9028
9029 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
9030 SUCCESS((short)0, "success"),
9031 IO((short)1, "io");
9032
9033 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9034
9035 static {
9036 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9037 byName.put(field.getFieldName(), field);
9038 }
9039 }
9040
9041
9042
9043
9044 public static _Fields findByThriftId(int fieldId) {
9045 switch(fieldId) {
9046 case 0:
9047 return SUCCESS;
9048 case 1:
9049 return IO;
9050 default:
9051 return null;
9052 }
9053 }
9054
9055
9056
9057
9058
9059 public static _Fields findByThriftIdOrThrow(int fieldId) {
9060 _Fields fields = findByThriftId(fieldId);
9061 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9062 return fields;
9063 }
9064
9065
9066
9067
9068 public static _Fields findByName(String name) {
9069 return byName.get(name);
9070 }
9071
9072 private final short _thriftId;
9073 private final String _fieldName;
9074
9075 _Fields(short thriftId, String fieldName) {
9076 _thriftId = thriftId;
9077 _fieldName = fieldName;
9078 }
9079
9080 public short getThriftFieldId() {
9081 return _thriftId;
9082 }
9083
9084 public String getFieldName() {
9085 return _fieldName;
9086 }
9087 }
9088
9089
9090 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
9091 static {
9092 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
9093 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
9094 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
9095 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
9096 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
9097 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
9098 metaDataMap = Collections.unmodifiableMap(tmpMap);
9099 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_result.class, metaDataMap);
9100 }
9101
9102 public deleteMultiple_result() {
9103 }
9104
9105 public deleteMultiple_result(
9106 List<TDelete> success,
9107 TIOError io)
9108 {
9109 this();
9110 this.success = success;
9111 this.io = io;
9112 }
9113
9114
9115
9116
9117 public deleteMultiple_result(deleteMultiple_result other) {
9118 if (other.isSetSuccess()) {
9119 List<TDelete> __this__success = new ArrayList<TDelete>();
9120 for (TDelete other_element : other.success) {
9121 __this__success.add(new TDelete(other_element));
9122 }
9123 this.success = __this__success;
9124 }
9125 if (other.isSetIo()) {
9126 this.io = new TIOError(other.io);
9127 }
9128 }
9129
9130 public deleteMultiple_result deepCopy() {
9131 return new deleteMultiple_result(this);
9132 }
9133
9134 @Override
9135 public void clear() {
9136 this.success = null;
9137 this.io = null;
9138 }
9139
9140 public int getSuccessSize() {
9141 return (this.success == null) ? 0 : this.success.size();
9142 }
9143
9144 public java.util.Iterator<TDelete> getSuccessIterator() {
9145 return (this.success == null) ? null : this.success.iterator();
9146 }
9147
9148 public void addToSuccess(TDelete elem) {
9149 if (this.success == null) {
9150 this.success = new ArrayList<TDelete>();
9151 }
9152 this.success.add(elem);
9153 }
9154
9155 public List<TDelete> getSuccess() {
9156 return this.success;
9157 }
9158
9159 public deleteMultiple_result setSuccess(List<TDelete> success) {
9160 this.success = success;
9161 return this;
9162 }
9163
9164 public void unsetSuccess() {
9165 this.success = null;
9166 }
9167
9168
9169 public boolean isSetSuccess() {
9170 return this.success != null;
9171 }
9172
9173 public void setSuccessIsSet(boolean value) {
9174 if (!value) {
9175 this.success = null;
9176 }
9177 }
9178
9179 public TIOError getIo() {
9180 return this.io;
9181 }
9182
9183 public deleteMultiple_result setIo(TIOError io) {
9184 this.io = io;
9185 return this;
9186 }
9187
9188 public void unsetIo() {
9189 this.io = null;
9190 }
9191
9192
9193 public boolean isSetIo() {
9194 return this.io != null;
9195 }
9196
9197 public void setIoIsSet(boolean value) {
9198 if (!value) {
9199 this.io = null;
9200 }
9201 }
9202
9203 public void setFieldValue(_Fields field, Object value) {
9204 switch (field) {
9205 case SUCCESS:
9206 if (value == null) {
9207 unsetSuccess();
9208 } else {
9209 setSuccess((List<TDelete>)value);
9210 }
9211 break;
9212
9213 case IO:
9214 if (value == null) {
9215 unsetIo();
9216 } else {
9217 setIo((TIOError)value);
9218 }
9219 break;
9220
9221 }
9222 }
9223
9224 public Object getFieldValue(_Fields field) {
9225 switch (field) {
9226 case SUCCESS:
9227 return getSuccess();
9228
9229 case IO:
9230 return getIo();
9231
9232 }
9233 throw new IllegalStateException();
9234 }
9235
9236
9237 public boolean isSet(_Fields field) {
9238 if (field == null) {
9239 throw new IllegalArgumentException();
9240 }
9241
9242 switch (field) {
9243 case SUCCESS:
9244 return isSetSuccess();
9245 case IO:
9246 return isSetIo();
9247 }
9248 throw new IllegalStateException();
9249 }
9250
9251 @Override
9252 public boolean equals(Object that) {
9253 if (that == null)
9254 return false;
9255 if (that instanceof deleteMultiple_result)
9256 return this.equals((deleteMultiple_result)that);
9257 return false;
9258 }
9259
9260 public boolean equals(deleteMultiple_result that) {
9261 if (that == null)
9262 return false;
9263
9264 boolean this_present_success = true && this.isSetSuccess();
9265 boolean that_present_success = true && that.isSetSuccess();
9266 if (this_present_success || that_present_success) {
9267 if (!(this_present_success && that_present_success))
9268 return false;
9269 if (!this.success.equals(that.success))
9270 return false;
9271 }
9272
9273 boolean this_present_io = true && this.isSetIo();
9274 boolean that_present_io = true && that.isSetIo();
9275 if (this_present_io || that_present_io) {
9276 if (!(this_present_io && that_present_io))
9277 return false;
9278 if (!this.io.equals(that.io))
9279 return false;
9280 }
9281
9282 return true;
9283 }
9284
9285 @Override
9286 public int hashCode() {
9287 return 0;
9288 }
9289
9290 public int compareTo(deleteMultiple_result other) {
9291 if (!getClass().equals(other.getClass())) {
9292 return getClass().getName().compareTo(other.getClass().getName());
9293 }
9294
9295 int lastComparison = 0;
9296 deleteMultiple_result typedOther = (deleteMultiple_result)other;
9297
9298 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
9299 if (lastComparison != 0) {
9300 return lastComparison;
9301 }
9302 if (isSetSuccess()) {
9303 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
9304 if (lastComparison != 0) {
9305 return lastComparison;
9306 }
9307 }
9308 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
9309 if (lastComparison != 0) {
9310 return lastComparison;
9311 }
9312 if (isSetIo()) {
9313 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
9314 if (lastComparison != 0) {
9315 return lastComparison;
9316 }
9317 }
9318 return 0;
9319 }
9320
9321 public _Fields fieldForId(int fieldId) {
9322 return _Fields.findByThriftId(fieldId);
9323 }
9324
9325 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
9326 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
9327 }
9328
9329 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
9330 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
9331 }
9332
9333 @Override
9334 public String toString() {
9335 StringBuilder sb = new StringBuilder("deleteMultiple_result(");
9336 boolean first = true;
9337
9338 sb.append("success:");
9339 if (this.success == null) {
9340 sb.append("null");
9341 } else {
9342 sb.append(this.success);
9343 }
9344 first = false;
9345 if (!first) sb.append(", ");
9346 sb.append("io:");
9347 if (this.io == null) {
9348 sb.append("null");
9349 } else {
9350 sb.append(this.io);
9351 }
9352 first = false;
9353 sb.append(")");
9354 return sb.toString();
9355 }
9356
9357 public void validate() throws org.apache.thrift.TException {
9358
9359 }
9360
9361 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
9362 try {
9363 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
9364 } catch (org.apache.thrift.TException te) {
9365 throw new java.io.IOException(te);
9366 }
9367 }
9368
9369 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
9370 try {
9371 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
9372 } catch (org.apache.thrift.TException te) {
9373 throw new java.io.IOException(te);
9374 }
9375 }
9376
9377 private static class deleteMultiple_resultStandardSchemeFactory implements SchemeFactory {
9378 public deleteMultiple_resultStandardScheme getScheme() {
9379 return new deleteMultiple_resultStandardScheme();
9380 }
9381 }
9382
9383 private static class deleteMultiple_resultStandardScheme extends StandardScheme<deleteMultiple_result> {
9384
9385 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9386 org.apache.thrift.protocol.TField schemeField;
9387 iprot.readStructBegin();
9388 while (true)
9389 {
9390 schemeField = iprot.readFieldBegin();
9391 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
9392 break;
9393 }
9394 switch (schemeField.id) {
9395 case 0:
9396 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
9397 {
9398 org.apache.thrift.protocol.TList _list128 = iprot.readListBegin();
9399 struct.success = new ArrayList<TDelete>(_list128.size);
9400 for (int _i129 = 0; _i129 < _list128.size; ++_i129)
9401 {
9402 TDelete _elem130;
9403 _elem130 = new TDelete();
9404 _elem130.read(iprot);
9405 struct.success.add(_elem130);
9406 }
9407 iprot.readListEnd();
9408 }
9409 struct.setSuccessIsSet(true);
9410 } else {
9411 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9412 }
9413 break;
9414 case 1:
9415 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
9416 struct.io = new TIOError();
9417 struct.io.read(iprot);
9418 struct.setIoIsSet(true);
9419 } else {
9420 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9421 }
9422 break;
9423 default:
9424 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9425 }
9426 iprot.readFieldEnd();
9427 }
9428 iprot.readStructEnd();
9429
9430
9431 struct.validate();
9432 }
9433
9434 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9435 struct.validate();
9436
9437 oprot.writeStructBegin(STRUCT_DESC);
9438 if (struct.success != null) {
9439 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
9440 {
9441 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
9442 for (TDelete _iter131 : struct.success)
9443 {
9444 _iter131.write(oprot);
9445 }
9446 oprot.writeListEnd();
9447 }
9448 oprot.writeFieldEnd();
9449 }
9450 if (struct.io != null) {
9451 oprot.writeFieldBegin(IO_FIELD_DESC);
9452 struct.io.write(oprot);
9453 oprot.writeFieldEnd();
9454 }
9455 oprot.writeFieldStop();
9456 oprot.writeStructEnd();
9457 }
9458
9459 }
9460
9461 private static class deleteMultiple_resultTupleSchemeFactory implements SchemeFactory {
9462 public deleteMultiple_resultTupleScheme getScheme() {
9463 return new deleteMultiple_resultTupleScheme();
9464 }
9465 }
9466
9467 private static class deleteMultiple_resultTupleScheme extends TupleScheme<deleteMultiple_result> {
9468
9469 @Override
9470 public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9471 TTupleProtocol oprot = (TTupleProtocol) prot;
9472 BitSet optionals = new BitSet();
9473 if (struct.isSetSuccess()) {
9474 optionals.set(0);
9475 }
9476 if (struct.isSetIo()) {
9477 optionals.set(1);
9478 }
9479 oprot.writeBitSet(optionals, 2);
9480 if (struct.isSetSuccess()) {
9481 {
9482 oprot.writeI32(struct.success.size());
9483 for (TDelete _iter132 : struct.success)
9484 {
9485 _iter132.write(oprot);
9486 }
9487 }
9488 }
9489 if (struct.isSetIo()) {
9490 struct.io.write(oprot);
9491 }
9492 }
9493
9494 @Override
9495 public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9496 TTupleProtocol iprot = (TTupleProtocol) prot;
9497 BitSet incoming = iprot.readBitSet(2);
9498 if (incoming.get(0)) {
9499 {
9500 org.apache.thrift.protocol.TList _list133 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
9501 struct.success = new ArrayList<TDelete>(_list133.size);
9502 for (int _i134 = 0; _i134 < _list133.size; ++_i134)
9503 {
9504 TDelete _elem135;
9505 _elem135 = new TDelete();
9506 _elem135.read(iprot);
9507 struct.success.add(_elem135);
9508 }
9509 }
9510 struct.setSuccessIsSet(true);
9511 }
9512 if (incoming.get(1)) {
9513 struct.io = new TIOError();
9514 struct.io.read(iprot);
9515 struct.setIoIsSet(true);
9516 }
9517 }
9518 }
9519
9520 }
9521
9522 public static class checkAndDelete_args implements org.apache.thrift.TBase<checkAndDelete_args, checkAndDelete_args._Fields>, java.io.Serializable, Cloneable {
9523 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_args");
9524
9525 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);
9526 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);
9527 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);
9528 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);
9529 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);
9530 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);
9531
9532 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
9533 static {
9534 schemes.put(StandardScheme.class, new checkAndDelete_argsStandardSchemeFactory());
9535 schemes.put(TupleScheme.class, new checkAndDelete_argsTupleSchemeFactory());
9536 }
9537
9538
9539
9540
9541 public ByteBuffer table;
9542
9543
9544
9545 public ByteBuffer row;
9546
9547
9548
9549 public ByteBuffer family;
9550
9551
9552
9553 public ByteBuffer qualifier;
9554
9555
9556
9557
9558
9559 public ByteBuffer value;
9560
9561
9562
9563 public TDelete deleteSingle;
9564
9565
9566 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
9567
9568
9569
9570 TABLE((short)1, "table"),
9571
9572
9573
9574 ROW((short)2, "row"),
9575
9576
9577
9578 FAMILY((short)3, "family"),
9579
9580
9581
9582 QUALIFIER((short)4, "qualifier"),
9583
9584
9585
9586
9587
9588 VALUE((short)5, "value"),
9589
9590
9591
9592 DELETE_SINGLE((short)6, "deleteSingle");
9593
9594 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9595
9596 static {
9597 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9598 byName.put(field.getFieldName(), field);
9599 }
9600 }
9601
9602
9603
9604
9605 public static _Fields findByThriftId(int fieldId) {
9606 switch(fieldId) {
9607 case 1:
9608 return TABLE;
9609 case 2:
9610 return ROW;
9611 case 3:
9612 return FAMILY;
9613 case 4:
9614 return QUALIFIER;
9615 case 5:
9616 return VALUE;
9617 case 6:
9618 return DELETE_SINGLE;
9619 default:
9620 return null;
9621 }
9622 }
9623
9624
9625
9626
9627
9628 public static _Fields findByThriftIdOrThrow(int fieldId) {
9629 _Fields fields = findByThriftId(fieldId);
9630 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9631 return fields;
9632 }
9633
9634
9635
9636
9637 public static _Fields findByName(String name) {
9638 return byName.get(name);
9639 }
9640
9641 private final short _thriftId;
9642 private final String _fieldName;
9643
9644 _Fields(short thriftId, String fieldName) {
9645 _thriftId = thriftId;
9646 _fieldName = fieldName;
9647 }
9648
9649 public short getThriftFieldId() {
9650 return _thriftId;
9651 }
9652
9653 public String getFieldName() {
9654 return _fieldName;
9655 }
9656 }
9657
9658
9659 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
9660 static {
9661 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
9662 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
9663 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9664 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
9665 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9666 tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
9667 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9668 tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
9669 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9670 tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT,
9671 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9672 tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED,
9673 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
9674 metaDataMap = Collections.unmodifiableMap(tmpMap);
9675 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_args.class, metaDataMap);
9676 }
9677
9678 public checkAndDelete_args() {
9679 }
9680
9681 public checkAndDelete_args(
9682 ByteBuffer table,
9683 ByteBuffer row,
9684 ByteBuffer family,
9685 ByteBuffer qualifier,
9686 ByteBuffer value,
9687 TDelete deleteSingle)
9688 {
9689 this();
9690 this.table = table;
9691 this.row = row;
9692 this.family = family;
9693 this.qualifier = qualifier;
9694 this.value = value;
9695 this.deleteSingle = deleteSingle;
9696 }
9697
9698
9699
9700
9701 public checkAndDelete_args(checkAndDelete_args other) {
9702 if (other.isSetTable()) {
9703 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
9704 ;
9705 }
9706 if (other.isSetRow()) {
9707 this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
9708 ;
9709 }
9710 if (other.isSetFamily()) {
9711 this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
9712 ;
9713 }
9714 if (other.isSetQualifier()) {
9715 this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
9716 ;
9717 }
9718 if (other.isSetValue()) {
9719 this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
9720 ;
9721 }
9722 if (other.isSetDeleteSingle()) {
9723 this.deleteSingle = new TDelete(other.deleteSingle);
9724 }
9725 }
9726
9727 public checkAndDelete_args deepCopy() {
9728 return new checkAndDelete_args(this);
9729 }
9730
9731 @Override
9732 public void clear() {
9733 this.table = null;
9734 this.row = null;
9735 this.family = null;
9736 this.qualifier = null;
9737 this.value = null;
9738 this.deleteSingle = null;
9739 }
9740
9741
9742
9743
9744 public byte[] getTable() {
9745 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
9746 return table == null ? null : table.array();
9747 }
9748
9749 public ByteBuffer bufferForTable() {
9750 return table;
9751 }
9752
9753
9754
9755
9756 public checkAndDelete_args setTable(byte[] table) {
9757 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
9758 return this;
9759 }
9760
9761 public checkAndDelete_args setTable(ByteBuffer table) {
9762 this.table = table;
9763 return this;
9764 }
9765
9766 public void unsetTable() {
9767 this.table = null;
9768 }
9769
9770
9771 public boolean isSetTable() {
9772 return this.table != null;
9773 }
9774
9775 public void setTableIsSet(boolean value) {
9776 if (!value) {
9777 this.table = null;
9778 }
9779 }
9780
9781
9782
9783
9784 public byte[] getRow() {
9785 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
9786 return row == null ? null : row.array();
9787 }
9788
9789 public ByteBuffer bufferForRow() {
9790 return row;
9791 }
9792
9793
9794
9795
9796 public checkAndDelete_args setRow(byte[] row) {
9797 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
9798 return this;
9799 }
9800
9801 public checkAndDelete_args setRow(ByteBuffer row) {
9802 this.row = row;
9803 return this;
9804 }
9805
9806 public void unsetRow() {
9807 this.row = null;
9808 }
9809
9810
9811 public boolean isSetRow() {
9812 return this.row != null;
9813 }
9814
9815 public void setRowIsSet(boolean value) {
9816 if (!value) {
9817 this.row = null;
9818 }
9819 }
9820
9821
9822
9823
9824 public byte[] getFamily() {
9825 setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
9826 return family == null ? null : family.array();
9827 }
9828
9829 public ByteBuffer bufferForFamily() {
9830 return family;
9831 }
9832
9833
9834
9835
9836 public checkAndDelete_args setFamily(byte[] family) {
9837 setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
9838 return this;
9839 }
9840
9841 public checkAndDelete_args setFamily(ByteBuffer family) {
9842 this.family = family;
9843 return this;
9844 }
9845
9846 public void unsetFamily() {
9847 this.family = null;
9848 }
9849
9850
9851 public boolean isSetFamily() {
9852 return this.family != null;
9853 }
9854
9855 public void setFamilyIsSet(boolean value) {
9856 if (!value) {
9857 this.family = null;
9858 }
9859 }
9860
9861
9862
9863
9864 public byte[] getQualifier() {
9865 setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
9866 return qualifier == null ? null : qualifier.array();
9867 }
9868
9869 public ByteBuffer bufferForQualifier() {
9870 return qualifier;
9871 }
9872
9873
9874
9875
9876 public checkAndDelete_args setQualifier(byte[] qualifier) {
9877 setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
9878 return this;
9879 }
9880
9881 public checkAndDelete_args setQualifier(ByteBuffer qualifier) {
9882 this.qualifier = qualifier;
9883 return this;
9884 }
9885
9886 public void unsetQualifier() {
9887 this.qualifier = null;
9888 }
9889
9890
9891 public boolean isSetQualifier() {
9892 return this.qualifier != null;
9893 }
9894
9895 public void setQualifierIsSet(boolean value) {
9896 if (!value) {
9897 this.qualifier = null;
9898 }
9899 }
9900
9901
9902
9903
9904
9905
9906 public byte[] getValue() {
9907 setValue(org.apache.thrift.TBaseHelper.rightSize(value));
9908 return value == null ? null : value.array();
9909 }
9910
9911 public ByteBuffer bufferForValue() {
9912 return value;
9913 }
9914
9915
9916
9917
9918
9919
9920 public checkAndDelete_args setValue(byte[] value) {
9921 setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
9922 return this;
9923 }
9924
9925 public checkAndDelete_args setValue(ByteBuffer value) {
9926 this.value = value;
9927 return this;
9928 }
9929
9930 public void unsetValue() {
9931 this.value = null;
9932 }
9933
9934
9935 public boolean isSetValue() {
9936 return this.value != null;
9937 }
9938
9939 public void setValueIsSet(boolean value) {
9940 if (!value) {
9941 this.value = null;
9942 }
9943 }
9944
9945
9946
9947
9948 public TDelete getDeleteSingle() {
9949 return this.deleteSingle;
9950 }
9951
9952
9953
9954
9955 public checkAndDelete_args setDeleteSingle(TDelete deleteSingle) {
9956 this.deleteSingle = deleteSingle;
9957 return this;
9958 }
9959
9960 public void unsetDeleteSingle() {
9961 this.deleteSingle = null;
9962 }
9963
9964
9965 public boolean isSetDeleteSingle() {
9966 return this.deleteSingle != null;
9967 }
9968
9969 public void setDeleteSingleIsSet(boolean value) {
9970 if (!value) {
9971 this.deleteSingle = null;
9972 }
9973 }
9974
9975 public void setFieldValue(_Fields field, Object value) {
9976 switch (field) {
9977 case TABLE:
9978 if (value == null) {
9979 unsetTable();
9980 } else {
9981 setTable((ByteBuffer)value);
9982 }
9983 break;
9984
9985 case ROW:
9986 if (value == null) {
9987 unsetRow();
9988 } else {
9989 setRow((ByteBuffer)value);
9990 }
9991 break;
9992
9993 case FAMILY:
9994 if (value == null) {
9995 unsetFamily();
9996 } else {
9997 setFamily((ByteBuffer)value);
9998 }
9999 break;
10000
10001 case QUALIFIER:
10002 if (value == null) {
10003 unsetQualifier();
10004 } else {
10005 setQualifier((ByteBuffer)value);
10006 }
10007 break;
10008
10009 case VALUE:
10010 if (value == null) {
10011 unsetValue();
10012 } else {
10013 setValue((ByteBuffer)value);
10014 }
10015 break;
10016
10017 case DELETE_SINGLE:
10018 if (value == null) {
10019 unsetDeleteSingle();
10020 } else {
10021 setDeleteSingle((TDelete)value);
10022 }
10023 break;
10024
10025 }
10026 }
10027
10028 public Object getFieldValue(_Fields field) {
10029 switch (field) {
10030 case TABLE:
10031 return getTable();
10032
10033 case ROW:
10034 return getRow();
10035
10036 case FAMILY:
10037 return getFamily();
10038
10039 case QUALIFIER:
10040 return getQualifier();
10041
10042 case VALUE:
10043 return getValue();
10044
10045 case DELETE_SINGLE:
10046 return getDeleteSingle();
10047
10048 }
10049 throw new IllegalStateException();
10050 }
10051
10052
10053 public boolean isSet(_Fields field) {
10054 if (field == null) {
10055 throw new IllegalArgumentException();
10056 }
10057
10058 switch (field) {
10059 case TABLE:
10060 return isSetTable();
10061 case ROW:
10062 return isSetRow();
10063 case FAMILY:
10064 return isSetFamily();
10065 case QUALIFIER:
10066 return isSetQualifier();
10067 case VALUE:
10068 return isSetValue();
10069 case DELETE_SINGLE:
10070 return isSetDeleteSingle();
10071 }
10072 throw new IllegalStateException();
10073 }
10074
10075 @Override
10076 public boolean equals(Object that) {
10077 if (that == null)
10078 return false;
10079 if (that instanceof checkAndDelete_args)
10080 return this.equals((checkAndDelete_args)that);
10081 return false;
10082 }
10083
10084 public boolean equals(checkAndDelete_args that) {
10085 if (that == null)
10086 return false;
10087
10088 boolean this_present_table = true && this.isSetTable();
10089 boolean that_present_table = true && that.isSetTable();
10090 if (this_present_table || that_present_table) {
10091 if (!(this_present_table && that_present_table))
10092 return false;
10093 if (!this.table.equals(that.table))
10094 return false;
10095 }
10096
10097 boolean this_present_row = true && this.isSetRow();
10098 boolean that_present_row = true && that.isSetRow();
10099 if (this_present_row || that_present_row) {
10100 if (!(this_present_row && that_present_row))
10101 return false;
10102 if (!this.row.equals(that.row))
10103 return false;
10104 }
10105
10106 boolean this_present_family = true && this.isSetFamily();
10107 boolean that_present_family = true && that.isSetFamily();
10108 if (this_present_family || that_present_family) {
10109 if (!(this_present_family && that_present_family))
10110 return false;
10111 if (!this.family.equals(that.family))
10112 return false;
10113 }
10114
10115 boolean this_present_qualifier = true && this.isSetQualifier();
10116 boolean that_present_qualifier = true && that.isSetQualifier();
10117 if (this_present_qualifier || that_present_qualifier) {
10118 if (!(this_present_qualifier && that_present_qualifier))
10119 return false;
10120 if (!this.qualifier.equals(that.qualifier))
10121 return false;
10122 }
10123
10124 boolean this_present_value = true && this.isSetValue();
10125 boolean that_present_value = true && that.isSetValue();
10126 if (this_present_value || that_present_value) {
10127 if (!(this_present_value && that_present_value))
10128 return false;
10129 if (!this.value.equals(that.value))
10130 return false;
10131 }
10132
10133 boolean this_present_deleteSingle = true && this.isSetDeleteSingle();
10134 boolean that_present_deleteSingle = true && that.isSetDeleteSingle();
10135 if (this_present_deleteSingle || that_present_deleteSingle) {
10136 if (!(this_present_deleteSingle && that_present_deleteSingle))
10137 return false;
10138 if (!this.deleteSingle.equals(that.deleteSingle))
10139 return false;
10140 }
10141
10142 return true;
10143 }
10144
10145 @Override
10146 public int hashCode() {
10147 return 0;
10148 }
10149
10150 public int compareTo(checkAndDelete_args other) {
10151 if (!getClass().equals(other.getClass())) {
10152 return getClass().getName().compareTo(other.getClass().getName());
10153 }
10154
10155 int lastComparison = 0;
10156 checkAndDelete_args typedOther = (checkAndDelete_args)other;
10157
10158 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
10159 if (lastComparison != 0) {
10160 return lastComparison;
10161 }
10162 if (isSetTable()) {
10163 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
10164 if (lastComparison != 0) {
10165 return lastComparison;
10166 }
10167 }
10168 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
10169 if (lastComparison != 0) {
10170 return lastComparison;
10171 }
10172 if (isSetRow()) {
10173 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
10174 if (lastComparison != 0) {
10175 return lastComparison;
10176 }
10177 }
10178 lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
10179 if (lastComparison != 0) {
10180 return lastComparison;
10181 }
10182 if (isSetFamily()) {
10183 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
10184 if (lastComparison != 0) {
10185 return lastComparison;
10186 }
10187 }
10188 lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
10189 if (lastComparison != 0) {
10190 return lastComparison;
10191 }
10192 if (isSetQualifier()) {
10193 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
10194 if (lastComparison != 0) {
10195 return lastComparison;
10196 }
10197 }
10198 lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
10199 if (lastComparison != 0) {
10200 return lastComparison;
10201 }
10202 if (isSetValue()) {
10203 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
10204 if (lastComparison != 0) {
10205 return lastComparison;
10206 }
10207 }
10208 lastComparison = Boolean.valueOf(isSetDeleteSingle()).compareTo(typedOther.isSetDeleteSingle());
10209 if (lastComparison != 0) {
10210 return lastComparison;
10211 }
10212 if (isSetDeleteSingle()) {
10213 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteSingle, typedOther.deleteSingle);
10214 if (lastComparison != 0) {
10215 return lastComparison;
10216 }
10217 }
10218 return 0;
10219 }
10220
10221 public _Fields fieldForId(int fieldId) {
10222 return _Fields.findByThriftId(fieldId);
10223 }
10224
10225 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
10226 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
10227 }
10228
10229 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
10230 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
10231 }
10232
10233 @Override
10234 public String toString() {
10235 StringBuilder sb = new StringBuilder("checkAndDelete_args(");
10236 boolean first = true;
10237
10238 sb.append("table:");
10239 if (this.table == null) {
10240 sb.append("null");
10241 } else {
10242 org.apache.thrift.TBaseHelper.toString(this.table, sb);
10243 }
10244 first = false;
10245 if (!first) sb.append(", ");
10246 sb.append("row:");
10247 if (this.row == null) {
10248 sb.append("null");
10249 } else {
10250 org.apache.thrift.TBaseHelper.toString(this.row, sb);
10251 }
10252 first = false;
10253 if (!first) sb.append(", ");
10254 sb.append("family:");
10255 if (this.family == null) {
10256 sb.append("null");
10257 } else {
10258 org.apache.thrift.TBaseHelper.toString(this.family, sb);
10259 }
10260 first = false;
10261 if (!first) sb.append(", ");
10262 sb.append("qualifier:");
10263 if (this.qualifier == null) {
10264 sb.append("null");
10265 } else {
10266 org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
10267 }
10268 first = false;
10269 if (!first) sb.append(", ");
10270 sb.append("value:");
10271 if (this.value == null) {
10272 sb.append("null");
10273 } else {
10274 org.apache.thrift.TBaseHelper.toString(this.value, sb);
10275 }
10276 first = false;
10277 if (!first) sb.append(", ");
10278 sb.append("deleteSingle:");
10279 if (this.deleteSingle == null) {
10280 sb.append("null");
10281 } else {
10282 sb.append(this.deleteSingle);
10283 }
10284 first = false;
10285 sb.append(")");
10286 return sb.toString();
10287 }
10288
10289 public void validate() throws org.apache.thrift.TException {
10290
10291 if (table == null) {
10292 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
10293 }
10294 if (row == null) {
10295 throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
10296 }
10297 if (family == null) {
10298 throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
10299 }
10300 if (qualifier == null) {
10301 throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
10302 }
10303 if (deleteSingle == null) {
10304 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deleteSingle' was not present! Struct: " + toString());
10305 }
10306 }
10307
10308 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
10309 try {
10310 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
10311 } catch (org.apache.thrift.TException te) {
10312 throw new java.io.IOException(te);
10313 }
10314 }
10315
10316 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
10317 try {
10318 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
10319 } catch (org.apache.thrift.TException te) {
10320 throw new java.io.IOException(te);
10321 }
10322 }
10323
10324 private static class checkAndDelete_argsStandardSchemeFactory implements SchemeFactory {
10325 public checkAndDelete_argsStandardScheme getScheme() {
10326 return new checkAndDelete_argsStandardScheme();
10327 }
10328 }
10329
10330 private static class checkAndDelete_argsStandardScheme extends StandardScheme<checkAndDelete_args> {
10331
10332 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10333 org.apache.thrift.protocol.TField schemeField;
10334 iprot.readStructBegin();
10335 while (true)
10336 {
10337 schemeField = iprot.readFieldBegin();
10338 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
10339 break;
10340 }
10341 switch (schemeField.id) {
10342 case 1:
10343 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10344 struct.table = iprot.readBinary();
10345 struct.setTableIsSet(true);
10346 } else {
10347 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10348 }
10349 break;
10350 case 2:
10351 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10352 struct.row = iprot.readBinary();
10353 struct.setRowIsSet(true);
10354 } else {
10355 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10356 }
10357 break;
10358 case 3:
10359 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10360 struct.family = iprot.readBinary();
10361 struct.setFamilyIsSet(true);
10362 } else {
10363 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10364 }
10365 break;
10366 case 4:
10367 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10368 struct.qualifier = iprot.readBinary();
10369 struct.setQualifierIsSet(true);
10370 } else {
10371 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10372 }
10373 break;
10374 case 5:
10375 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10376 struct.value = iprot.readBinary();
10377 struct.setValueIsSet(true);
10378 } else {
10379 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10380 }
10381 break;
10382 case 6:
10383 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
10384 struct.deleteSingle = new TDelete();
10385 struct.deleteSingle.read(iprot);
10386 struct.setDeleteSingleIsSet(true);
10387 } else {
10388 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10389 }
10390 break;
10391 default:
10392 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10393 }
10394 iprot.readFieldEnd();
10395 }
10396 iprot.readStructEnd();
10397
10398
10399 struct.validate();
10400 }
10401
10402 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10403 struct.validate();
10404
10405 oprot.writeStructBegin(STRUCT_DESC);
10406 if (struct.table != null) {
10407 oprot.writeFieldBegin(TABLE_FIELD_DESC);
10408 oprot.writeBinary(struct.table);
10409 oprot.writeFieldEnd();
10410 }
10411 if (struct.row != null) {
10412 oprot.writeFieldBegin(ROW_FIELD_DESC);
10413 oprot.writeBinary(struct.row);
10414 oprot.writeFieldEnd();
10415 }
10416 if (struct.family != null) {
10417 oprot.writeFieldBegin(FAMILY_FIELD_DESC);
10418 oprot.writeBinary(struct.family);
10419 oprot.writeFieldEnd();
10420 }
10421 if (struct.qualifier != null) {
10422 oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
10423 oprot.writeBinary(struct.qualifier);
10424 oprot.writeFieldEnd();
10425 }
10426 if (struct.value != null) {
10427 oprot.writeFieldBegin(VALUE_FIELD_DESC);
10428 oprot.writeBinary(struct.value);
10429 oprot.writeFieldEnd();
10430 }
10431 if (struct.deleteSingle != null) {
10432 oprot.writeFieldBegin(DELETE_SINGLE_FIELD_DESC);
10433 struct.deleteSingle.write(oprot);
10434 oprot.writeFieldEnd();
10435 }
10436 oprot.writeFieldStop();
10437 oprot.writeStructEnd();
10438 }
10439
10440 }
10441
10442 private static class checkAndDelete_argsTupleSchemeFactory implements SchemeFactory {
10443 public checkAndDelete_argsTupleScheme getScheme() {
10444 return new checkAndDelete_argsTupleScheme();
10445 }
10446 }
10447
10448 private static class checkAndDelete_argsTupleScheme extends TupleScheme<checkAndDelete_args> {
10449
10450 @Override
10451 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10452 TTupleProtocol oprot = (TTupleProtocol) prot;
10453 oprot.writeBinary(struct.table);
10454 oprot.writeBinary(struct.row);
10455 oprot.writeBinary(struct.family);
10456 oprot.writeBinary(struct.qualifier);
10457 struct.deleteSingle.write(oprot);
10458 BitSet optionals = new BitSet();
10459 if (struct.isSetValue()) {
10460 optionals.set(0);
10461 }
10462 oprot.writeBitSet(optionals, 1);
10463 if (struct.isSetValue()) {
10464 oprot.writeBinary(struct.value);
10465 }
10466 }
10467
10468 @Override
10469 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10470 TTupleProtocol iprot = (TTupleProtocol) prot;
10471 struct.table = iprot.readBinary();
10472 struct.setTableIsSet(true);
10473 struct.row = iprot.readBinary();
10474 struct.setRowIsSet(true);
10475 struct.family = iprot.readBinary();
10476 struct.setFamilyIsSet(true);
10477 struct.qualifier = iprot.readBinary();
10478 struct.setQualifierIsSet(true);
10479 struct.deleteSingle = new TDelete();
10480 struct.deleteSingle.read(iprot);
10481 struct.setDeleteSingleIsSet(true);
10482 BitSet incoming = iprot.readBitSet(1);
10483 if (incoming.get(0)) {
10484 struct.value = iprot.readBinary();
10485 struct.setValueIsSet(true);
10486 }
10487 }
10488 }
10489
10490 }
10491
10492 public static class checkAndDelete_result implements org.apache.thrift.TBase<checkAndDelete_result, checkAndDelete_result._Fields>, java.io.Serializable, Cloneable {
10493 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_result");
10494
10495 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);
10496 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);
10497
10498 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
10499 static {
10500 schemes.put(StandardScheme.class, new checkAndDelete_resultStandardSchemeFactory());
10501 schemes.put(TupleScheme.class, new checkAndDelete_resultTupleSchemeFactory());
10502 }
10503
10504 public boolean success;
10505 public TIOError io;
10506
10507
10508 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
10509 SUCCESS((short)0, "success"),
10510 IO((short)1, "io");
10511
10512 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10513
10514 static {
10515 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10516 byName.put(field.getFieldName(), field);
10517 }
10518 }
10519
10520
10521
10522
10523 public static _Fields findByThriftId(int fieldId) {
10524 switch(fieldId) {
10525 case 0:
10526 return SUCCESS;
10527 case 1:
10528 return IO;
10529 default:
10530 return null;
10531 }
10532 }
10533
10534
10535
10536
10537
10538 public static _Fields findByThriftIdOrThrow(int fieldId) {
10539 _Fields fields = findByThriftId(fieldId);
10540 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10541 return fields;
10542 }
10543
10544
10545
10546
10547 public static _Fields findByName(String name) {
10548 return byName.get(name);
10549 }
10550
10551 private final short _thriftId;
10552 private final String _fieldName;
10553
10554 _Fields(short thriftId, String fieldName) {
10555 _thriftId = thriftId;
10556 _fieldName = fieldName;
10557 }
10558
10559 public short getThriftFieldId() {
10560 return _thriftId;
10561 }
10562
10563 public String getFieldName() {
10564 return _fieldName;
10565 }
10566 }
10567
10568
10569 private static final int __SUCCESS_ISSET_ID = 0;
10570 private BitSet __isset_bit_vector = new BitSet(1);
10571 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
10572 static {
10573 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
10574 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
10575 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
10576 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
10577 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
10578 metaDataMap = Collections.unmodifiableMap(tmpMap);
10579 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_result.class, metaDataMap);
10580 }
10581
10582 public checkAndDelete_result() {
10583 }
10584
10585 public checkAndDelete_result(
10586 boolean success,
10587 TIOError io)
10588 {
10589 this();
10590 this.success = success;
10591 setSuccessIsSet(true);
10592 this.io = io;
10593 }
10594
10595
10596
10597
10598 public checkAndDelete_result(checkAndDelete_result other) {
10599 __isset_bit_vector.clear();
10600 __isset_bit_vector.or(other.__isset_bit_vector);
10601 this.success = other.success;
10602 if (other.isSetIo()) {
10603 this.io = new TIOError(other.io);
10604 }
10605 }
10606
10607 public checkAndDelete_result deepCopy() {
10608 return new checkAndDelete_result(this);
10609 }
10610
10611 @Override
10612 public void clear() {
10613 setSuccessIsSet(false);
10614 this.success = false;
10615 this.io = null;
10616 }
10617
10618 public boolean isSuccess() {
10619 return this.success;
10620 }
10621
10622 public checkAndDelete_result setSuccess(boolean success) {
10623 this.success = success;
10624 setSuccessIsSet(true);
10625 return this;
10626 }
10627
10628 public void unsetSuccess() {
10629 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
10630 }
10631
10632
10633 public boolean isSetSuccess() {
10634 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
10635 }
10636
10637 public void setSuccessIsSet(boolean value) {
10638 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
10639 }
10640
10641 public TIOError getIo() {
10642 return this.io;
10643 }
10644
10645 public checkAndDelete_result setIo(TIOError io) {
10646 this.io = io;
10647 return this;
10648 }
10649
10650 public void unsetIo() {
10651 this.io = null;
10652 }
10653
10654
10655 public boolean isSetIo() {
10656 return this.io != null;
10657 }
10658
10659 public void setIoIsSet(boolean value) {
10660 if (!value) {
10661 this.io = null;
10662 }
10663 }
10664
10665 public void setFieldValue(_Fields field, Object value) {
10666 switch (field) {
10667 case SUCCESS:
10668 if (value == null) {
10669 unsetSuccess();
10670 } else {
10671 setSuccess((Boolean)value);
10672 }
10673 break;
10674
10675 case IO:
10676 if (value == null) {
10677 unsetIo();
10678 } else {
10679 setIo((TIOError)value);
10680 }
10681 break;
10682
10683 }
10684 }
10685
10686 public Object getFieldValue(_Fields field) {
10687 switch (field) {
10688 case SUCCESS:
10689 return Boolean.valueOf(isSuccess());
10690
10691 case IO:
10692 return getIo();
10693
10694 }
10695 throw new IllegalStateException();
10696 }
10697
10698
10699 public boolean isSet(_Fields field) {
10700 if (field == null) {
10701 throw new IllegalArgumentException();
10702 }
10703
10704 switch (field) {
10705 case SUCCESS:
10706 return isSetSuccess();
10707 case IO:
10708 return isSetIo();
10709 }
10710 throw new IllegalStateException();
10711 }
10712
10713 @Override
10714 public boolean equals(Object that) {
10715 if (that == null)
10716 return false;
10717 if (that instanceof checkAndDelete_result)
10718 return this.equals((checkAndDelete_result)that);
10719 return false;
10720 }
10721
10722 public boolean equals(checkAndDelete_result that) {
10723 if (that == null)
10724 return false;
10725
10726 boolean this_present_success = true;
10727 boolean that_present_success = true;
10728 if (this_present_success || that_present_success) {
10729 if (!(this_present_success && that_present_success))
10730 return false;
10731 if (this.success != that.success)
10732 return false;
10733 }
10734
10735 boolean this_present_io = true && this.isSetIo();
10736 boolean that_present_io = true && that.isSetIo();
10737 if (this_present_io || that_present_io) {
10738 if (!(this_present_io && that_present_io))
10739 return false;
10740 if (!this.io.equals(that.io))
10741 return false;
10742 }
10743
10744 return true;
10745 }
10746
10747 @Override
10748 public int hashCode() {
10749 return 0;
10750 }
10751
10752 public int compareTo(checkAndDelete_result other) {
10753 if (!getClass().equals(other.getClass())) {
10754 return getClass().getName().compareTo(other.getClass().getName());
10755 }
10756
10757 int lastComparison = 0;
10758 checkAndDelete_result typedOther = (checkAndDelete_result)other;
10759
10760 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
10761 if (lastComparison != 0) {
10762 return lastComparison;
10763 }
10764 if (isSetSuccess()) {
10765 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
10766 if (lastComparison != 0) {
10767 return lastComparison;
10768 }
10769 }
10770 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
10771 if (lastComparison != 0) {
10772 return lastComparison;
10773 }
10774 if (isSetIo()) {
10775 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
10776 if (lastComparison != 0) {
10777 return lastComparison;
10778 }
10779 }
10780 return 0;
10781 }
10782
10783 public _Fields fieldForId(int fieldId) {
10784 return _Fields.findByThriftId(fieldId);
10785 }
10786
10787 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
10788 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
10789 }
10790
10791 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
10792 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
10793 }
10794
10795 @Override
10796 public String toString() {
10797 StringBuilder sb = new StringBuilder("checkAndDelete_result(");
10798 boolean first = true;
10799
10800 sb.append("success:");
10801 sb.append(this.success);
10802 first = false;
10803 if (!first) sb.append(", ");
10804 sb.append("io:");
10805 if (this.io == null) {
10806 sb.append("null");
10807 } else {
10808 sb.append(this.io);
10809 }
10810 first = false;
10811 sb.append(")");
10812 return sb.toString();
10813 }
10814
10815 public void validate() throws org.apache.thrift.TException {
10816
10817 }
10818
10819 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
10820 try {
10821 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
10822 } catch (org.apache.thrift.TException te) {
10823 throw new java.io.IOException(te);
10824 }
10825 }
10826
10827 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
10828 try {
10829
10830 __isset_bit_vector = new BitSet(1);
10831 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
10832 } catch (org.apache.thrift.TException te) {
10833 throw new java.io.IOException(te);
10834 }
10835 }
10836
10837 private static class checkAndDelete_resultStandardSchemeFactory implements SchemeFactory {
10838 public checkAndDelete_resultStandardScheme getScheme() {
10839 return new checkAndDelete_resultStandardScheme();
10840 }
10841 }
10842
10843 private static class checkAndDelete_resultStandardScheme extends StandardScheme<checkAndDelete_result> {
10844
10845 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10846 org.apache.thrift.protocol.TField schemeField;
10847 iprot.readStructBegin();
10848 while (true)
10849 {
10850 schemeField = iprot.readFieldBegin();
10851 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
10852 break;
10853 }
10854 switch (schemeField.id) {
10855 case 0:
10856 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
10857 struct.success = iprot.readBool();
10858 struct.setSuccessIsSet(true);
10859 } else {
10860 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10861 }
10862 break;
10863 case 1:
10864 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
10865 struct.io = new TIOError();
10866 struct.io.read(iprot);
10867 struct.setIoIsSet(true);
10868 } else {
10869 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10870 }
10871 break;
10872 default:
10873 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10874 }
10875 iprot.readFieldEnd();
10876 }
10877 iprot.readStructEnd();
10878
10879
10880 struct.validate();
10881 }
10882
10883 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10884 struct.validate();
10885
10886 oprot.writeStructBegin(STRUCT_DESC);
10887 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
10888 oprot.writeBool(struct.success);
10889 oprot.writeFieldEnd();
10890 if (struct.io != null) {
10891 oprot.writeFieldBegin(IO_FIELD_DESC);
10892 struct.io.write(oprot);
10893 oprot.writeFieldEnd();
10894 }
10895 oprot.writeFieldStop();
10896 oprot.writeStructEnd();
10897 }
10898
10899 }
10900
10901 private static class checkAndDelete_resultTupleSchemeFactory implements SchemeFactory {
10902 public checkAndDelete_resultTupleScheme getScheme() {
10903 return new checkAndDelete_resultTupleScheme();
10904 }
10905 }
10906
10907 private static class checkAndDelete_resultTupleScheme extends TupleScheme<checkAndDelete_result> {
10908
10909 @Override
10910 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10911 TTupleProtocol oprot = (TTupleProtocol) prot;
10912 BitSet optionals = new BitSet();
10913 if (struct.isSetSuccess()) {
10914 optionals.set(0);
10915 }
10916 if (struct.isSetIo()) {
10917 optionals.set(1);
10918 }
10919 oprot.writeBitSet(optionals, 2);
10920 if (struct.isSetSuccess()) {
10921 oprot.writeBool(struct.success);
10922 }
10923 if (struct.isSetIo()) {
10924 struct.io.write(oprot);
10925 }
10926 }
10927
10928 @Override
10929 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10930 TTupleProtocol iprot = (TTupleProtocol) prot;
10931 BitSet incoming = iprot.readBitSet(2);
10932 if (incoming.get(0)) {
10933 struct.success = iprot.readBool();
10934 struct.setSuccessIsSet(true);
10935 }
10936 if (incoming.get(1)) {
10937 struct.io = new TIOError();
10938 struct.io.read(iprot);
10939 struct.setIoIsSet(true);
10940 }
10941 }
10942 }
10943
10944 }
10945
10946 public static class increment_args implements org.apache.thrift.TBase<increment_args, increment_args._Fields>, java.io.Serializable, Cloneable {
10947 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_args");
10948
10949 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);
10950 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);
10951
10952 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
10953 static {
10954 schemes.put(StandardScheme.class, new increment_argsStandardSchemeFactory());
10955 schemes.put(TupleScheme.class, new increment_argsTupleSchemeFactory());
10956 }
10957
10958
10959
10960
10961 public ByteBuffer table;
10962
10963
10964
10965 public TIncrement increment;
10966
10967
10968 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
10969
10970
10971
10972 TABLE((short)1, "table"),
10973
10974
10975
10976 INCREMENT((short)2, "increment");
10977
10978 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10979
10980 static {
10981 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10982 byName.put(field.getFieldName(), field);
10983 }
10984 }
10985
10986
10987
10988
10989 public static _Fields findByThriftId(int fieldId) {
10990 switch(fieldId) {
10991 case 1:
10992 return TABLE;
10993 case 2:
10994 return INCREMENT;
10995 default:
10996 return null;
10997 }
10998 }
10999
11000
11001
11002
11003
11004 public static _Fields findByThriftIdOrThrow(int fieldId) {
11005 _Fields fields = findByThriftId(fieldId);
11006 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11007 return fields;
11008 }
11009
11010
11011
11012
11013 public static _Fields findByName(String name) {
11014 return byName.get(name);
11015 }
11016
11017 private final short _thriftId;
11018 private final String _fieldName;
11019
11020 _Fields(short thriftId, String fieldName) {
11021 _thriftId = thriftId;
11022 _fieldName = fieldName;
11023 }
11024
11025 public short getThriftFieldId() {
11026 return _thriftId;
11027 }
11028
11029 public String getFieldName() {
11030 return _fieldName;
11031 }
11032 }
11033
11034
11035 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
11036 static {
11037 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
11038 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
11039 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
11040 tmpMap.put(_Fields.INCREMENT, new org.apache.thrift.meta_data.FieldMetaData("increment", org.apache.thrift.TFieldRequirementType.REQUIRED,
11041 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIncrement.class)));
11042 metaDataMap = Collections.unmodifiableMap(tmpMap);
11043 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_args.class, metaDataMap);
11044 }
11045
11046 public increment_args() {
11047 }
11048
11049 public increment_args(
11050 ByteBuffer table,
11051 TIncrement increment)
11052 {
11053 this();
11054 this.table = table;
11055 this.increment = increment;
11056 }
11057
11058
11059
11060
11061 public increment_args(increment_args other) {
11062 if (other.isSetTable()) {
11063 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
11064 ;
11065 }
11066 if (other.isSetIncrement()) {
11067 this.increment = new TIncrement(other.increment);
11068 }
11069 }
11070
11071 public increment_args deepCopy() {
11072 return new increment_args(this);
11073 }
11074
11075 @Override
11076 public void clear() {
11077 this.table = null;
11078 this.increment = null;
11079 }
11080
11081
11082
11083
11084 public byte[] getTable() {
11085 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
11086 return table == null ? null : table.array();
11087 }
11088
11089 public ByteBuffer bufferForTable() {
11090 return table;
11091 }
11092
11093
11094
11095
11096 public increment_args setTable(byte[] table) {
11097 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
11098 return this;
11099 }
11100
11101 public increment_args setTable(ByteBuffer table) {
11102 this.table = table;
11103 return this;
11104 }
11105
11106 public void unsetTable() {
11107 this.table = null;
11108 }
11109
11110
11111 public boolean isSetTable() {
11112 return this.table != null;
11113 }
11114
11115 public void setTableIsSet(boolean value) {
11116 if (!value) {
11117 this.table = null;
11118 }
11119 }
11120
11121
11122
11123
11124 public TIncrement getIncrement() {
11125 return this.increment;
11126 }
11127
11128
11129
11130
11131 public increment_args setIncrement(TIncrement increment) {
11132 this.increment = increment;
11133 return this;
11134 }
11135
11136 public void unsetIncrement() {
11137 this.increment = null;
11138 }
11139
11140
11141 public boolean isSetIncrement() {
11142 return this.increment != null;
11143 }
11144
11145 public void setIncrementIsSet(boolean value) {
11146 if (!value) {
11147 this.increment = null;
11148 }
11149 }
11150
11151 public void setFieldValue(_Fields field, Object value) {
11152 switch (field) {
11153 case TABLE:
11154 if (value == null) {
11155 unsetTable();
11156 } else {
11157 setTable((ByteBuffer)value);
11158 }
11159 break;
11160
11161 case INCREMENT:
11162 if (value == null) {
11163 unsetIncrement();
11164 } else {
11165 setIncrement((TIncrement)value);
11166 }
11167 break;
11168
11169 }
11170 }
11171
11172 public Object getFieldValue(_Fields field) {
11173 switch (field) {
11174 case TABLE:
11175 return getTable();
11176
11177 case INCREMENT:
11178 return getIncrement();
11179
11180 }
11181 throw new IllegalStateException();
11182 }
11183
11184
11185 public boolean isSet(_Fields field) {
11186 if (field == null) {
11187 throw new IllegalArgumentException();
11188 }
11189
11190 switch (field) {
11191 case TABLE:
11192 return isSetTable();
11193 case INCREMENT:
11194 return isSetIncrement();
11195 }
11196 throw new IllegalStateException();
11197 }
11198
11199 @Override
11200 public boolean equals(Object that) {
11201 if (that == null)
11202 return false;
11203 if (that instanceof increment_args)
11204 return this.equals((increment_args)that);
11205 return false;
11206 }
11207
11208 public boolean equals(increment_args that) {
11209 if (that == null)
11210 return false;
11211
11212 boolean this_present_table = true && this.isSetTable();
11213 boolean that_present_table = true && that.isSetTable();
11214 if (this_present_table || that_present_table) {
11215 if (!(this_present_table && that_present_table))
11216 return false;
11217 if (!this.table.equals(that.table))
11218 return false;
11219 }
11220
11221 boolean this_present_increment = true && this.isSetIncrement();
11222 boolean that_present_increment = true && that.isSetIncrement();
11223 if (this_present_increment || that_present_increment) {
11224 if (!(this_present_increment && that_present_increment))
11225 return false;
11226 if (!this.increment.equals(that.increment))
11227 return false;
11228 }
11229
11230 return true;
11231 }
11232
11233 @Override
11234 public int hashCode() {
11235 return 0;
11236 }
11237
11238 public int compareTo(increment_args other) {
11239 if (!getClass().equals(other.getClass())) {
11240 return getClass().getName().compareTo(other.getClass().getName());
11241 }
11242
11243 int lastComparison = 0;
11244 increment_args typedOther = (increment_args)other;
11245
11246 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
11247 if (lastComparison != 0) {
11248 return lastComparison;
11249 }
11250 if (isSetTable()) {
11251 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
11252 if (lastComparison != 0) {
11253 return lastComparison;
11254 }
11255 }
11256 lastComparison = Boolean.valueOf(isSetIncrement()).compareTo(typedOther.isSetIncrement());
11257 if (lastComparison != 0) {
11258 return lastComparison;
11259 }
11260 if (isSetIncrement()) {
11261 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.increment, typedOther.increment);
11262 if (lastComparison != 0) {
11263 return lastComparison;
11264 }
11265 }
11266 return 0;
11267 }
11268
11269 public _Fields fieldForId(int fieldId) {
11270 return _Fields.findByThriftId(fieldId);
11271 }
11272
11273 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
11274 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
11275 }
11276
11277 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
11278 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
11279 }
11280
11281 @Override
11282 public String toString() {
11283 StringBuilder sb = new StringBuilder("increment_args(");
11284 boolean first = true;
11285
11286 sb.append("table:");
11287 if (this.table == null) {
11288 sb.append("null");
11289 } else {
11290 org.apache.thrift.TBaseHelper.toString(this.table, sb);
11291 }
11292 first = false;
11293 if (!first) sb.append(", ");
11294 sb.append("increment:");
11295 if (this.increment == null) {
11296 sb.append("null");
11297 } else {
11298 sb.append(this.increment);
11299 }
11300 first = false;
11301 sb.append(")");
11302 return sb.toString();
11303 }
11304
11305 public void validate() throws org.apache.thrift.TException {
11306
11307 if (table == null) {
11308 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
11309 }
11310 if (increment == null) {
11311 throw new org.apache.thrift.protocol.TProtocolException("Required field 'increment' was not present! Struct: " + toString());
11312 }
11313 }
11314
11315 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
11316 try {
11317 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
11318 } catch (org.apache.thrift.TException te) {
11319 throw new java.io.IOException(te);
11320 }
11321 }
11322
11323 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
11324 try {
11325 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
11326 } catch (org.apache.thrift.TException te) {
11327 throw new java.io.IOException(te);
11328 }
11329 }
11330
11331 private static class increment_argsStandardSchemeFactory implements SchemeFactory {
11332 public increment_argsStandardScheme getScheme() {
11333 return new increment_argsStandardScheme();
11334 }
11335 }
11336
11337 private static class increment_argsStandardScheme extends StandardScheme<increment_args> {
11338
11339 public void read(org.apache.thrift.protocol.TProtocol iprot, increment_args struct) throws org.apache.thrift.TException {
11340 org.apache.thrift.protocol.TField schemeField;
11341 iprot.readStructBegin();
11342 while (true)
11343 {
11344 schemeField = iprot.readFieldBegin();
11345 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
11346 break;
11347 }
11348 switch (schemeField.id) {
11349 case 1:
11350 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
11351 struct.table = iprot.readBinary();
11352 struct.setTableIsSet(true);
11353 } else {
11354 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11355 }
11356 break;
11357 case 2:
11358 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11359 struct.increment = new TIncrement();
11360 struct.increment.read(iprot);
11361 struct.setIncrementIsSet(true);
11362 } else {
11363 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11364 }
11365 break;
11366 default:
11367 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11368 }
11369 iprot.readFieldEnd();
11370 }
11371 iprot.readStructEnd();
11372
11373
11374 struct.validate();
11375 }
11376
11377 public void write(org.apache.thrift.protocol.TProtocol oprot, increment_args struct) throws org.apache.thrift.TException {
11378 struct.validate();
11379
11380 oprot.writeStructBegin(STRUCT_DESC);
11381 if (struct.table != null) {
11382 oprot.writeFieldBegin(TABLE_FIELD_DESC);
11383 oprot.writeBinary(struct.table);
11384 oprot.writeFieldEnd();
11385 }
11386 if (struct.increment != null) {
11387 oprot.writeFieldBegin(INCREMENT_FIELD_DESC);
11388 struct.increment.write(oprot);
11389 oprot.writeFieldEnd();
11390 }
11391 oprot.writeFieldStop();
11392 oprot.writeStructEnd();
11393 }
11394
11395 }
11396
11397 private static class increment_argsTupleSchemeFactory implements SchemeFactory {
11398 public increment_argsTupleScheme getScheme() {
11399 return new increment_argsTupleScheme();
11400 }
11401 }
11402
11403 private static class increment_argsTupleScheme extends TupleScheme<increment_args> {
11404
11405 @Override
11406 public void write(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
11407 TTupleProtocol oprot = (TTupleProtocol) prot;
11408 oprot.writeBinary(struct.table);
11409 struct.increment.write(oprot);
11410 }
11411
11412 @Override
11413 public void read(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
11414 TTupleProtocol iprot = (TTupleProtocol) prot;
11415 struct.table = iprot.readBinary();
11416 struct.setTableIsSet(true);
11417 struct.increment = new TIncrement();
11418 struct.increment.read(iprot);
11419 struct.setIncrementIsSet(true);
11420 }
11421 }
11422
11423 }
11424
11425 public static class increment_result implements org.apache.thrift.TBase<increment_result, increment_result._Fields>, java.io.Serializable, Cloneable {
11426 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_result");
11427
11428 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);
11429 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);
11430
11431 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
11432 static {
11433 schemes.put(StandardScheme.class, new increment_resultStandardSchemeFactory());
11434 schemes.put(TupleScheme.class, new increment_resultTupleSchemeFactory());
11435 }
11436
11437 public TResult success;
11438 public TIOError io;
11439
11440
11441 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
11442 SUCCESS((short)0, "success"),
11443 IO((short)1, "io");
11444
11445 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11446
11447 static {
11448 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11449 byName.put(field.getFieldName(), field);
11450 }
11451 }
11452
11453
11454
11455
11456 public static _Fields findByThriftId(int fieldId) {
11457 switch(fieldId) {
11458 case 0:
11459 return SUCCESS;
11460 case 1:
11461 return IO;
11462 default:
11463 return null;
11464 }
11465 }
11466
11467
11468
11469
11470
11471 public static _Fields findByThriftIdOrThrow(int fieldId) {
11472 _Fields fields = findByThriftId(fieldId);
11473 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11474 return fields;
11475 }
11476
11477
11478
11479
11480 public static _Fields findByName(String name) {
11481 return byName.get(name);
11482 }
11483
11484 private final short _thriftId;
11485 private final String _fieldName;
11486
11487 _Fields(short thriftId, String fieldName) {
11488 _thriftId = thriftId;
11489 _fieldName = fieldName;
11490 }
11491
11492 public short getThriftFieldId() {
11493 return _thriftId;
11494 }
11495
11496 public String getFieldName() {
11497 return _fieldName;
11498 }
11499 }
11500
11501
11502 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
11503 static {
11504 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
11505 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
11506 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
11507 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
11508 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
11509 metaDataMap = Collections.unmodifiableMap(tmpMap);
11510 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_result.class, metaDataMap);
11511 }
11512
11513 public increment_result() {
11514 }
11515
11516 public increment_result(
11517 TResult success,
11518 TIOError io)
11519 {
11520 this();
11521 this.success = success;
11522 this.io = io;
11523 }
11524
11525
11526
11527
11528 public increment_result(increment_result other) {
11529 if (other.isSetSuccess()) {
11530 this.success = new TResult(other.success);
11531 }
11532 if (other.isSetIo()) {
11533 this.io = new TIOError(other.io);
11534 }
11535 }
11536
11537 public increment_result deepCopy() {
11538 return new increment_result(this);
11539 }
11540
11541 @Override
11542 public void clear() {
11543 this.success = null;
11544 this.io = null;
11545 }
11546
11547 public TResult getSuccess() {
11548 return this.success;
11549 }
11550
11551 public increment_result setSuccess(TResult success) {
11552 this.success = success;
11553 return this;
11554 }
11555
11556 public void unsetSuccess() {
11557 this.success = null;
11558 }
11559
11560
11561 public boolean isSetSuccess() {
11562 return this.success != null;
11563 }
11564
11565 public void setSuccessIsSet(boolean value) {
11566 if (!value) {
11567 this.success = null;
11568 }
11569 }
11570
11571 public TIOError getIo() {
11572 return this.io;
11573 }
11574
11575 public increment_result setIo(TIOError io) {
11576 this.io = io;
11577 return this;
11578 }
11579
11580 public void unsetIo() {
11581 this.io = null;
11582 }
11583
11584
11585 public boolean isSetIo() {
11586 return this.io != null;
11587 }
11588
11589 public void setIoIsSet(boolean value) {
11590 if (!value) {
11591 this.io = null;
11592 }
11593 }
11594
11595 public void setFieldValue(_Fields field, Object value) {
11596 switch (field) {
11597 case SUCCESS:
11598 if (value == null) {
11599 unsetSuccess();
11600 } else {
11601 setSuccess((TResult)value);
11602 }
11603 break;
11604
11605 case IO:
11606 if (value == null) {
11607 unsetIo();
11608 } else {
11609 setIo((TIOError)value);
11610 }
11611 break;
11612
11613 }
11614 }
11615
11616 public Object getFieldValue(_Fields field) {
11617 switch (field) {
11618 case SUCCESS:
11619 return getSuccess();
11620
11621 case IO:
11622 return getIo();
11623
11624 }
11625 throw new IllegalStateException();
11626 }
11627
11628
11629 public boolean isSet(_Fields field) {
11630 if (field == null) {
11631 throw new IllegalArgumentException();
11632 }
11633
11634 switch (field) {
11635 case SUCCESS:
11636 return isSetSuccess();
11637 case IO:
11638 return isSetIo();
11639 }
11640 throw new IllegalStateException();
11641 }
11642
11643 @Override
11644 public boolean equals(Object that) {
11645 if (that == null)
11646 return false;
11647 if (that instanceof increment_result)
11648 return this.equals((increment_result)that);
11649 return false;
11650 }
11651
11652 public boolean equals(increment_result that) {
11653 if (that == null)
11654 return false;
11655
11656 boolean this_present_success = true && this.isSetSuccess();
11657 boolean that_present_success = true && that.isSetSuccess();
11658 if (this_present_success || that_present_success) {
11659 if (!(this_present_success && that_present_success))
11660 return false;
11661 if (!this.success.equals(that.success))
11662 return false;
11663 }
11664
11665 boolean this_present_io = true && this.isSetIo();
11666 boolean that_present_io = true && that.isSetIo();
11667 if (this_present_io || that_present_io) {
11668 if (!(this_present_io && that_present_io))
11669 return false;
11670 if (!this.io.equals(that.io))
11671 return false;
11672 }
11673
11674 return true;
11675 }
11676
11677 @Override
11678 public int hashCode() {
11679 return 0;
11680 }
11681
11682 public int compareTo(increment_result other) {
11683 if (!getClass().equals(other.getClass())) {
11684 return getClass().getName().compareTo(other.getClass().getName());
11685 }
11686
11687 int lastComparison = 0;
11688 increment_result typedOther = (increment_result)other;
11689
11690 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
11691 if (lastComparison != 0) {
11692 return lastComparison;
11693 }
11694 if (isSetSuccess()) {
11695 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
11696 if (lastComparison != 0) {
11697 return lastComparison;
11698 }
11699 }
11700 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
11701 if (lastComparison != 0) {
11702 return lastComparison;
11703 }
11704 if (isSetIo()) {
11705 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
11706 if (lastComparison != 0) {
11707 return lastComparison;
11708 }
11709 }
11710 return 0;
11711 }
11712
11713 public _Fields fieldForId(int fieldId) {
11714 return _Fields.findByThriftId(fieldId);
11715 }
11716
11717 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
11718 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
11719 }
11720
11721 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
11722 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
11723 }
11724
11725 @Override
11726 public String toString() {
11727 StringBuilder sb = new StringBuilder("increment_result(");
11728 boolean first = true;
11729
11730 sb.append("success:");
11731 if (this.success == null) {
11732 sb.append("null");
11733 } else {
11734 sb.append(this.success);
11735 }
11736 first = false;
11737 if (!first) sb.append(", ");
11738 sb.append("io:");
11739 if (this.io == null) {
11740 sb.append("null");
11741 } else {
11742 sb.append(this.io);
11743 }
11744 first = false;
11745 sb.append(")");
11746 return sb.toString();
11747 }
11748
11749 public void validate() throws org.apache.thrift.TException {
11750
11751 }
11752
11753 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
11754 try {
11755 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
11756 } catch (org.apache.thrift.TException te) {
11757 throw new java.io.IOException(te);
11758 }
11759 }
11760
11761 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
11762 try {
11763 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
11764 } catch (org.apache.thrift.TException te) {
11765 throw new java.io.IOException(te);
11766 }
11767 }
11768
11769 private static class increment_resultStandardSchemeFactory implements SchemeFactory {
11770 public increment_resultStandardScheme getScheme() {
11771 return new increment_resultStandardScheme();
11772 }
11773 }
11774
11775 private static class increment_resultStandardScheme extends StandardScheme<increment_result> {
11776
11777 public void read(org.apache.thrift.protocol.TProtocol iprot, increment_result struct) throws org.apache.thrift.TException {
11778 org.apache.thrift.protocol.TField schemeField;
11779 iprot.readStructBegin();
11780 while (true)
11781 {
11782 schemeField = iprot.readFieldBegin();
11783 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
11784 break;
11785 }
11786 switch (schemeField.id) {
11787 case 0:
11788 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11789 struct.success = new TResult();
11790 struct.success.read(iprot);
11791 struct.setSuccessIsSet(true);
11792 } else {
11793 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11794 }
11795 break;
11796 case 1:
11797 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11798 struct.io = new TIOError();
11799 struct.io.read(iprot);
11800 struct.setIoIsSet(true);
11801 } else {
11802 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11803 }
11804 break;
11805 default:
11806 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11807 }
11808 iprot.readFieldEnd();
11809 }
11810 iprot.readStructEnd();
11811
11812
11813 struct.validate();
11814 }
11815
11816 public void write(org.apache.thrift.protocol.TProtocol oprot, increment_result struct) throws org.apache.thrift.TException {
11817 struct.validate();
11818
11819 oprot.writeStructBegin(STRUCT_DESC);
11820 if (struct.success != null) {
11821 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11822 struct.success.write(oprot);
11823 oprot.writeFieldEnd();
11824 }
11825 if (struct.io != null) {
11826 oprot.writeFieldBegin(IO_FIELD_DESC);
11827 struct.io.write(oprot);
11828 oprot.writeFieldEnd();
11829 }
11830 oprot.writeFieldStop();
11831 oprot.writeStructEnd();
11832 }
11833
11834 }
11835
11836 private static class increment_resultTupleSchemeFactory implements SchemeFactory {
11837 public increment_resultTupleScheme getScheme() {
11838 return new increment_resultTupleScheme();
11839 }
11840 }
11841
11842 private static class increment_resultTupleScheme extends TupleScheme<increment_result> {
11843
11844 @Override
11845 public void write(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
11846 TTupleProtocol oprot = (TTupleProtocol) prot;
11847 BitSet optionals = new BitSet();
11848 if (struct.isSetSuccess()) {
11849 optionals.set(0);
11850 }
11851 if (struct.isSetIo()) {
11852 optionals.set(1);
11853 }
11854 oprot.writeBitSet(optionals, 2);
11855 if (struct.isSetSuccess()) {
11856 struct.success.write(oprot);
11857 }
11858 if (struct.isSetIo()) {
11859 struct.io.write(oprot);
11860 }
11861 }
11862
11863 @Override
11864 public void read(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
11865 TTupleProtocol iprot = (TTupleProtocol) prot;
11866 BitSet incoming = iprot.readBitSet(2);
11867 if (incoming.get(0)) {
11868 struct.success = new TResult();
11869 struct.success.read(iprot);
11870 struct.setSuccessIsSet(true);
11871 }
11872 if (incoming.get(1)) {
11873 struct.io = new TIOError();
11874 struct.io.read(iprot);
11875 struct.setIoIsSet(true);
11876 }
11877 }
11878 }
11879
11880 }
11881
11882 public static class openScanner_args implements org.apache.thrift.TBase<openScanner_args, openScanner_args._Fields>, java.io.Serializable, Cloneable {
11883 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_args");
11884
11885 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);
11886 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);
11887
11888 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
11889 static {
11890 schemes.put(StandardScheme.class, new openScanner_argsStandardSchemeFactory());
11891 schemes.put(TupleScheme.class, new openScanner_argsTupleSchemeFactory());
11892 }
11893
11894
11895
11896
11897 public ByteBuffer table;
11898
11899
11900
11901 public TScan scan;
11902
11903
11904 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
11905
11906
11907
11908 TABLE((short)1, "table"),
11909
11910
11911
11912 SCAN((short)2, "scan");
11913
11914 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11915
11916 static {
11917 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11918 byName.put(field.getFieldName(), field);
11919 }
11920 }
11921
11922
11923
11924
11925 public static _Fields findByThriftId(int fieldId) {
11926 switch(fieldId) {
11927 case 1:
11928 return TABLE;
11929 case 2:
11930 return SCAN;
11931 default:
11932 return null;
11933 }
11934 }
11935
11936
11937
11938
11939
11940 public static _Fields findByThriftIdOrThrow(int fieldId) {
11941 _Fields fields = findByThriftId(fieldId);
11942 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11943 return fields;
11944 }
11945
11946
11947
11948
11949 public static _Fields findByName(String name) {
11950 return byName.get(name);
11951 }
11952
11953 private final short _thriftId;
11954 private final String _fieldName;
11955
11956 _Fields(short thriftId, String fieldName) {
11957 _thriftId = thriftId;
11958 _fieldName = fieldName;
11959 }
11960
11961 public short getThriftFieldId() {
11962 return _thriftId;
11963 }
11964
11965 public String getFieldName() {
11966 return _fieldName;
11967 }
11968 }
11969
11970
11971 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
11972 static {
11973 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
11974 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
11975 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
11976 tmpMap.put(_Fields.SCAN, new org.apache.thrift.meta_data.FieldMetaData("scan", org.apache.thrift.TFieldRequirementType.REQUIRED,
11977 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TScan.class)));
11978 metaDataMap = Collections.unmodifiableMap(tmpMap);
11979 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_args.class, metaDataMap);
11980 }
11981
11982 public openScanner_args() {
11983 }
11984
11985 public openScanner_args(
11986 ByteBuffer table,
11987 TScan scan)
11988 {
11989 this();
11990 this.table = table;
11991 this.scan = scan;
11992 }
11993
11994
11995
11996
11997 public openScanner_args(openScanner_args other) {
11998 if (other.isSetTable()) {
11999 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
12000 ;
12001 }
12002 if (other.isSetScan()) {
12003 this.scan = new TScan(other.scan);
12004 }
12005 }
12006
12007 public openScanner_args deepCopy() {
12008 return new openScanner_args(this);
12009 }
12010
12011 @Override
12012 public void clear() {
12013 this.table = null;
12014 this.scan = null;
12015 }
12016
12017
12018
12019
12020 public byte[] getTable() {
12021 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
12022 return table == null ? null : table.array();
12023 }
12024
12025 public ByteBuffer bufferForTable() {
12026 return table;
12027 }
12028
12029
12030
12031
12032 public openScanner_args setTable(byte[] table) {
12033 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
12034 return this;
12035 }
12036
12037 public openScanner_args setTable(ByteBuffer table) {
12038 this.table = table;
12039 return this;
12040 }
12041
12042 public void unsetTable() {
12043 this.table = null;
12044 }
12045
12046
12047 public boolean isSetTable() {
12048 return this.table != null;
12049 }
12050
12051 public void setTableIsSet(boolean value) {
12052 if (!value) {
12053 this.table = null;
12054 }
12055 }
12056
12057
12058
12059
12060 public TScan getScan() {
12061 return this.scan;
12062 }
12063
12064
12065
12066
12067 public openScanner_args setScan(TScan scan) {
12068 this.scan = scan;
12069 return this;
12070 }
12071
12072 public void unsetScan() {
12073 this.scan = null;
12074 }
12075
12076
12077 public boolean isSetScan() {
12078 return this.scan != null;
12079 }
12080
12081 public void setScanIsSet(boolean value) {
12082 if (!value) {
12083 this.scan = null;
12084 }
12085 }
12086
12087 public void setFieldValue(_Fields field, Object value) {
12088 switch (field) {
12089 case TABLE:
12090 if (value == null) {
12091 unsetTable();
12092 } else {
12093 setTable((ByteBuffer)value);
12094 }
12095 break;
12096
12097 case SCAN:
12098 if (value == null) {
12099 unsetScan();
12100 } else {
12101 setScan((TScan)value);
12102 }
12103 break;
12104
12105 }
12106 }
12107
12108 public Object getFieldValue(_Fields field) {
12109 switch (field) {
12110 case TABLE:
12111 return getTable();
12112
12113 case SCAN:
12114 return getScan();
12115
12116 }
12117 throw new IllegalStateException();
12118 }
12119
12120
12121 public boolean isSet(_Fields field) {
12122 if (field == null) {
12123 throw new IllegalArgumentException();
12124 }
12125
12126 switch (field) {
12127 case TABLE:
12128 return isSetTable();
12129 case SCAN:
12130 return isSetScan();
12131 }
12132 throw new IllegalStateException();
12133 }
12134
12135 @Override
12136 public boolean equals(Object that) {
12137 if (that == null)
12138 return false;
12139 if (that instanceof openScanner_args)
12140 return this.equals((openScanner_args)that);
12141 return false;
12142 }
12143
12144 public boolean equals(openScanner_args that) {
12145 if (that == null)
12146 return false;
12147
12148 boolean this_present_table = true && this.isSetTable();
12149 boolean that_present_table = true && that.isSetTable();
12150 if (this_present_table || that_present_table) {
12151 if (!(this_present_table && that_present_table))
12152 return false;
12153 if (!this.table.equals(that.table))
12154 return false;
12155 }
12156
12157 boolean this_present_scan = true && this.isSetScan();
12158 boolean that_present_scan = true && that.isSetScan();
12159 if (this_present_scan || that_present_scan) {
12160 if (!(this_present_scan && that_present_scan))
12161 return false;
12162 if (!this.scan.equals(that.scan))
12163 return false;
12164 }
12165
12166 return true;
12167 }
12168
12169 @Override
12170 public int hashCode() {
12171 return 0;
12172 }
12173
12174 public int compareTo(openScanner_args other) {
12175 if (!getClass().equals(other.getClass())) {
12176 return getClass().getName().compareTo(other.getClass().getName());
12177 }
12178
12179 int lastComparison = 0;
12180 openScanner_args typedOther = (openScanner_args)other;
12181
12182 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
12183 if (lastComparison != 0) {
12184 return lastComparison;
12185 }
12186 if (isSetTable()) {
12187 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
12188 if (lastComparison != 0) {
12189 return lastComparison;
12190 }
12191 }
12192 lastComparison = Boolean.valueOf(isSetScan()).compareTo(typedOther.isSetScan());
12193 if (lastComparison != 0) {
12194 return lastComparison;
12195 }
12196 if (isSetScan()) {
12197 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scan, typedOther.scan);
12198 if (lastComparison != 0) {
12199 return lastComparison;
12200 }
12201 }
12202 return 0;
12203 }
12204
12205 public _Fields fieldForId(int fieldId) {
12206 return _Fields.findByThriftId(fieldId);
12207 }
12208
12209 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
12210 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
12211 }
12212
12213 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
12214 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
12215 }
12216
12217 @Override
12218 public String toString() {
12219 StringBuilder sb = new StringBuilder("openScanner_args(");
12220 boolean first = true;
12221
12222 sb.append("table:");
12223 if (this.table == null) {
12224 sb.append("null");
12225 } else {
12226 org.apache.thrift.TBaseHelper.toString(this.table, sb);
12227 }
12228 first = false;
12229 if (!first) sb.append(", ");
12230 sb.append("scan:");
12231 if (this.scan == null) {
12232 sb.append("null");
12233 } else {
12234 sb.append(this.scan);
12235 }
12236 first = false;
12237 sb.append(")");
12238 return sb.toString();
12239 }
12240
12241 public void validate() throws org.apache.thrift.TException {
12242
12243 if (table == null) {
12244 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
12245 }
12246 if (scan == null) {
12247 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scan' was not present! Struct: " + toString());
12248 }
12249 }
12250
12251 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12252 try {
12253 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12254 } catch (org.apache.thrift.TException te) {
12255 throw new java.io.IOException(te);
12256 }
12257 }
12258
12259 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12260 try {
12261 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12262 } catch (org.apache.thrift.TException te) {
12263 throw new java.io.IOException(te);
12264 }
12265 }
12266
12267 private static class openScanner_argsStandardSchemeFactory implements SchemeFactory {
12268 public openScanner_argsStandardScheme getScheme() {
12269 return new openScanner_argsStandardScheme();
12270 }
12271 }
12272
12273 private static class openScanner_argsStandardScheme extends StandardScheme<openScanner_args> {
12274
12275 public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_args struct) throws org.apache.thrift.TException {
12276 org.apache.thrift.protocol.TField schemeField;
12277 iprot.readStructBegin();
12278 while (true)
12279 {
12280 schemeField = iprot.readFieldBegin();
12281 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
12282 break;
12283 }
12284 switch (schemeField.id) {
12285 case 1:
12286 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
12287 struct.table = iprot.readBinary();
12288 struct.setTableIsSet(true);
12289 } else {
12290 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12291 }
12292 break;
12293 case 2:
12294 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
12295 struct.scan = new TScan();
12296 struct.scan.read(iprot);
12297 struct.setScanIsSet(true);
12298 } else {
12299 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12300 }
12301 break;
12302 default:
12303 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12304 }
12305 iprot.readFieldEnd();
12306 }
12307 iprot.readStructEnd();
12308
12309
12310 struct.validate();
12311 }
12312
12313 public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_args struct) throws org.apache.thrift.TException {
12314 struct.validate();
12315
12316 oprot.writeStructBegin(STRUCT_DESC);
12317 if (struct.table != null) {
12318 oprot.writeFieldBegin(TABLE_FIELD_DESC);
12319 oprot.writeBinary(struct.table);
12320 oprot.writeFieldEnd();
12321 }
12322 if (struct.scan != null) {
12323 oprot.writeFieldBegin(SCAN_FIELD_DESC);
12324 struct.scan.write(oprot);
12325 oprot.writeFieldEnd();
12326 }
12327 oprot.writeFieldStop();
12328 oprot.writeStructEnd();
12329 }
12330
12331 }
12332
12333 private static class openScanner_argsTupleSchemeFactory implements SchemeFactory {
12334 public openScanner_argsTupleScheme getScheme() {
12335 return new openScanner_argsTupleScheme();
12336 }
12337 }
12338
12339 private static class openScanner_argsTupleScheme extends TupleScheme<openScanner_args> {
12340
12341 @Override
12342 public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
12343 TTupleProtocol oprot = (TTupleProtocol) prot;
12344 oprot.writeBinary(struct.table);
12345 struct.scan.write(oprot);
12346 }
12347
12348 @Override
12349 public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
12350 TTupleProtocol iprot = (TTupleProtocol) prot;
12351 struct.table = iprot.readBinary();
12352 struct.setTableIsSet(true);
12353 struct.scan = new TScan();
12354 struct.scan.read(iprot);
12355 struct.setScanIsSet(true);
12356 }
12357 }
12358
12359 }
12360
12361 public static class openScanner_result implements org.apache.thrift.TBase<openScanner_result, openScanner_result._Fields>, java.io.Serializable, Cloneable {
12362 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_result");
12363
12364 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);
12365 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);
12366
12367 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
12368 static {
12369 schemes.put(StandardScheme.class, new openScanner_resultStandardSchemeFactory());
12370 schemes.put(TupleScheme.class, new openScanner_resultTupleSchemeFactory());
12371 }
12372
12373 public int success;
12374 public TIOError io;
12375
12376
12377 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
12378 SUCCESS((short)0, "success"),
12379 IO((short)1, "io");
12380
12381 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12382
12383 static {
12384 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12385 byName.put(field.getFieldName(), field);
12386 }
12387 }
12388
12389
12390
12391
12392 public static _Fields findByThriftId(int fieldId) {
12393 switch(fieldId) {
12394 case 0:
12395 return SUCCESS;
12396 case 1:
12397 return IO;
12398 default:
12399 return null;
12400 }
12401 }
12402
12403
12404
12405
12406
12407 public static _Fields findByThriftIdOrThrow(int fieldId) {
12408 _Fields fields = findByThriftId(fieldId);
12409 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12410 return fields;
12411 }
12412
12413
12414
12415
12416 public static _Fields findByName(String name) {
12417 return byName.get(name);
12418 }
12419
12420 private final short _thriftId;
12421 private final String _fieldName;
12422
12423 _Fields(short thriftId, String fieldName) {
12424 _thriftId = thriftId;
12425 _fieldName = fieldName;
12426 }
12427
12428 public short getThriftFieldId() {
12429 return _thriftId;
12430 }
12431
12432 public String getFieldName() {
12433 return _fieldName;
12434 }
12435 }
12436
12437
12438 private static final int __SUCCESS_ISSET_ID = 0;
12439 private BitSet __isset_bit_vector = new BitSet(1);
12440 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
12441 static {
12442 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
12443 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
12444 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12445 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
12446 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
12447 metaDataMap = Collections.unmodifiableMap(tmpMap);
12448 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_result.class, metaDataMap);
12449 }
12450
12451 public openScanner_result() {
12452 }
12453
12454 public openScanner_result(
12455 int success,
12456 TIOError io)
12457 {
12458 this();
12459 this.success = success;
12460 setSuccessIsSet(true);
12461 this.io = io;
12462 }
12463
12464
12465
12466
12467 public openScanner_result(openScanner_result other) {
12468 __isset_bit_vector.clear();
12469 __isset_bit_vector.or(other.__isset_bit_vector);
12470 this.success = other.success;
12471 if (other.isSetIo()) {
12472 this.io = new TIOError(other.io);
12473 }
12474 }
12475
12476 public openScanner_result deepCopy() {
12477 return new openScanner_result(this);
12478 }
12479
12480 @Override
12481 public void clear() {
12482 setSuccessIsSet(false);
12483 this.success = 0;
12484 this.io = null;
12485 }
12486
12487 public int getSuccess() {
12488 return this.success;
12489 }
12490
12491 public openScanner_result setSuccess(int success) {
12492 this.success = success;
12493 setSuccessIsSet(true);
12494 return this;
12495 }
12496
12497 public void unsetSuccess() {
12498 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
12499 }
12500
12501
12502 public boolean isSetSuccess() {
12503 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
12504 }
12505
12506 public void setSuccessIsSet(boolean value) {
12507 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
12508 }
12509
12510 public TIOError getIo() {
12511 return this.io;
12512 }
12513
12514 public openScanner_result setIo(TIOError io) {
12515 this.io = io;
12516 return this;
12517 }
12518
12519 public void unsetIo() {
12520 this.io = null;
12521 }
12522
12523
12524 public boolean isSetIo() {
12525 return this.io != null;
12526 }
12527
12528 public void setIoIsSet(boolean value) {
12529 if (!value) {
12530 this.io = null;
12531 }
12532 }
12533
12534 public void setFieldValue(_Fields field, Object value) {
12535 switch (field) {
12536 case SUCCESS:
12537 if (value == null) {
12538 unsetSuccess();
12539 } else {
12540 setSuccess((Integer)value);
12541 }
12542 break;
12543
12544 case IO:
12545 if (value == null) {
12546 unsetIo();
12547 } else {
12548 setIo((TIOError)value);
12549 }
12550 break;
12551
12552 }
12553 }
12554
12555 public Object getFieldValue(_Fields field) {
12556 switch (field) {
12557 case SUCCESS:
12558 return Integer.valueOf(getSuccess());
12559
12560 case IO:
12561 return getIo();
12562
12563 }
12564 throw new IllegalStateException();
12565 }
12566
12567
12568 public boolean isSet(_Fields field) {
12569 if (field == null) {
12570 throw new IllegalArgumentException();
12571 }
12572
12573 switch (field) {
12574 case SUCCESS:
12575 return isSetSuccess();
12576 case IO:
12577 return isSetIo();
12578 }
12579 throw new IllegalStateException();
12580 }
12581
12582 @Override
12583 public boolean equals(Object that) {
12584 if (that == null)
12585 return false;
12586 if (that instanceof openScanner_result)
12587 return this.equals((openScanner_result)that);
12588 return false;
12589 }
12590
12591 public boolean equals(openScanner_result that) {
12592 if (that == null)
12593 return false;
12594
12595 boolean this_present_success = true;
12596 boolean that_present_success = true;
12597 if (this_present_success || that_present_success) {
12598 if (!(this_present_success && that_present_success))
12599 return false;
12600 if (this.success != that.success)
12601 return false;
12602 }
12603
12604 boolean this_present_io = true && this.isSetIo();
12605 boolean that_present_io = true && that.isSetIo();
12606 if (this_present_io || that_present_io) {
12607 if (!(this_present_io && that_present_io))
12608 return false;
12609 if (!this.io.equals(that.io))
12610 return false;
12611 }
12612
12613 return true;
12614 }
12615
12616 @Override
12617 public int hashCode() {
12618 return 0;
12619 }
12620
12621 public int compareTo(openScanner_result other) {
12622 if (!getClass().equals(other.getClass())) {
12623 return getClass().getName().compareTo(other.getClass().getName());
12624 }
12625
12626 int lastComparison = 0;
12627 openScanner_result typedOther = (openScanner_result)other;
12628
12629 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
12630 if (lastComparison != 0) {
12631 return lastComparison;
12632 }
12633 if (isSetSuccess()) {
12634 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
12635 if (lastComparison != 0) {
12636 return lastComparison;
12637 }
12638 }
12639 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
12640 if (lastComparison != 0) {
12641 return lastComparison;
12642 }
12643 if (isSetIo()) {
12644 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
12645 if (lastComparison != 0) {
12646 return lastComparison;
12647 }
12648 }
12649 return 0;
12650 }
12651
12652 public _Fields fieldForId(int fieldId) {
12653 return _Fields.findByThriftId(fieldId);
12654 }
12655
12656 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
12657 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
12658 }
12659
12660 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
12661 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
12662 }
12663
12664 @Override
12665 public String toString() {
12666 StringBuilder sb = new StringBuilder("openScanner_result(");
12667 boolean first = true;
12668
12669 sb.append("success:");
12670 sb.append(this.success);
12671 first = false;
12672 if (!first) sb.append(", ");
12673 sb.append("io:");
12674 if (this.io == null) {
12675 sb.append("null");
12676 } else {
12677 sb.append(this.io);
12678 }
12679 first = false;
12680 sb.append(")");
12681 return sb.toString();
12682 }
12683
12684 public void validate() throws org.apache.thrift.TException {
12685
12686 }
12687
12688 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12689 try {
12690 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12691 } catch (org.apache.thrift.TException te) {
12692 throw new java.io.IOException(te);
12693 }
12694 }
12695
12696 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12697 try {
12698
12699 __isset_bit_vector = new BitSet(1);
12700 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12701 } catch (org.apache.thrift.TException te) {
12702 throw new java.io.IOException(te);
12703 }
12704 }
12705
12706 private static class openScanner_resultStandardSchemeFactory implements SchemeFactory {
12707 public openScanner_resultStandardScheme getScheme() {
12708 return new openScanner_resultStandardScheme();
12709 }
12710 }
12711
12712 private static class openScanner_resultStandardScheme extends StandardScheme<openScanner_result> {
12713
12714 public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_result struct) throws org.apache.thrift.TException {
12715 org.apache.thrift.protocol.TField schemeField;
12716 iprot.readStructBegin();
12717 while (true)
12718 {
12719 schemeField = iprot.readFieldBegin();
12720 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
12721 break;
12722 }
12723 switch (schemeField.id) {
12724 case 0:
12725 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
12726 struct.success = iprot.readI32();
12727 struct.setSuccessIsSet(true);
12728 } else {
12729 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12730 }
12731 break;
12732 case 1:
12733 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
12734 struct.io = new TIOError();
12735 struct.io.read(iprot);
12736 struct.setIoIsSet(true);
12737 } else {
12738 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12739 }
12740 break;
12741 default:
12742 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12743 }
12744 iprot.readFieldEnd();
12745 }
12746 iprot.readStructEnd();
12747
12748
12749 struct.validate();
12750 }
12751
12752 public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_result struct) throws org.apache.thrift.TException {
12753 struct.validate();
12754
12755 oprot.writeStructBegin(STRUCT_DESC);
12756 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12757 oprot.writeI32(struct.success);
12758 oprot.writeFieldEnd();
12759 if (struct.io != null) {
12760 oprot.writeFieldBegin(IO_FIELD_DESC);
12761 struct.io.write(oprot);
12762 oprot.writeFieldEnd();
12763 }
12764 oprot.writeFieldStop();
12765 oprot.writeStructEnd();
12766 }
12767
12768 }
12769
12770 private static class openScanner_resultTupleSchemeFactory implements SchemeFactory {
12771 public openScanner_resultTupleScheme getScheme() {
12772 return new openScanner_resultTupleScheme();
12773 }
12774 }
12775
12776 private static class openScanner_resultTupleScheme extends TupleScheme<openScanner_result> {
12777
12778 @Override
12779 public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
12780 TTupleProtocol oprot = (TTupleProtocol) prot;
12781 BitSet optionals = new BitSet();
12782 if (struct.isSetSuccess()) {
12783 optionals.set(0);
12784 }
12785 if (struct.isSetIo()) {
12786 optionals.set(1);
12787 }
12788 oprot.writeBitSet(optionals, 2);
12789 if (struct.isSetSuccess()) {
12790 oprot.writeI32(struct.success);
12791 }
12792 if (struct.isSetIo()) {
12793 struct.io.write(oprot);
12794 }
12795 }
12796
12797 @Override
12798 public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
12799 TTupleProtocol iprot = (TTupleProtocol) prot;
12800 BitSet incoming = iprot.readBitSet(2);
12801 if (incoming.get(0)) {
12802 struct.success = iprot.readI32();
12803 struct.setSuccessIsSet(true);
12804 }
12805 if (incoming.get(1)) {
12806 struct.io = new TIOError();
12807 struct.io.read(iprot);
12808 struct.setIoIsSet(true);
12809 }
12810 }
12811 }
12812
12813 }
12814
12815 public static class getScannerRows_args implements org.apache.thrift.TBase<getScannerRows_args, getScannerRows_args._Fields>, java.io.Serializable, Cloneable {
12816 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_args");
12817
12818 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);
12819 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);
12820
12821 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
12822 static {
12823 schemes.put(StandardScheme.class, new getScannerRows_argsStandardSchemeFactory());
12824 schemes.put(TupleScheme.class, new getScannerRows_argsTupleSchemeFactory());
12825 }
12826
12827
12828
12829
12830 public int scannerId;
12831
12832
12833
12834 public int numRows;
12835
12836
12837 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
12838
12839
12840
12841 SCANNER_ID((short)1, "scannerId"),
12842
12843
12844
12845 NUM_ROWS((short)2, "numRows");
12846
12847 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12848
12849 static {
12850 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12851 byName.put(field.getFieldName(), field);
12852 }
12853 }
12854
12855
12856
12857
12858 public static _Fields findByThriftId(int fieldId) {
12859 switch(fieldId) {
12860 case 1:
12861 return SCANNER_ID;
12862 case 2:
12863 return NUM_ROWS;
12864 default:
12865 return null;
12866 }
12867 }
12868
12869
12870
12871
12872
12873 public static _Fields findByThriftIdOrThrow(int fieldId) {
12874 _Fields fields = findByThriftId(fieldId);
12875 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12876 return fields;
12877 }
12878
12879
12880
12881
12882 public static _Fields findByName(String name) {
12883 return byName.get(name);
12884 }
12885
12886 private final short _thriftId;
12887 private final String _fieldName;
12888
12889 _Fields(short thriftId, String fieldName) {
12890 _thriftId = thriftId;
12891 _fieldName = fieldName;
12892 }
12893
12894 public short getThriftFieldId() {
12895 return _thriftId;
12896 }
12897
12898 public String getFieldName() {
12899 return _fieldName;
12900 }
12901 }
12902
12903
12904 private static final int __SCANNERID_ISSET_ID = 0;
12905 private static final int __NUMROWS_ISSET_ID = 1;
12906 private BitSet __isset_bit_vector = new BitSet(2);
12907 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
12908 static {
12909 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
12910 tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
12911 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12912 tmpMap.put(_Fields.NUM_ROWS, new org.apache.thrift.meta_data.FieldMetaData("numRows", org.apache.thrift.TFieldRequirementType.DEFAULT,
12913 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12914 metaDataMap = Collections.unmodifiableMap(tmpMap);
12915 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_args.class, metaDataMap);
12916 }
12917
12918 public getScannerRows_args() {
12919 this.numRows = 1;
12920
12921 }
12922
12923 public getScannerRows_args(
12924 int scannerId,
12925 int numRows)
12926 {
12927 this();
12928 this.scannerId = scannerId;
12929 setScannerIdIsSet(true);
12930 this.numRows = numRows;
12931 setNumRowsIsSet(true);
12932 }
12933
12934
12935
12936
12937 public getScannerRows_args(getScannerRows_args other) {
12938 __isset_bit_vector.clear();
12939 __isset_bit_vector.or(other.__isset_bit_vector);
12940 this.scannerId = other.scannerId;
12941 this.numRows = other.numRows;
12942 }
12943
12944 public getScannerRows_args deepCopy() {
12945 return new getScannerRows_args(this);
12946 }
12947
12948 @Override
12949 public void clear() {
12950 setScannerIdIsSet(false);
12951 this.scannerId = 0;
12952 this.numRows = 1;
12953
12954 }
12955
12956
12957
12958
12959 public int getScannerId() {
12960 return this.scannerId;
12961 }
12962
12963
12964
12965
12966 public getScannerRows_args setScannerId(int scannerId) {
12967 this.scannerId = scannerId;
12968 setScannerIdIsSet(true);
12969 return this;
12970 }
12971
12972 public void unsetScannerId() {
12973 __isset_bit_vector.clear(__SCANNERID_ISSET_ID);
12974 }
12975
12976
12977 public boolean isSetScannerId() {
12978 return __isset_bit_vector.get(__SCANNERID_ISSET_ID);
12979 }
12980
12981 public void setScannerIdIsSet(boolean value) {
12982 __isset_bit_vector.set(__SCANNERID_ISSET_ID, value);
12983 }
12984
12985
12986
12987
12988 public int getNumRows() {
12989 return this.numRows;
12990 }
12991
12992
12993
12994
12995 public getScannerRows_args setNumRows(int numRows) {
12996 this.numRows = numRows;
12997 setNumRowsIsSet(true);
12998 return this;
12999 }
13000
13001 public void unsetNumRows() {
13002 __isset_bit_vector.clear(__NUMROWS_ISSET_ID);
13003 }
13004
13005
13006 public boolean isSetNumRows() {
13007 return __isset_bit_vector.get(__NUMROWS_ISSET_ID);
13008 }
13009
13010 public void setNumRowsIsSet(boolean value) {
13011 __isset_bit_vector.set(__NUMROWS_ISSET_ID, value);
13012 }
13013
13014 public void setFieldValue(_Fields field, Object value) {
13015 switch (field) {
13016 case SCANNER_ID:
13017 if (value == null) {
13018 unsetScannerId();
13019 } else {
13020 setScannerId((Integer)value);
13021 }
13022 break;
13023
13024 case NUM_ROWS:
13025 if (value == null) {
13026 unsetNumRows();
13027 } else {
13028 setNumRows((Integer)value);
13029 }
13030 break;
13031
13032 }
13033 }
13034
13035 public Object getFieldValue(_Fields field) {
13036 switch (field) {
13037 case SCANNER_ID:
13038 return Integer.valueOf(getScannerId());
13039
13040 case NUM_ROWS:
13041 return Integer.valueOf(getNumRows());
13042
13043 }
13044 throw new IllegalStateException();
13045 }
13046
13047
13048 public boolean isSet(_Fields field) {
13049 if (field == null) {
13050 throw new IllegalArgumentException();
13051 }
13052
13053 switch (field) {
13054 case SCANNER_ID:
13055 return isSetScannerId();
13056 case NUM_ROWS:
13057 return isSetNumRows();
13058 }
13059 throw new IllegalStateException();
13060 }
13061
13062 @Override
13063 public boolean equals(Object that) {
13064 if (that == null)
13065 return false;
13066 if (that instanceof getScannerRows_args)
13067 return this.equals((getScannerRows_args)that);
13068 return false;
13069 }
13070
13071 public boolean equals(getScannerRows_args that) {
13072 if (that == null)
13073 return false;
13074
13075 boolean this_present_scannerId = true;
13076 boolean that_present_scannerId = true;
13077 if (this_present_scannerId || that_present_scannerId) {
13078 if (!(this_present_scannerId && that_present_scannerId))
13079 return false;
13080 if (this.scannerId != that.scannerId)
13081 return false;
13082 }
13083
13084 boolean this_present_numRows = true;
13085 boolean that_present_numRows = true;
13086 if (this_present_numRows || that_present_numRows) {
13087 if (!(this_present_numRows && that_present_numRows))
13088 return false;
13089 if (this.numRows != that.numRows)
13090 return false;
13091 }
13092
13093 return true;
13094 }
13095
13096 @Override
13097 public int hashCode() {
13098 return 0;
13099 }
13100
13101 public int compareTo(getScannerRows_args other) {
13102 if (!getClass().equals(other.getClass())) {
13103 return getClass().getName().compareTo(other.getClass().getName());
13104 }
13105
13106 int lastComparison = 0;
13107 getScannerRows_args typedOther = (getScannerRows_args)other;
13108
13109 lastComparison = Boolean.valueOf(isSetScannerId()).compareTo(typedOther.isSetScannerId());
13110 if (lastComparison != 0) {
13111 return lastComparison;
13112 }
13113 if (isSetScannerId()) {
13114 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, typedOther.scannerId);
13115 if (lastComparison != 0) {
13116 return lastComparison;
13117 }
13118 }
13119 lastComparison = Boolean.valueOf(isSetNumRows()).compareTo(typedOther.isSetNumRows());
13120 if (lastComparison != 0) {
13121 return lastComparison;
13122 }
13123 if (isSetNumRows()) {
13124 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numRows, typedOther.numRows);
13125 if (lastComparison != 0) {
13126 return lastComparison;
13127 }
13128 }
13129 return 0;
13130 }
13131
13132 public _Fields fieldForId(int fieldId) {
13133 return _Fields.findByThriftId(fieldId);
13134 }
13135
13136 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
13137 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
13138 }
13139
13140 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
13141 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
13142 }
13143
13144 @Override
13145 public String toString() {
13146 StringBuilder sb = new StringBuilder("getScannerRows_args(");
13147 boolean first = true;
13148
13149 sb.append("scannerId:");
13150 sb.append(this.scannerId);
13151 first = false;
13152 if (!first) sb.append(", ");
13153 sb.append("numRows:");
13154 sb.append(this.numRows);
13155 first = false;
13156 sb.append(")");
13157 return sb.toString();
13158 }
13159
13160 public void validate() throws org.apache.thrift.TException {
13161
13162
13163 }
13164
13165 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
13166 try {
13167 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
13168 } catch (org.apache.thrift.TException te) {
13169 throw new java.io.IOException(te);
13170 }
13171 }
13172
13173 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
13174 try {
13175
13176 __isset_bit_vector = new BitSet(1);
13177 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
13178 } catch (org.apache.thrift.TException te) {
13179 throw new java.io.IOException(te);
13180 }
13181 }
13182
13183 private static class getScannerRows_argsStandardSchemeFactory implements SchemeFactory {
13184 public getScannerRows_argsStandardScheme getScheme() {
13185 return new getScannerRows_argsStandardScheme();
13186 }
13187 }
13188
13189 private static class getScannerRows_argsStandardScheme extends StandardScheme<getScannerRows_args> {
13190
13191 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_args struct) throws org.apache.thrift.TException {
13192 org.apache.thrift.protocol.TField schemeField;
13193 iprot.readStructBegin();
13194 while (true)
13195 {
13196 schemeField = iprot.readFieldBegin();
13197 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
13198 break;
13199 }
13200 switch (schemeField.id) {
13201 case 1:
13202 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
13203 struct.scannerId = iprot.readI32();
13204 struct.setScannerIdIsSet(true);
13205 } else {
13206 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13207 }
13208 break;
13209 case 2:
13210 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
13211 struct.numRows = iprot.readI32();
13212 struct.setNumRowsIsSet(true);
13213 } else {
13214 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13215 }
13216 break;
13217 default:
13218 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13219 }
13220 iprot.readFieldEnd();
13221 }
13222 iprot.readStructEnd();
13223
13224
13225 if (!struct.isSetScannerId()) {
13226 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
13227 }
13228 struct.validate();
13229 }
13230
13231 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_args struct) throws org.apache.thrift.TException {
13232 struct.validate();
13233
13234 oprot.writeStructBegin(STRUCT_DESC);
13235 oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
13236 oprot.writeI32(struct.scannerId);
13237 oprot.writeFieldEnd();
13238 oprot.writeFieldBegin(NUM_ROWS_FIELD_DESC);
13239 oprot.writeI32(struct.numRows);
13240 oprot.writeFieldEnd();
13241 oprot.writeFieldStop();
13242 oprot.writeStructEnd();
13243 }
13244
13245 }
13246
13247 private static class getScannerRows_argsTupleSchemeFactory implements SchemeFactory {
13248 public getScannerRows_argsTupleScheme getScheme() {
13249 return new getScannerRows_argsTupleScheme();
13250 }
13251 }
13252
13253 private static class getScannerRows_argsTupleScheme extends TupleScheme<getScannerRows_args> {
13254
13255 @Override
13256 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
13257 TTupleProtocol oprot = (TTupleProtocol) prot;
13258 oprot.writeI32(struct.scannerId);
13259 BitSet optionals = new BitSet();
13260 if (struct.isSetNumRows()) {
13261 optionals.set(0);
13262 }
13263 oprot.writeBitSet(optionals, 1);
13264 if (struct.isSetNumRows()) {
13265 oprot.writeI32(struct.numRows);
13266 }
13267 }
13268
13269 @Override
13270 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
13271 TTupleProtocol iprot = (TTupleProtocol) prot;
13272 struct.scannerId = iprot.readI32();
13273 struct.setScannerIdIsSet(true);
13274 BitSet incoming = iprot.readBitSet(1);
13275 if (incoming.get(0)) {
13276 struct.numRows = iprot.readI32();
13277 struct.setNumRowsIsSet(true);
13278 }
13279 }
13280 }
13281
13282 }
13283
13284 public static class getScannerRows_result implements org.apache.thrift.TBase<getScannerRows_result, getScannerRows_result._Fields>, java.io.Serializable, Cloneable {
13285 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_result");
13286
13287 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);
13288 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);
13289 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);
13290
13291 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
13292 static {
13293 schemes.put(StandardScheme.class, new getScannerRows_resultStandardSchemeFactory());
13294 schemes.put(TupleScheme.class, new getScannerRows_resultTupleSchemeFactory());
13295 }
13296
13297 public List<TResult> success;
13298 public TIOError io;
13299
13300
13301
13302 public TIllegalArgument ia;
13303
13304
13305 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
13306 SUCCESS((short)0, "success"),
13307 IO((short)1, "io"),
13308
13309
13310
13311 IA((short)2, "ia");
13312
13313 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13314
13315 static {
13316 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13317 byName.put(field.getFieldName(), field);
13318 }
13319 }
13320
13321
13322
13323
13324 public static _Fields findByThriftId(int fieldId) {
13325 switch(fieldId) {
13326 case 0:
13327 return SUCCESS;
13328 case 1:
13329 return IO;
13330 case 2:
13331 return IA;
13332 default:
13333 return null;
13334 }
13335 }
13336
13337
13338
13339
13340
13341 public static _Fields findByThriftIdOrThrow(int fieldId) {
13342 _Fields fields = findByThriftId(fieldId);
13343 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13344 return fields;
13345 }
13346
13347
13348
13349
13350 public static _Fields findByName(String name) {
13351 return byName.get(name);
13352 }
13353
13354 private final short _thriftId;
13355 private final String _fieldName;
13356
13357 _Fields(short thriftId, String fieldName) {
13358 _thriftId = thriftId;
13359 _fieldName = fieldName;
13360 }
13361
13362 public short getThriftFieldId() {
13363 return _thriftId;
13364 }
13365
13366 public String getFieldName() {
13367 return _fieldName;
13368 }
13369 }
13370
13371
13372 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
13373 static {
13374 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
13375 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
13376 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
13377 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
13378 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
13379 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
13380 tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
13381 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
13382 metaDataMap = Collections.unmodifiableMap(tmpMap);
13383 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_result.class, metaDataMap);
13384 }
13385
13386 public getScannerRows_result() {
13387 }
13388
13389 public getScannerRows_result(
13390 List<TResult> success,
13391 TIOError io,
13392 TIllegalArgument ia)
13393 {
13394 this();
13395 this.success = success;
13396 this.io = io;
13397 this.ia = ia;
13398 }
13399
13400
13401
13402
13403 public getScannerRows_result(getScannerRows_result other) {
13404 if (other.isSetSuccess()) {
13405 List<TResult> __this__success = new ArrayList<TResult>();
13406 for (TResult other_element : other.success) {
13407 __this__success.add(new TResult(other_element));
13408 }
13409 this.success = __this__success;
13410 }
13411 if (other.isSetIo()) {
13412 this.io = new TIOError(other.io);
13413 }
13414 if (other.isSetIa()) {
13415 this.ia = new TIllegalArgument(other.ia);
13416 }
13417 }
13418
13419 public getScannerRows_result deepCopy() {
13420 return new getScannerRows_result(this);
13421 }
13422
13423 @Override
13424 public void clear() {
13425 this.success = null;
13426 this.io = null;
13427 this.ia = null;
13428 }
13429
13430 public int getSuccessSize() {
13431 return (this.success == null) ? 0 : this.success.size();
13432 }
13433
13434 public java.util.Iterator<TResult> getSuccessIterator() {
13435 return (this.success == null) ? null : this.success.iterator();
13436 }
13437
13438 public void addToSuccess(TResult elem) {
13439 if (this.success == null) {
13440 this.success = new ArrayList<TResult>();
13441 }
13442 this.success.add(elem);
13443 }
13444
13445 public List<TResult> getSuccess() {
13446 return this.success;
13447 }
13448
13449 public getScannerRows_result setSuccess(List<TResult> success) {
13450 this.success = success;
13451 return this;
13452 }
13453
13454 public void unsetSuccess() {
13455 this.success = null;
13456 }
13457
13458
13459 public boolean isSetSuccess() {
13460 return this.success != null;
13461 }
13462
13463 public void setSuccessIsSet(boolean value) {
13464 if (!value) {
13465 this.success = null;
13466 }
13467 }
13468
13469 public TIOError getIo() {
13470 return this.io;
13471 }
13472
13473 public getScannerRows_result setIo(TIOError io) {
13474 this.io = io;
13475 return this;
13476 }
13477
13478 public void unsetIo() {
13479 this.io = null;
13480 }
13481
13482
13483 public boolean isSetIo() {
13484 return this.io != null;
13485 }
13486
13487 public void setIoIsSet(boolean value) {
13488 if (!value) {
13489 this.io = null;
13490 }
13491 }
13492
13493
13494
13495
13496 public TIllegalArgument getIa() {
13497 return this.ia;
13498 }
13499
13500
13501
13502
13503 public getScannerRows_result setIa(TIllegalArgument ia) {
13504 this.ia = ia;
13505 return this;
13506 }
13507
13508 public void unsetIa() {
13509 this.ia = null;
13510 }
13511
13512
13513 public boolean isSetIa() {
13514 return this.ia != null;
13515 }
13516
13517 public void setIaIsSet(boolean value) {
13518 if (!value) {
13519 this.ia = null;
13520 }
13521 }
13522
13523 public void setFieldValue(_Fields field, Object value) {
13524 switch (field) {
13525 case SUCCESS:
13526 if (value == null) {
13527 unsetSuccess();
13528 } else {
13529 setSuccess((List<TResult>)value);
13530 }
13531 break;
13532
13533 case IO:
13534 if (value == null) {
13535 unsetIo();
13536 } else {
13537 setIo((TIOError)value);
13538 }
13539 break;
13540
13541 case IA:
13542 if (value == null) {
13543 unsetIa();
13544 } else {
13545 setIa((TIllegalArgument)value);
13546 }
13547 break;
13548
13549 }
13550 }
13551
13552 public Object getFieldValue(_Fields field) {
13553 switch (field) {
13554 case SUCCESS:
13555 return getSuccess();
13556
13557 case IO:
13558 return getIo();
13559
13560 case IA:
13561 return getIa();
13562
13563 }
13564 throw new IllegalStateException();
13565 }
13566
13567
13568 public boolean isSet(_Fields field) {
13569 if (field == null) {
13570 throw new IllegalArgumentException();
13571 }
13572
13573 switch (field) {
13574 case SUCCESS:
13575 return isSetSuccess();
13576 case IO:
13577 return isSetIo();
13578 case IA:
13579 return isSetIa();
13580 }
13581 throw new IllegalStateException();
13582 }
13583
13584 @Override
13585 public boolean equals(Object that) {
13586 if (that == null)
13587 return false;
13588 if (that instanceof getScannerRows_result)
13589 return this.equals((getScannerRows_result)that);
13590 return false;
13591 }
13592
13593 public boolean equals(getScannerRows_result that) {
13594 if (that == null)
13595 return false;
13596
13597 boolean this_present_success = true && this.isSetSuccess();
13598 boolean that_present_success = true && that.isSetSuccess();
13599 if (this_present_success || that_present_success) {
13600 if (!(this_present_success && that_present_success))
13601 return false;
13602 if (!this.success.equals(that.success))
13603 return false;
13604 }
13605
13606 boolean this_present_io = true && this.isSetIo();
13607 boolean that_present_io = true && that.isSetIo();
13608 if (this_present_io || that_present_io) {
13609 if (!(this_present_io && that_present_io))
13610 return false;
13611 if (!this.io.equals(that.io))
13612 return false;
13613 }
13614
13615 boolean this_present_ia = true && this.isSetIa();
13616 boolean that_present_ia = true && that.isSetIa();
13617 if (this_present_ia || that_present_ia) {
13618 if (!(this_present_ia && that_present_ia))
13619 return false;
13620 if (!this.ia.equals(that.ia))
13621 return false;
13622 }
13623
13624 return true;
13625 }
13626
13627 @Override
13628 public int hashCode() {
13629 return 0;
13630 }
13631
13632 public int compareTo(getScannerRows_result other) {
13633 if (!getClass().equals(other.getClass())) {
13634 return getClass().getName().compareTo(other.getClass().getName());
13635 }
13636
13637 int lastComparison = 0;
13638 getScannerRows_result typedOther = (getScannerRows_result)other;
13639
13640 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
13641 if (lastComparison != 0) {
13642 return lastComparison;
13643 }
13644 if (isSetSuccess()) {
13645 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
13646 if (lastComparison != 0) {
13647 return lastComparison;
13648 }
13649 }
13650 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
13651 if (lastComparison != 0) {
13652 return lastComparison;
13653 }
13654 if (isSetIo()) {
13655 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
13656 if (lastComparison != 0) {
13657 return lastComparison;
13658 }
13659 }
13660 lastComparison = Boolean.valueOf(isSetIa()).compareTo(typedOther.isSetIa());
13661 if (lastComparison != 0) {
13662 return lastComparison;
13663 }
13664 if (isSetIa()) {
13665 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia);
13666 if (lastComparison != 0) {
13667 return lastComparison;
13668 }
13669 }
13670 return 0;
13671 }
13672
13673 public _Fields fieldForId(int fieldId) {
13674 return _Fields.findByThriftId(fieldId);
13675 }
13676
13677 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
13678 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
13679 }
13680
13681 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
13682 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
13683 }
13684
13685 @Override
13686 public String toString() {
13687 StringBuilder sb = new StringBuilder("getScannerRows_result(");
13688 boolean first = true;
13689
13690 sb.append("success:");
13691 if (this.success == null) {
13692 sb.append("null");
13693 } else {
13694 sb.append(this.success);
13695 }
13696 first = false;
13697 if (!first) sb.append(", ");
13698 sb.append("io:");
13699 if (this.io == null) {
13700 sb.append("null");
13701 } else {
13702 sb.append(this.io);
13703 }
13704 first = false;
13705 if (!first) sb.append(", ");
13706 sb.append("ia:");
13707 if (this.ia == null) {
13708 sb.append("null");
13709 } else {
13710 sb.append(this.ia);
13711 }
13712 first = false;
13713 sb.append(")");
13714 return sb.toString();
13715 }
13716
13717 public void validate() throws org.apache.thrift.TException {
13718
13719 }
13720
13721 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
13722 try {
13723 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
13724 } catch (org.apache.thrift.TException te) {
13725 throw new java.io.IOException(te);
13726 }
13727 }
13728
13729 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
13730 try {
13731 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
13732 } catch (org.apache.thrift.TException te) {
13733 throw new java.io.IOException(te);
13734 }
13735 }
13736
13737 private static class getScannerRows_resultStandardSchemeFactory implements SchemeFactory {
13738 public getScannerRows_resultStandardScheme getScheme() {
13739 return new getScannerRows_resultStandardScheme();
13740 }
13741 }
13742
13743 private static class getScannerRows_resultStandardScheme extends StandardScheme<getScannerRows_result> {
13744
13745 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_result struct) throws org.apache.thrift.TException {
13746 org.apache.thrift.protocol.TField schemeField;
13747 iprot.readStructBegin();
13748 while (true)
13749 {
13750 schemeField = iprot.readFieldBegin();
13751 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
13752 break;
13753 }
13754 switch (schemeField.id) {
13755 case 0:
13756 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
13757 {
13758 org.apache.thrift.protocol.TList _list136 = iprot.readListBegin();
13759 struct.success = new ArrayList<TResult>(_list136.size);
13760 for (int _i137 = 0; _i137 < _list136.size; ++_i137)
13761 {
13762 TResult _elem138;
13763 _elem138 = new TResult();
13764 _elem138.read(iprot);
13765 struct.success.add(_elem138);
13766 }
13767 iprot.readListEnd();
13768 }
13769 struct.setSuccessIsSet(true);
13770 } else {
13771 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13772 }
13773 break;
13774 case 1:
13775 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
13776 struct.io = new TIOError();
13777 struct.io.read(iprot);
13778 struct.setIoIsSet(true);
13779 } else {
13780 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13781 }
13782 break;
13783 case 2:
13784 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
13785 struct.ia = new TIllegalArgument();
13786 struct.ia.read(iprot);
13787 struct.setIaIsSet(true);
13788 } else {
13789 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13790 }
13791 break;
13792 default:
13793 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13794 }
13795 iprot.readFieldEnd();
13796 }
13797 iprot.readStructEnd();
13798
13799
13800 struct.validate();
13801 }
13802
13803 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_result struct) throws org.apache.thrift.TException {
13804 struct.validate();
13805
13806 oprot.writeStructBegin(STRUCT_DESC);
13807 if (struct.success != null) {
13808 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13809 {
13810 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
13811 for (TResult _iter139 : struct.success)
13812 {
13813 _iter139.write(oprot);
13814 }
13815 oprot.writeListEnd();
13816 }
13817 oprot.writeFieldEnd();
13818 }
13819 if (struct.io != null) {
13820 oprot.writeFieldBegin(IO_FIELD_DESC);
13821 struct.io.write(oprot);
13822 oprot.writeFieldEnd();
13823 }
13824 if (struct.ia != null) {
13825 oprot.writeFieldBegin(IA_FIELD_DESC);
13826 struct.ia.write(oprot);
13827 oprot.writeFieldEnd();
13828 }
13829 oprot.writeFieldStop();
13830 oprot.writeStructEnd();
13831 }
13832
13833 }
13834
13835 private static class getScannerRows_resultTupleSchemeFactory implements SchemeFactory {
13836 public getScannerRows_resultTupleScheme getScheme() {
13837 return new getScannerRows_resultTupleScheme();
13838 }
13839 }
13840
13841 private static class getScannerRows_resultTupleScheme extends TupleScheme<getScannerRows_result> {
13842
13843 @Override
13844 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
13845 TTupleProtocol oprot = (TTupleProtocol) prot;
13846 BitSet optionals = new BitSet();
13847 if (struct.isSetSuccess()) {
13848 optionals.set(0);
13849 }
13850 if (struct.isSetIo()) {
13851 optionals.set(1);
13852 }
13853 if (struct.isSetIa()) {
13854 optionals.set(2);
13855 }
13856 oprot.writeBitSet(optionals, 3);
13857 if (struct.isSetSuccess()) {
13858 {
13859 oprot.writeI32(struct.success.size());
13860 for (TResult _iter140 : struct.success)
13861 {
13862 _iter140.write(oprot);
13863 }
13864 }
13865 }
13866 if (struct.isSetIo()) {
13867 struct.io.write(oprot);
13868 }
13869 if (struct.isSetIa()) {
13870 struct.ia.write(oprot);
13871 }
13872 }
13873
13874 @Override
13875 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
13876 TTupleProtocol iprot = (TTupleProtocol) prot;
13877 BitSet incoming = iprot.readBitSet(3);
13878 if (incoming.get(0)) {
13879 {
13880 org.apache.thrift.protocol.TList _list141 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
13881 struct.success = new ArrayList<TResult>(_list141.size);
13882 for (int _i142 = 0; _i142 < _list141.size; ++_i142)
13883 {
13884 TResult _elem143;
13885 _elem143 = new TResult();
13886 _elem143.read(iprot);
13887 struct.success.add(_elem143);
13888 }
13889 }
13890 struct.setSuccessIsSet(true);
13891 }
13892 if (incoming.get(1)) {
13893 struct.io = new TIOError();
13894 struct.io.read(iprot);
13895 struct.setIoIsSet(true);
13896 }
13897 if (incoming.get(2)) {
13898 struct.ia = new TIllegalArgument();
13899 struct.ia.read(iprot);
13900 struct.setIaIsSet(true);
13901 }
13902 }
13903 }
13904
13905 }
13906
13907 public static class closeScanner_args implements org.apache.thrift.TBase<closeScanner_args, closeScanner_args._Fields>, java.io.Serializable, Cloneable {
13908 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_args");
13909
13910 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);
13911
13912 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
13913 static {
13914 schemes.put(StandardScheme.class, new closeScanner_argsStandardSchemeFactory());
13915 schemes.put(TupleScheme.class, new closeScanner_argsTupleSchemeFactory());
13916 }
13917
13918
13919
13920
13921 public int scannerId;
13922
13923
13924 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
13925
13926
13927
13928 SCANNER_ID((short)1, "scannerId");
13929
13930 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13931
13932 static {
13933 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13934 byName.put(field.getFieldName(), field);
13935 }
13936 }
13937
13938
13939
13940
13941 public static _Fields findByThriftId(int fieldId) {
13942 switch(fieldId) {
13943 case 1:
13944 return SCANNER_ID;
13945 default:
13946 return null;
13947 }
13948 }
13949
13950
13951
13952
13953
13954 public static _Fields findByThriftIdOrThrow(int fieldId) {
13955 _Fields fields = findByThriftId(fieldId);
13956 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13957 return fields;
13958 }
13959
13960
13961
13962
13963 public static _Fields findByName(String name) {
13964 return byName.get(name);
13965 }
13966
13967 private final short _thriftId;
13968 private final String _fieldName;
13969
13970 _Fields(short thriftId, String fieldName) {
13971 _thriftId = thriftId;
13972 _fieldName = fieldName;
13973 }
13974
13975 public short getThriftFieldId() {
13976 return _thriftId;
13977 }
13978
13979 public String getFieldName() {
13980 return _fieldName;
13981 }
13982 }
13983
13984
13985 private static final int __SCANNERID_ISSET_ID = 0;
13986 private BitSet __isset_bit_vector = new BitSet(1);
13987 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
13988 static {
13989 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
13990 tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
13991 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
13992 metaDataMap = Collections.unmodifiableMap(tmpMap);
13993 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_args.class, metaDataMap);
13994 }
13995
13996 public closeScanner_args() {
13997 }
13998
13999 public closeScanner_args(
14000 int scannerId)
14001 {
14002 this();
14003 this.scannerId = scannerId;
14004 setScannerIdIsSet(true);
14005 }
14006
14007
14008
14009
14010 public closeScanner_args(closeScanner_args other) {
14011 __isset_bit_vector.clear();
14012 __isset_bit_vector.or(other.__isset_bit_vector);
14013 this.scannerId = other.scannerId;
14014 }
14015
14016 public closeScanner_args deepCopy() {
14017 return new closeScanner_args(this);
14018 }
14019
14020 @Override
14021 public void clear() {
14022 setScannerIdIsSet(false);
14023 this.scannerId = 0;
14024 }
14025
14026
14027
14028
14029 public int getScannerId() {
14030 return this.scannerId;
14031 }
14032
14033
14034
14035
14036 public closeScanner_args setScannerId(int scannerId) {
14037 this.scannerId = scannerId;
14038 setScannerIdIsSet(true);
14039 return this;
14040 }
14041
14042 public void unsetScannerId() {
14043 __isset_bit_vector.clear(__SCANNERID_ISSET_ID);
14044 }
14045
14046
14047 public boolean isSetScannerId() {
14048 return __isset_bit_vector.get(__SCANNERID_ISSET_ID);
14049 }
14050
14051 public void setScannerIdIsSet(boolean value) {
14052 __isset_bit_vector.set(__SCANNERID_ISSET_ID, value);
14053 }
14054
14055 public void setFieldValue(_Fields field, Object value) {
14056 switch (field) {
14057 case SCANNER_ID:
14058 if (value == null) {
14059 unsetScannerId();
14060 } else {
14061 setScannerId((Integer)value);
14062 }
14063 break;
14064
14065 }
14066 }
14067
14068 public Object getFieldValue(_Fields field) {
14069 switch (field) {
14070 case SCANNER_ID:
14071 return Integer.valueOf(getScannerId());
14072
14073 }
14074 throw new IllegalStateException();
14075 }
14076
14077
14078 public boolean isSet(_Fields field) {
14079 if (field == null) {
14080 throw new IllegalArgumentException();
14081 }
14082
14083 switch (field) {
14084 case SCANNER_ID:
14085 return isSetScannerId();
14086 }
14087 throw new IllegalStateException();
14088 }
14089
14090 @Override
14091 public boolean equals(Object that) {
14092 if (that == null)
14093 return false;
14094 if (that instanceof closeScanner_args)
14095 return this.equals((closeScanner_args)that);
14096 return false;
14097 }
14098
14099 public boolean equals(closeScanner_args that) {
14100 if (that == null)
14101 return false;
14102
14103 boolean this_present_scannerId = true;
14104 boolean that_present_scannerId = true;
14105 if (this_present_scannerId || that_present_scannerId) {
14106 if (!(this_present_scannerId && that_present_scannerId))
14107 return false;
14108 if (this.scannerId != that.scannerId)
14109 return false;
14110 }
14111
14112 return true;
14113 }
14114
14115 @Override
14116 public int hashCode() {
14117 return 0;
14118 }
14119
14120 public int compareTo(closeScanner_args other) {
14121 if (!getClass().equals(other.getClass())) {
14122 return getClass().getName().compareTo(other.getClass().getName());
14123 }
14124
14125 int lastComparison = 0;
14126 closeScanner_args typedOther = (closeScanner_args)other;
14127
14128 lastComparison = Boolean.valueOf(isSetScannerId()).compareTo(typedOther.isSetScannerId());
14129 if (lastComparison != 0) {
14130 return lastComparison;
14131 }
14132 if (isSetScannerId()) {
14133 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, typedOther.scannerId);
14134 if (lastComparison != 0) {
14135 return lastComparison;
14136 }
14137 }
14138 return 0;
14139 }
14140
14141 public _Fields fieldForId(int fieldId) {
14142 return _Fields.findByThriftId(fieldId);
14143 }
14144
14145 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
14146 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
14147 }
14148
14149 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
14150 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
14151 }
14152
14153 @Override
14154 public String toString() {
14155 StringBuilder sb = new StringBuilder("closeScanner_args(");
14156 boolean first = true;
14157
14158 sb.append("scannerId:");
14159 sb.append(this.scannerId);
14160 first = false;
14161 sb.append(")");
14162 return sb.toString();
14163 }
14164
14165 public void validate() throws org.apache.thrift.TException {
14166
14167
14168 }
14169
14170 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
14171 try {
14172 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
14173 } catch (org.apache.thrift.TException te) {
14174 throw new java.io.IOException(te);
14175 }
14176 }
14177
14178 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
14179 try {
14180
14181 __isset_bit_vector = new BitSet(1);
14182 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
14183 } catch (org.apache.thrift.TException te) {
14184 throw new java.io.IOException(te);
14185 }
14186 }
14187
14188 private static class closeScanner_argsStandardSchemeFactory implements SchemeFactory {
14189 public closeScanner_argsStandardScheme getScheme() {
14190 return new closeScanner_argsStandardScheme();
14191 }
14192 }
14193
14194 private static class closeScanner_argsStandardScheme extends StandardScheme<closeScanner_args> {
14195
14196 public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_args struct) throws org.apache.thrift.TException {
14197 org.apache.thrift.protocol.TField schemeField;
14198 iprot.readStructBegin();
14199 while (true)
14200 {
14201 schemeField = iprot.readFieldBegin();
14202 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
14203 break;
14204 }
14205 switch (schemeField.id) {
14206 case 1:
14207 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
14208 struct.scannerId = iprot.readI32();
14209 struct.setScannerIdIsSet(true);
14210 } else {
14211 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14212 }
14213 break;
14214 default:
14215 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14216 }
14217 iprot.readFieldEnd();
14218 }
14219 iprot.readStructEnd();
14220
14221
14222 if (!struct.isSetScannerId()) {
14223 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
14224 }
14225 struct.validate();
14226 }
14227
14228 public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_args struct) throws org.apache.thrift.TException {
14229 struct.validate();
14230
14231 oprot.writeStructBegin(STRUCT_DESC);
14232 oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
14233 oprot.writeI32(struct.scannerId);
14234 oprot.writeFieldEnd();
14235 oprot.writeFieldStop();
14236 oprot.writeStructEnd();
14237 }
14238
14239 }
14240
14241 private static class closeScanner_argsTupleSchemeFactory implements SchemeFactory {
14242 public closeScanner_argsTupleScheme getScheme() {
14243 return new closeScanner_argsTupleScheme();
14244 }
14245 }
14246
14247 private static class closeScanner_argsTupleScheme extends TupleScheme<closeScanner_args> {
14248
14249 @Override
14250 public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
14251 TTupleProtocol oprot = (TTupleProtocol) prot;
14252 oprot.writeI32(struct.scannerId);
14253 }
14254
14255 @Override
14256 public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
14257 TTupleProtocol iprot = (TTupleProtocol) prot;
14258 struct.scannerId = iprot.readI32();
14259 struct.setScannerIdIsSet(true);
14260 }
14261 }
14262
14263 }
14264
14265 public static class closeScanner_result implements org.apache.thrift.TBase<closeScanner_result, closeScanner_result._Fields>, java.io.Serializable, Cloneable {
14266 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_result");
14267
14268 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);
14269 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);
14270
14271 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
14272 static {
14273 schemes.put(StandardScheme.class, new closeScanner_resultStandardSchemeFactory());
14274 schemes.put(TupleScheme.class, new closeScanner_resultTupleSchemeFactory());
14275 }
14276
14277 public TIOError io;
14278
14279
14280
14281 public TIllegalArgument ia;
14282
14283
14284 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
14285 IO((short)1, "io"),
14286
14287
14288
14289 IA((short)2, "ia");
14290
14291 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14292
14293 static {
14294 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14295 byName.put(field.getFieldName(), field);
14296 }
14297 }
14298
14299
14300
14301
14302 public static _Fields findByThriftId(int fieldId) {
14303 switch(fieldId) {
14304 case 1:
14305 return IO;
14306 case 2:
14307 return IA;
14308 default:
14309 return null;
14310 }
14311 }
14312
14313
14314
14315
14316
14317 public static _Fields findByThriftIdOrThrow(int fieldId) {
14318 _Fields fields = findByThriftId(fieldId);
14319 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14320 return fields;
14321 }
14322
14323
14324
14325
14326 public static _Fields findByName(String name) {
14327 return byName.get(name);
14328 }
14329
14330 private final short _thriftId;
14331 private final String _fieldName;
14332
14333 _Fields(short thriftId, String fieldName) {
14334 _thriftId = thriftId;
14335 _fieldName = fieldName;
14336 }
14337
14338 public short getThriftFieldId() {
14339 return _thriftId;
14340 }
14341
14342 public String getFieldName() {
14343 return _fieldName;
14344 }
14345 }
14346
14347
14348 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
14349 static {
14350 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
14351 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
14352 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
14353 tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
14354 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
14355 metaDataMap = Collections.unmodifiableMap(tmpMap);
14356 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_result.class, metaDataMap);
14357 }
14358
14359 public closeScanner_result() {
14360 }
14361
14362 public closeScanner_result(
14363 TIOError io,
14364 TIllegalArgument ia)
14365 {
14366 this();
14367 this.io = io;
14368 this.ia = ia;
14369 }
14370
14371
14372
14373
14374 public closeScanner_result(closeScanner_result other) {
14375 if (other.isSetIo()) {
14376 this.io = new TIOError(other.io);
14377 }
14378 if (other.isSetIa()) {
14379 this.ia = new TIllegalArgument(other.ia);
14380 }
14381 }
14382
14383 public closeScanner_result deepCopy() {
14384 return new closeScanner_result(this);
14385 }
14386
14387 @Override
14388 public void clear() {
14389 this.io = null;
14390 this.ia = null;
14391 }
14392
14393 public TIOError getIo() {
14394 return this.io;
14395 }
14396
14397 public closeScanner_result setIo(TIOError io) {
14398 this.io = io;
14399 return this;
14400 }
14401
14402 public void unsetIo() {
14403 this.io = null;
14404 }
14405
14406
14407 public boolean isSetIo() {
14408 return this.io != null;
14409 }
14410
14411 public void setIoIsSet(boolean value) {
14412 if (!value) {
14413 this.io = null;
14414 }
14415 }
14416
14417
14418
14419
14420 public TIllegalArgument getIa() {
14421 return this.ia;
14422 }
14423
14424
14425
14426
14427 public closeScanner_result setIa(TIllegalArgument ia) {
14428 this.ia = ia;
14429 return this;
14430 }
14431
14432 public void unsetIa() {
14433 this.ia = null;
14434 }
14435
14436
14437 public boolean isSetIa() {
14438 return this.ia != null;
14439 }
14440
14441 public void setIaIsSet(boolean value) {
14442 if (!value) {
14443 this.ia = null;
14444 }
14445 }
14446
14447 public void setFieldValue(_Fields field, Object value) {
14448 switch (field) {
14449 case IO:
14450 if (value == null) {
14451 unsetIo();
14452 } else {
14453 setIo((TIOError)value);
14454 }
14455 break;
14456
14457 case IA:
14458 if (value == null) {
14459 unsetIa();
14460 } else {
14461 setIa((TIllegalArgument)value);
14462 }
14463 break;
14464
14465 }
14466 }
14467
14468 public Object getFieldValue(_Fields field) {
14469 switch (field) {
14470 case IO:
14471 return getIo();
14472
14473 case IA:
14474 return getIa();
14475
14476 }
14477 throw new IllegalStateException();
14478 }
14479
14480
14481 public boolean isSet(_Fields field) {
14482 if (field == null) {
14483 throw new IllegalArgumentException();
14484 }
14485
14486 switch (field) {
14487 case IO:
14488 return isSetIo();
14489 case IA:
14490 return isSetIa();
14491 }
14492 throw new IllegalStateException();
14493 }
14494
14495 @Override
14496 public boolean equals(Object that) {
14497 if (that == null)
14498 return false;
14499 if (that instanceof closeScanner_result)
14500 return this.equals((closeScanner_result)that);
14501 return false;
14502 }
14503
14504 public boolean equals(closeScanner_result that) {
14505 if (that == null)
14506 return false;
14507
14508 boolean this_present_io = true && this.isSetIo();
14509 boolean that_present_io = true && that.isSetIo();
14510 if (this_present_io || that_present_io) {
14511 if (!(this_present_io && that_present_io))
14512 return false;
14513 if (!this.io.equals(that.io))
14514 return false;
14515 }
14516
14517 boolean this_present_ia = true && this.isSetIa();
14518 boolean that_present_ia = true && that.isSetIa();
14519 if (this_present_ia || that_present_ia) {
14520 if (!(this_present_ia && that_present_ia))
14521 return false;
14522 if (!this.ia.equals(that.ia))
14523 return false;
14524 }
14525
14526 return true;
14527 }
14528
14529 @Override
14530 public int hashCode() {
14531 return 0;
14532 }
14533
14534 public int compareTo(closeScanner_result other) {
14535 if (!getClass().equals(other.getClass())) {
14536 return getClass().getName().compareTo(other.getClass().getName());
14537 }
14538
14539 int lastComparison = 0;
14540 closeScanner_result typedOther = (closeScanner_result)other;
14541
14542 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
14543 if (lastComparison != 0) {
14544 return lastComparison;
14545 }
14546 if (isSetIo()) {
14547 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
14548 if (lastComparison != 0) {
14549 return lastComparison;
14550 }
14551 }
14552 lastComparison = Boolean.valueOf(isSetIa()).compareTo(typedOther.isSetIa());
14553 if (lastComparison != 0) {
14554 return lastComparison;
14555 }
14556 if (isSetIa()) {
14557 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia);
14558 if (lastComparison != 0) {
14559 return lastComparison;
14560 }
14561 }
14562 return 0;
14563 }
14564
14565 public _Fields fieldForId(int fieldId) {
14566 return _Fields.findByThriftId(fieldId);
14567 }
14568
14569 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
14570 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
14571 }
14572
14573 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
14574 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
14575 }
14576
14577 @Override
14578 public String toString() {
14579 StringBuilder sb = new StringBuilder("closeScanner_result(");
14580 boolean first = true;
14581
14582 sb.append("io:");
14583 if (this.io == null) {
14584 sb.append("null");
14585 } else {
14586 sb.append(this.io);
14587 }
14588 first = false;
14589 if (!first) sb.append(", ");
14590 sb.append("ia:");
14591 if (this.ia == null) {
14592 sb.append("null");
14593 } else {
14594 sb.append(this.ia);
14595 }
14596 first = false;
14597 sb.append(")");
14598 return sb.toString();
14599 }
14600
14601 public void validate() throws org.apache.thrift.TException {
14602
14603 }
14604
14605 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
14606 try {
14607 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
14608 } catch (org.apache.thrift.TException te) {
14609 throw new java.io.IOException(te);
14610 }
14611 }
14612
14613 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
14614 try {
14615 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
14616 } catch (org.apache.thrift.TException te) {
14617 throw new java.io.IOException(te);
14618 }
14619 }
14620
14621 private static class closeScanner_resultStandardSchemeFactory implements SchemeFactory {
14622 public closeScanner_resultStandardScheme getScheme() {
14623 return new closeScanner_resultStandardScheme();
14624 }
14625 }
14626
14627 private static class closeScanner_resultStandardScheme extends StandardScheme<closeScanner_result> {
14628
14629 public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_result struct) throws org.apache.thrift.TException {
14630 org.apache.thrift.protocol.TField schemeField;
14631 iprot.readStructBegin();
14632 while (true)
14633 {
14634 schemeField = iprot.readFieldBegin();
14635 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
14636 break;
14637 }
14638 switch (schemeField.id) {
14639 case 1:
14640 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14641 struct.io = new TIOError();
14642 struct.io.read(iprot);
14643 struct.setIoIsSet(true);
14644 } else {
14645 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14646 }
14647 break;
14648 case 2:
14649 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14650 struct.ia = new TIllegalArgument();
14651 struct.ia.read(iprot);
14652 struct.setIaIsSet(true);
14653 } else {
14654 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14655 }
14656 break;
14657 default:
14658 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14659 }
14660 iprot.readFieldEnd();
14661 }
14662 iprot.readStructEnd();
14663
14664
14665 struct.validate();
14666 }
14667
14668 public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_result struct) throws org.apache.thrift.TException {
14669 struct.validate();
14670
14671 oprot.writeStructBegin(STRUCT_DESC);
14672 if (struct.io != null) {
14673 oprot.writeFieldBegin(IO_FIELD_DESC);
14674 struct.io.write(oprot);
14675 oprot.writeFieldEnd();
14676 }
14677 if (struct.ia != null) {
14678 oprot.writeFieldBegin(IA_FIELD_DESC);
14679 struct.ia.write(oprot);
14680 oprot.writeFieldEnd();
14681 }
14682 oprot.writeFieldStop();
14683 oprot.writeStructEnd();
14684 }
14685
14686 }
14687
14688 private static class closeScanner_resultTupleSchemeFactory implements SchemeFactory {
14689 public closeScanner_resultTupleScheme getScheme() {
14690 return new closeScanner_resultTupleScheme();
14691 }
14692 }
14693
14694 private static class closeScanner_resultTupleScheme extends TupleScheme<closeScanner_result> {
14695
14696 @Override
14697 public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
14698 TTupleProtocol oprot = (TTupleProtocol) prot;
14699 BitSet optionals = new BitSet();
14700 if (struct.isSetIo()) {
14701 optionals.set(0);
14702 }
14703 if (struct.isSetIa()) {
14704 optionals.set(1);
14705 }
14706 oprot.writeBitSet(optionals, 2);
14707 if (struct.isSetIo()) {
14708 struct.io.write(oprot);
14709 }
14710 if (struct.isSetIa()) {
14711 struct.ia.write(oprot);
14712 }
14713 }
14714
14715 @Override
14716 public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
14717 TTupleProtocol iprot = (TTupleProtocol) prot;
14718 BitSet incoming = iprot.readBitSet(2);
14719 if (incoming.get(0)) {
14720 struct.io = new TIOError();
14721 struct.io.read(iprot);
14722 struct.setIoIsSet(true);
14723 }
14724 if (incoming.get(1)) {
14725 struct.ia = new TIllegalArgument();
14726 struct.ia.read(iprot);
14727 struct.setIaIsSet(true);
14728 }
14729 }
14730 }
14731
14732 }
14733
14734 public static class mutateRow_args implements org.apache.thrift.TBase<mutateRow_args, mutateRow_args._Fields>, java.io.Serializable, Cloneable {
14735 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRow_args");
14736
14737 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);
14738 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);
14739
14740 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
14741 static {
14742 schemes.put(StandardScheme.class, new mutateRow_argsStandardSchemeFactory());
14743 schemes.put(TupleScheme.class, new mutateRow_argsTupleSchemeFactory());
14744 }
14745
14746
14747
14748
14749 public ByteBuffer table;
14750
14751
14752
14753 public TRowMutations rowMutations;
14754
14755
14756 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
14757
14758
14759
14760 TABLE((short)1, "table"),
14761
14762
14763
14764 ROW_MUTATIONS((short)2, "rowMutations");
14765
14766 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14767
14768 static {
14769 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14770 byName.put(field.getFieldName(), field);
14771 }
14772 }
14773
14774
14775
14776
14777 public static _Fields findByThriftId(int fieldId) {
14778 switch(fieldId) {
14779 case 1:
14780 return TABLE;
14781 case 2:
14782 return ROW_MUTATIONS;
14783 default:
14784 return null;
14785 }
14786 }
14787
14788
14789
14790
14791
14792 public static _Fields findByThriftIdOrThrow(int fieldId) {
14793 _Fields fields = findByThriftId(fieldId);
14794 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14795 return fields;
14796 }
14797
14798
14799
14800
14801 public static _Fields findByName(String name) {
14802 return byName.get(name);
14803 }
14804
14805 private final short _thriftId;
14806 private final String _fieldName;
14807
14808 _Fields(short thriftId, String fieldName) {
14809 _thriftId = thriftId;
14810 _fieldName = fieldName;
14811 }
14812
14813 public short getThriftFieldId() {
14814 return _thriftId;
14815 }
14816
14817 public String getFieldName() {
14818 return _fieldName;
14819 }
14820 }
14821
14822
14823 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
14824 static {
14825 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
14826 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
14827 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
14828 tmpMap.put(_Fields.ROW_MUTATIONS, new org.apache.thrift.meta_data.FieldMetaData("rowMutations", org.apache.thrift.TFieldRequirementType.REQUIRED,
14829 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowMutations.class)));
14830 metaDataMap = Collections.unmodifiableMap(tmpMap);
14831 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
14832 }
14833
14834 public mutateRow_args() {
14835 }
14836
14837 public mutateRow_args(
14838 ByteBuffer table,
14839 TRowMutations rowMutations)
14840 {
14841 this();
14842 this.table = table;
14843 this.rowMutations = rowMutations;
14844 }
14845
14846
14847
14848
14849 public mutateRow_args(mutateRow_args other) {
14850 if (other.isSetTable()) {
14851 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
14852 ;
14853 }
14854 if (other.isSetRowMutations()) {
14855 this.rowMutations = new TRowMutations(other.rowMutations);
14856 }
14857 }
14858
14859 public mutateRow_args deepCopy() {
14860 return new mutateRow_args(this);
14861 }
14862
14863 @Override
14864 public void clear() {
14865 this.table = null;
14866 this.rowMutations = null;
14867 }
14868
14869
14870
14871
14872 public byte[] getTable() {
14873 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
14874 return table == null ? null : table.array();
14875 }
14876
14877 public ByteBuffer bufferForTable() {
14878 return table;
14879 }
14880
14881
14882
14883
14884 public mutateRow_args setTable(byte[] table) {
14885 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
14886 return this;
14887 }
14888
14889 public mutateRow_args setTable(ByteBuffer table) {
14890 this.table = table;
14891 return this;
14892 }
14893
14894 public void unsetTable() {
14895 this.table = null;
14896 }
14897
14898
14899 public boolean isSetTable() {
14900 return this.table != null;
14901 }
14902
14903 public void setTableIsSet(boolean value) {
14904 if (!value) {
14905 this.table = null;
14906 }
14907 }
14908
14909
14910
14911
14912 public TRowMutations getRowMutations() {
14913 return this.rowMutations;
14914 }
14915
14916
14917
14918
14919 public mutateRow_args setRowMutations(TRowMutations rowMutations) {
14920 this.rowMutations = rowMutations;
14921 return this;
14922 }
14923
14924 public void unsetRowMutations() {
14925 this.rowMutations = null;
14926 }
14927
14928
14929 public boolean isSetRowMutations() {
14930 return this.rowMutations != null;
14931 }
14932
14933 public void setRowMutationsIsSet(boolean value) {
14934 if (!value) {
14935 this.rowMutations = null;
14936 }
14937 }
14938
14939 public void setFieldValue(_Fields field, Object value) {
14940 switch (field) {
14941 case TABLE:
14942 if (value == null) {
14943 unsetTable();
14944 } else {
14945 setTable((ByteBuffer)value);
14946 }
14947 break;
14948
14949 case ROW_MUTATIONS:
14950 if (value == null) {
14951 unsetRowMutations();
14952 } else {
14953 setRowMutations((TRowMutations)value);
14954 }
14955 break;
14956
14957 }
14958 }
14959
14960 public Object getFieldValue(_Fields field) {
14961 switch (field) {
14962 case TABLE:
14963 return getTable();
14964
14965 case ROW_MUTATIONS:
14966 return getRowMutations();
14967
14968 }
14969 throw new IllegalStateException();
14970 }
14971
14972
14973 public boolean isSet(_Fields field) {
14974 if (field == null) {
14975 throw new IllegalArgumentException();
14976 }
14977
14978 switch (field) {
14979 case TABLE:
14980 return isSetTable();
14981 case ROW_MUTATIONS:
14982 return isSetRowMutations();
14983 }
14984 throw new IllegalStateException();
14985 }
14986
14987 @Override
14988 public boolean equals(Object that) {
14989 if (that == null)
14990 return false;
14991 if (that instanceof mutateRow_args)
14992 return this.equals((mutateRow_args)that);
14993 return false;
14994 }
14995
14996 public boolean equals(mutateRow_args that) {
14997 if (that == null)
14998 return false;
14999
15000 boolean this_present_table = true && this.isSetTable();
15001 boolean that_present_table = true && that.isSetTable();
15002 if (this_present_table || that_present_table) {
15003 if (!(this_present_table && that_present_table))
15004 return false;
15005 if (!this.table.equals(that.table))
15006 return false;
15007 }
15008
15009 boolean this_present_rowMutations = true && this.isSetRowMutations();
15010 boolean that_present_rowMutations = true && that.isSetRowMutations();
15011 if (this_present_rowMutations || that_present_rowMutations) {
15012 if (!(this_present_rowMutations && that_present_rowMutations))
15013 return false;
15014 if (!this.rowMutations.equals(that.rowMutations))
15015 return false;
15016 }
15017
15018 return true;
15019 }
15020
15021 @Override
15022 public int hashCode() {
15023 return 0;
15024 }
15025
15026 public int compareTo(mutateRow_args other) {
15027 if (!getClass().equals(other.getClass())) {
15028 return getClass().getName().compareTo(other.getClass().getName());
15029 }
15030
15031 int lastComparison = 0;
15032 mutateRow_args typedOther = (mutateRow_args)other;
15033
15034 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
15035 if (lastComparison != 0) {
15036 return lastComparison;
15037 }
15038 if (isSetTable()) {
15039 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
15040 if (lastComparison != 0) {
15041 return lastComparison;
15042 }
15043 }
15044 lastComparison = Boolean.valueOf(isSetRowMutations()).compareTo(typedOther.isSetRowMutations());
15045 if (lastComparison != 0) {
15046 return lastComparison;
15047 }
15048 if (isSetRowMutations()) {
15049 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rowMutations, typedOther.rowMutations);
15050 if (lastComparison != 0) {
15051 return lastComparison;
15052 }
15053 }
15054 return 0;
15055 }
15056
15057 public _Fields fieldForId(int fieldId) {
15058 return _Fields.findByThriftId(fieldId);
15059 }
15060
15061 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
15062 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
15063 }
15064
15065 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
15066 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
15067 }
15068
15069 @Override
15070 public String toString() {
15071 StringBuilder sb = new StringBuilder("mutateRow_args(");
15072 boolean first = true;
15073
15074 sb.append("table:");
15075 if (this.table == null) {
15076 sb.append("null");
15077 } else {
15078 org.apache.thrift.TBaseHelper.toString(this.table, sb);
15079 }
15080 first = false;
15081 if (!first) sb.append(", ");
15082 sb.append("rowMutations:");
15083 if (this.rowMutations == null) {
15084 sb.append("null");
15085 } else {
15086 sb.append(this.rowMutations);
15087 }
15088 first = false;
15089 sb.append(")");
15090 return sb.toString();
15091 }
15092
15093 public void validate() throws org.apache.thrift.TException {
15094
15095 if (table == null) {
15096 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
15097 }
15098 if (rowMutations == null) {
15099 throw new org.apache.thrift.protocol.TProtocolException("Required field 'rowMutations' was not present! Struct: " + toString());
15100 }
15101 }
15102
15103 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
15104 try {
15105 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
15106 } catch (org.apache.thrift.TException te) {
15107 throw new java.io.IOException(te);
15108 }
15109 }
15110
15111 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
15112 try {
15113 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
15114 } catch (org.apache.thrift.TException te) {
15115 throw new java.io.IOException(te);
15116 }
15117 }
15118
15119 private static class mutateRow_argsStandardSchemeFactory implements SchemeFactory {
15120 public mutateRow_argsStandardScheme getScheme() {
15121 return new mutateRow_argsStandardScheme();
15122 }
15123 }
15124
15125 private static class mutateRow_argsStandardScheme extends StandardScheme<mutateRow_args> {
15126
15127 public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_args struct) throws org.apache.thrift.TException {
15128 org.apache.thrift.protocol.TField schemeField;
15129 iprot.readStructBegin();
15130 while (true)
15131 {
15132 schemeField = iprot.readFieldBegin();
15133 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
15134 break;
15135 }
15136 switch (schemeField.id) {
15137 case 1:
15138 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
15139 struct.table = iprot.readBinary();
15140 struct.setTableIsSet(true);
15141 } else {
15142 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15143 }
15144 break;
15145 case 2:
15146 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
15147 struct.rowMutations = new TRowMutations();
15148 struct.rowMutations.read(iprot);
15149 struct.setRowMutationsIsSet(true);
15150 } else {
15151 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15152 }
15153 break;
15154 default:
15155 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15156 }
15157 iprot.readFieldEnd();
15158 }
15159 iprot.readStructEnd();
15160
15161
15162 struct.validate();
15163 }
15164
15165 public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_args struct) throws org.apache.thrift.TException {
15166 struct.validate();
15167
15168 oprot.writeStructBegin(STRUCT_DESC);
15169 if (struct.table != null) {
15170 oprot.writeFieldBegin(TABLE_FIELD_DESC);
15171 oprot.writeBinary(struct.table);
15172 oprot.writeFieldEnd();
15173 }
15174 if (struct.rowMutations != null) {
15175 oprot.writeFieldBegin(ROW_MUTATIONS_FIELD_DESC);
15176 struct.rowMutations.write(oprot);
15177 oprot.writeFieldEnd();
15178 }
15179 oprot.writeFieldStop();
15180 oprot.writeStructEnd();
15181 }
15182
15183 }
15184
15185 private static class mutateRow_argsTupleSchemeFactory implements SchemeFactory {
15186 public mutateRow_argsTupleScheme getScheme() {
15187 return new mutateRow_argsTupleScheme();
15188 }
15189 }
15190
15191 private static class mutateRow_argsTupleScheme extends TupleScheme<mutateRow_args> {
15192
15193 @Override
15194 public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
15195 TTupleProtocol oprot = (TTupleProtocol) prot;
15196 oprot.writeBinary(struct.table);
15197 struct.rowMutations.write(oprot);
15198 }
15199
15200 @Override
15201 public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
15202 TTupleProtocol iprot = (TTupleProtocol) prot;
15203 struct.table = iprot.readBinary();
15204 struct.setTableIsSet(true);
15205 struct.rowMutations = new TRowMutations();
15206 struct.rowMutations.read(iprot);
15207 struct.setRowMutationsIsSet(true);
15208 }
15209 }
15210
15211 }
15212
15213 public static class mutateRow_result implements org.apache.thrift.TBase<mutateRow_result, mutateRow_result._Fields>, java.io.Serializable, Cloneable {
15214 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRow_result");
15215
15216 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);
15217
15218 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
15219 static {
15220 schemes.put(StandardScheme.class, new mutateRow_resultStandardSchemeFactory());
15221 schemes.put(TupleScheme.class, new mutateRow_resultTupleSchemeFactory());
15222 }
15223
15224 public TIOError io;
15225
15226
15227 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
15228 IO((short)1, "io");
15229
15230 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15231
15232 static {
15233 for (_Fields field : EnumSet.allOf(_Fields.class)) {
15234 byName.put(field.getFieldName(), field);
15235 }
15236 }
15237
15238
15239
15240
15241 public static _Fields findByThriftId(int fieldId) {
15242 switch(fieldId) {
15243 case 1:
15244 return IO;
15245 default:
15246 return null;
15247 }
15248 }
15249
15250
15251
15252
15253
15254 public static _Fields findByThriftIdOrThrow(int fieldId) {
15255 _Fields fields = findByThriftId(fieldId);
15256 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15257 return fields;
15258 }
15259
15260
15261
15262
15263 public static _Fields findByName(String name) {
15264 return byName.get(name);
15265 }
15266
15267 private final short _thriftId;
15268 private final String _fieldName;
15269
15270 _Fields(short thriftId, String fieldName) {
15271 _thriftId = thriftId;
15272 _fieldName = fieldName;
15273 }
15274
15275 public short getThriftFieldId() {
15276 return _thriftId;
15277 }
15278
15279 public String getFieldName() {
15280 return _fieldName;
15281 }
15282 }
15283
15284
15285 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
15286 static {
15287 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
15288 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
15289 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
15290 metaDataMap = Collections.unmodifiableMap(tmpMap);
15291 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap);
15292 }
15293
15294 public mutateRow_result() {
15295 }
15296
15297 public mutateRow_result(
15298 TIOError io)
15299 {
15300 this();
15301 this.io = io;
15302 }
15303
15304
15305
15306
15307 public mutateRow_result(mutateRow_result other) {
15308 if (other.isSetIo()) {
15309 this.io = new TIOError(other.io);
15310 }
15311 }
15312
15313 public mutateRow_result deepCopy() {
15314 return new mutateRow_result(this);
15315 }
15316
15317 @Override
15318 public void clear() {
15319 this.io = null;
15320 }
15321
15322 public TIOError getIo() {
15323 return this.io;
15324 }
15325
15326 public mutateRow_result setIo(TIOError io) {
15327 this.io = io;
15328 return this;
15329 }
15330
15331 public void unsetIo() {
15332 this.io = null;
15333 }
15334
15335
15336 public boolean isSetIo() {
15337 return this.io != null;
15338 }
15339
15340 public void setIoIsSet(boolean value) {
15341 if (!value) {
15342 this.io = null;
15343 }
15344 }
15345
15346 public void setFieldValue(_Fields field, Object value) {
15347 switch (field) {
15348 case IO:
15349 if (value == null) {
15350 unsetIo();
15351 } else {
15352 setIo((TIOError)value);
15353 }
15354 break;
15355
15356 }
15357 }
15358
15359 public Object getFieldValue(_Fields field) {
15360 switch (field) {
15361 case IO:
15362 return getIo();
15363
15364 }
15365 throw new IllegalStateException();
15366 }
15367
15368
15369 public boolean isSet(_Fields field) {
15370 if (field == null) {
15371 throw new IllegalArgumentException();
15372 }
15373
15374 switch (field) {
15375 case IO:
15376 return isSetIo();
15377 }
15378 throw new IllegalStateException();
15379 }
15380
15381 @Override
15382 public boolean equals(Object that) {
15383 if (that == null)
15384 return false;
15385 if (that instanceof mutateRow_result)
15386 return this.equals((mutateRow_result)that);
15387 return false;
15388 }
15389
15390 public boolean equals(mutateRow_result that) {
15391 if (that == null)
15392 return false;
15393
15394 boolean this_present_io = true && this.isSetIo();
15395 boolean that_present_io = true && that.isSetIo();
15396 if (this_present_io || that_present_io) {
15397 if (!(this_present_io && that_present_io))
15398 return false;
15399 if (!this.io.equals(that.io))
15400 return false;
15401 }
15402
15403 return true;
15404 }
15405
15406 @Override
15407 public int hashCode() {
15408 return 0;
15409 }
15410
15411 public int compareTo(mutateRow_result other) {
15412 if (!getClass().equals(other.getClass())) {
15413 return getClass().getName().compareTo(other.getClass().getName());
15414 }
15415
15416 int lastComparison = 0;
15417 mutateRow_result typedOther = (mutateRow_result)other;
15418
15419 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
15420 if (lastComparison != 0) {
15421 return lastComparison;
15422 }
15423 if (isSetIo()) {
15424 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
15425 if (lastComparison != 0) {
15426 return lastComparison;
15427 }
15428 }
15429 return 0;
15430 }
15431
15432 public _Fields fieldForId(int fieldId) {
15433 return _Fields.findByThriftId(fieldId);
15434 }
15435
15436 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
15437 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
15438 }
15439
15440 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
15441 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
15442 }
15443
15444 @Override
15445 public String toString() {
15446 StringBuilder sb = new StringBuilder("mutateRow_result(");
15447 boolean first = true;
15448
15449 sb.append("io:");
15450 if (this.io == null) {
15451 sb.append("null");
15452 } else {
15453 sb.append(this.io);
15454 }
15455 first = false;
15456 sb.append(")");
15457 return sb.toString();
15458 }
15459
15460 public void validate() throws org.apache.thrift.TException {
15461
15462 }
15463
15464 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
15465 try {
15466 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
15467 } catch (org.apache.thrift.TException te) {
15468 throw new java.io.IOException(te);
15469 }
15470 }
15471
15472 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
15473 try {
15474 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
15475 } catch (org.apache.thrift.TException te) {
15476 throw new java.io.IOException(te);
15477 }
15478 }
15479
15480 private static class mutateRow_resultStandardSchemeFactory implements SchemeFactory {
15481 public mutateRow_resultStandardScheme getScheme() {
15482 return new mutateRow_resultStandardScheme();
15483 }
15484 }
15485
15486 private static class mutateRow_resultStandardScheme extends StandardScheme<mutateRow_result> {
15487
15488 public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_result struct) throws org.apache.thrift.TException {
15489 org.apache.thrift.protocol.TField schemeField;
15490 iprot.readStructBegin();
15491 while (true)
15492 {
15493 schemeField = iprot.readFieldBegin();
15494 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
15495 break;
15496 }
15497 switch (schemeField.id) {
15498 case 1:
15499 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
15500 struct.io = new TIOError();
15501 struct.io.read(iprot);
15502 struct.setIoIsSet(true);
15503 } else {
15504 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15505 }
15506 break;
15507 default:
15508 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15509 }
15510 iprot.readFieldEnd();
15511 }
15512 iprot.readStructEnd();
15513
15514
15515 struct.validate();
15516 }
15517
15518 public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_result struct) throws org.apache.thrift.TException {
15519 struct.validate();
15520
15521 oprot.writeStructBegin(STRUCT_DESC);
15522 if (struct.io != null) {
15523 oprot.writeFieldBegin(IO_FIELD_DESC);
15524 struct.io.write(oprot);
15525 oprot.writeFieldEnd();
15526 }
15527 oprot.writeFieldStop();
15528 oprot.writeStructEnd();
15529 }
15530
15531 }
15532
15533 private static class mutateRow_resultTupleSchemeFactory implements SchemeFactory {
15534 public mutateRow_resultTupleScheme getScheme() {
15535 return new mutateRow_resultTupleScheme();
15536 }
15537 }
15538
15539 private static class mutateRow_resultTupleScheme extends TupleScheme<mutateRow_result> {
15540
15541 @Override
15542 public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
15543 TTupleProtocol oprot = (TTupleProtocol) prot;
15544 BitSet optionals = new BitSet();
15545 if (struct.isSetIo()) {
15546 optionals.set(0);
15547 }
15548 oprot.writeBitSet(optionals, 1);
15549 if (struct.isSetIo()) {
15550 struct.io.write(oprot);
15551 }
15552 }
15553
15554 @Override
15555 public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
15556 TTupleProtocol iprot = (TTupleProtocol) prot;
15557 BitSet incoming = iprot.readBitSet(1);
15558 if (incoming.get(0)) {
15559 struct.io = new TIOError();
15560 struct.io.read(iprot);
15561 struct.setIoIsSet(true);
15562 }
15563 }
15564 }
15565
15566 }
15567
15568 public static class getScannerResults_args implements org.apache.thrift.TBase<getScannerResults_args, getScannerResults_args._Fields>, java.io.Serializable, Cloneable {
15569 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerResults_args");
15570
15571 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);
15572 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);
15573 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);
15574
15575 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
15576 static {
15577 schemes.put(StandardScheme.class, new getScannerResults_argsStandardSchemeFactory());
15578 schemes.put(TupleScheme.class, new getScannerResults_argsTupleSchemeFactory());
15579 }
15580
15581
15582
15583
15584 public ByteBuffer table;
15585
15586
15587
15588 public TScan scan;
15589
15590
15591
15592 public int numRows;
15593
15594
15595 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
15596
15597
15598
15599 TABLE((short)1, "table"),
15600
15601
15602
15603 SCAN((short)2, "scan"),
15604
15605
15606
15607 NUM_ROWS((short)3, "numRows");
15608
15609 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15610
15611 static {
15612 for (_Fields field : EnumSet.allOf(_Fields.class)) {
15613 byName.put(field.getFieldName(), field);
15614 }
15615 }
15616
15617
15618
15619
15620 public static _Fields findByThriftId(int fieldId) {
15621 switch(fieldId) {
15622 case 1:
15623 return TABLE;
15624 case 2:
15625 return SCAN;
15626 case 3:
15627 return NUM_ROWS;
15628 default:
15629 return null;
15630 }
15631 }
15632
15633
15634
15635
15636
15637 public static _Fields findByThriftIdOrThrow(int fieldId) {
15638 _Fields fields = findByThriftId(fieldId);
15639 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15640 return fields;
15641 }
15642
15643
15644
15645
15646 public static _Fields findByName(String name) {
15647 return byName.get(name);
15648 }
15649
15650 private final short _thriftId;
15651 private final String _fieldName;
15652
15653 _Fields(short thriftId, String fieldName) {
15654 _thriftId = thriftId;
15655 _fieldName = fieldName;
15656 }
15657
15658 public short getThriftFieldId() {
15659 return _thriftId;
15660 }
15661
15662 public String getFieldName() {
15663 return _fieldName;
15664 }
15665 }
15666
15667
15668 private static final int __NUMROWS_ISSET_ID = 0;
15669 private BitSet __isset_bit_vector = new BitSet(1);
15670 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
15671 static {
15672 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
15673 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
15674 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
15675 tmpMap.put(_Fields.SCAN, new org.apache.thrift.meta_data.FieldMetaData("scan", org.apache.thrift.TFieldRequirementType.REQUIRED,
15676 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TScan.class)));
15677 tmpMap.put(_Fields.NUM_ROWS, new org.apache.thrift.meta_data.FieldMetaData("numRows", org.apache.thrift.TFieldRequirementType.DEFAULT,
15678 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
15679 metaDataMap = Collections.unmodifiableMap(tmpMap);
15680 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerResults_args.class, metaDataMap);
15681 }
15682
15683 public getScannerResults_args() {
15684 this.numRows = 1;
15685
15686 }
15687
15688 public getScannerResults_args(
15689 ByteBuffer table,
15690 TScan scan,
15691 int numRows)
15692 {
15693 this();
15694 this.table = table;
15695 this.scan = scan;
15696 this.numRows = numRows;
15697 setNumRowsIsSet(true);
15698 }
15699
15700
15701
15702
15703 public getScannerResults_args(getScannerResults_args other) {
15704 __isset_bit_vector.clear();
15705 __isset_bit_vector.or(other.__isset_bit_vector);
15706 if (other.isSetTable()) {
15707 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
15708 ;
15709 }
15710 if (other.isSetScan()) {
15711 this.scan = new TScan(other.scan);
15712 }
15713 this.numRows = other.numRows;
15714 }
15715
15716 public getScannerResults_args deepCopy() {
15717 return new getScannerResults_args(this);
15718 }
15719
15720 @Override
15721 public void clear() {
15722 this.table = null;
15723 this.scan = null;
15724 this.numRows = 1;
15725
15726 }
15727
15728
15729
15730
15731 public byte[] getTable() {
15732 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
15733 return table == null ? null : table.array();
15734 }
15735
15736 public ByteBuffer bufferForTable() {
15737 return table;
15738 }
15739
15740
15741
15742
15743 public getScannerResults_args setTable(byte[] table) {
15744 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
15745 return this;
15746 }
15747
15748 public getScannerResults_args setTable(ByteBuffer table) {
15749 this.table = table;
15750 return this;
15751 }
15752
15753 public void unsetTable() {
15754 this.table = null;
15755 }
15756
15757
15758 public boolean isSetTable() {
15759 return this.table != null;
15760 }
15761
15762 public void setTableIsSet(boolean value) {
15763 if (!value) {
15764 this.table = null;
15765 }
15766 }
15767
15768
15769
15770
15771 public TScan getScan() {
15772 return this.scan;
15773 }
15774
15775
15776
15777
15778 public getScannerResults_args setScan(TScan scan) {
15779 this.scan = scan;
15780 return this;
15781 }
15782
15783 public void unsetScan() {
15784 this.scan = null;
15785 }
15786
15787
15788 public boolean isSetScan() {
15789 return this.scan != null;
15790 }
15791
15792 public void setScanIsSet(boolean value) {
15793 if (!value) {
15794 this.scan = null;
15795 }
15796 }
15797
15798
15799
15800
15801 public int getNumRows() {
15802 return this.numRows;
15803 }
15804
15805
15806
15807
15808 public getScannerResults_args setNumRows(int numRows) {
15809 this.numRows = numRows;
15810 setNumRowsIsSet(true);
15811 return this;
15812 }
15813
15814 public void unsetNumRows() {
15815 __isset_bit_vector.clear(__NUMROWS_ISSET_ID);
15816 }
15817
15818
15819 public boolean isSetNumRows() {
15820 return __isset_bit_vector.get(__NUMROWS_ISSET_ID);
15821 }
15822
15823 public void setNumRowsIsSet(boolean value) {
15824 __isset_bit_vector.set(__NUMROWS_ISSET_ID, value);
15825 }
15826
15827 public void setFieldValue(_Fields field, Object value) {
15828 switch (field) {
15829 case TABLE:
15830 if (value == null) {
15831 unsetTable();
15832 } else {
15833 setTable((ByteBuffer)value);
15834 }
15835 break;
15836
15837 case SCAN:
15838 if (value == null) {
15839 unsetScan();
15840 } else {
15841 setScan((TScan)value);
15842 }
15843 break;
15844
15845 case NUM_ROWS:
15846 if (value == null) {
15847 unsetNumRows();
15848 } else {
15849 setNumRows((Integer)value);
15850 }
15851 break;
15852
15853 }
15854 }
15855
15856 public Object getFieldValue(_Fields field) {
15857 switch (field) {
15858 case TABLE:
15859 return getTable();
15860
15861 case SCAN:
15862 return getScan();
15863
15864 case NUM_ROWS:
15865 return Integer.valueOf(getNumRows());
15866
15867 }
15868 throw new IllegalStateException();
15869 }
15870
15871
15872 public boolean isSet(_Fields field) {
15873 if (field == null) {
15874 throw new IllegalArgumentException();
15875 }
15876
15877 switch (field) {
15878 case TABLE:
15879 return isSetTable();
15880 case SCAN:
15881 return isSetScan();
15882 case NUM_ROWS:
15883 return isSetNumRows();
15884 }
15885 throw new IllegalStateException();
15886 }
15887
15888 @Override
15889 public boolean equals(Object that) {
15890 if (that == null)
15891 return false;
15892 if (that instanceof getScannerResults_args)
15893 return this.equals((getScannerResults_args)that);
15894 return false;
15895 }
15896
15897 public boolean equals(getScannerResults_args that) {
15898 if (that == null)
15899 return false;
15900
15901 boolean this_present_table = true && this.isSetTable();
15902 boolean that_present_table = true && that.isSetTable();
15903 if (this_present_table || that_present_table) {
15904 if (!(this_present_table && that_present_table))
15905 return false;
15906 if (!this.table.equals(that.table))
15907 return false;
15908 }
15909
15910 boolean this_present_scan = true && this.isSetScan();
15911 boolean that_present_scan = true && that.isSetScan();
15912 if (this_present_scan || that_present_scan) {
15913 if (!(this_present_scan && that_present_scan))
15914 return false;
15915 if (!this.scan.equals(that.scan))
15916 return false;
15917 }
15918
15919 boolean this_present_numRows = true;
15920 boolean that_present_numRows = true;
15921 if (this_present_numRows || that_present_numRows) {
15922 if (!(this_present_numRows && that_present_numRows))
15923 return false;
15924 if (this.numRows != that.numRows)
15925 return false;
15926 }
15927
15928 return true;
15929 }
15930
15931 @Override
15932 public int hashCode() {
15933 return 0;
15934 }
15935
15936 public int compareTo(getScannerResults_args other) {
15937 if (!getClass().equals(other.getClass())) {
15938 return getClass().getName().compareTo(other.getClass().getName());
15939 }
15940
15941 int lastComparison = 0;
15942 getScannerResults_args typedOther = (getScannerResults_args)other;
15943
15944 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
15945 if (lastComparison != 0) {
15946 return lastComparison;
15947 }
15948 if (isSetTable()) {
15949 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
15950 if (lastComparison != 0) {
15951 return lastComparison;
15952 }
15953 }
15954 lastComparison = Boolean.valueOf(isSetScan()).compareTo(typedOther.isSetScan());
15955 if (lastComparison != 0) {
15956 return lastComparison;
15957 }
15958 if (isSetScan()) {
15959 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scan, typedOther.scan);
15960 if (lastComparison != 0) {
15961 return lastComparison;
15962 }
15963 }
15964 lastComparison = Boolean.valueOf(isSetNumRows()).compareTo(typedOther.isSetNumRows());
15965 if (lastComparison != 0) {
15966 return lastComparison;
15967 }
15968 if (isSetNumRows()) {
15969 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numRows, typedOther.numRows);
15970 if (lastComparison != 0) {
15971 return lastComparison;
15972 }
15973 }
15974 return 0;
15975 }
15976
15977 public _Fields fieldForId(int fieldId) {
15978 return _Fields.findByThriftId(fieldId);
15979 }
15980
15981 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
15982 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
15983 }
15984
15985 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
15986 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
15987 }
15988
15989 @Override
15990 public String toString() {
15991 StringBuilder sb = new StringBuilder("getScannerResults_args(");
15992 boolean first = true;
15993
15994 sb.append("table:");
15995 if (this.table == null) {
15996 sb.append("null");
15997 } else {
15998 org.apache.thrift.TBaseHelper.toString(this.table, sb);
15999 }
16000 first = false;
16001 if (!first) sb.append(", ");
16002 sb.append("scan:");
16003 if (this.scan == null) {
16004 sb.append("null");
16005 } else {
16006 sb.append(this.scan);
16007 }
16008 first = false;
16009 if (!first) sb.append(", ");
16010 sb.append("numRows:");
16011 sb.append(this.numRows);
16012 first = false;
16013 sb.append(")");
16014 return sb.toString();
16015 }
16016
16017 public void validate() throws org.apache.thrift.TException {
16018
16019 if (table == null) {
16020 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
16021 }
16022 if (scan == null) {
16023 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scan' was not present! Struct: " + toString());
16024 }
16025 }
16026
16027 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
16028 try {
16029 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
16030 } catch (org.apache.thrift.TException te) {
16031 throw new java.io.IOException(te);
16032 }
16033 }
16034
16035 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
16036 try {
16037
16038 __isset_bit_vector = new BitSet(1);
16039 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
16040 } catch (org.apache.thrift.TException te) {
16041 throw new java.io.IOException(te);
16042 }
16043 }
16044
16045 private static class getScannerResults_argsStandardSchemeFactory implements SchemeFactory {
16046 public getScannerResults_argsStandardScheme getScheme() {
16047 return new getScannerResults_argsStandardScheme();
16048 }
16049 }
16050
16051 private static class getScannerResults_argsStandardScheme extends StandardScheme<getScannerResults_args> {
16052
16053 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerResults_args struct) throws org.apache.thrift.TException {
16054 org.apache.thrift.protocol.TField schemeField;
16055 iprot.readStructBegin();
16056 while (true)
16057 {
16058 schemeField = iprot.readFieldBegin();
16059 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
16060 break;
16061 }
16062 switch (schemeField.id) {
16063 case 1:
16064 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
16065 struct.table = iprot.readBinary();
16066 struct.setTableIsSet(true);
16067 } else {
16068 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16069 }
16070 break;
16071 case 2:
16072 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
16073 struct.scan = new TScan();
16074 struct.scan.read(iprot);
16075 struct.setScanIsSet(true);
16076 } else {
16077 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16078 }
16079 break;
16080 case 3:
16081 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
16082 struct.numRows = iprot.readI32();
16083 struct.setNumRowsIsSet(true);
16084 } else {
16085 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16086 }
16087 break;
16088 default:
16089 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16090 }
16091 iprot.readFieldEnd();
16092 }
16093 iprot.readStructEnd();
16094
16095
16096 struct.validate();
16097 }
16098
16099 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerResults_args struct) throws org.apache.thrift.TException {
16100 struct.validate();
16101
16102 oprot.writeStructBegin(STRUCT_DESC);
16103 if (struct.table != null) {
16104 oprot.writeFieldBegin(TABLE_FIELD_DESC);
16105 oprot.writeBinary(struct.table);
16106 oprot.writeFieldEnd();
16107 }
16108 if (struct.scan != null) {
16109 oprot.writeFieldBegin(SCAN_FIELD_DESC);
16110 struct.scan.write(oprot);
16111 oprot.writeFieldEnd();
16112 }
16113 oprot.writeFieldBegin(NUM_ROWS_FIELD_DESC);
16114 oprot.writeI32(struct.numRows);
16115 oprot.writeFieldEnd();
16116 oprot.writeFieldStop();
16117 oprot.writeStructEnd();
16118 }
16119
16120 }
16121
16122 private static class getScannerResults_argsTupleSchemeFactory implements SchemeFactory {
16123 public getScannerResults_argsTupleScheme getScheme() {
16124 return new getScannerResults_argsTupleScheme();
16125 }
16126 }
16127
16128 private static class getScannerResults_argsTupleScheme extends TupleScheme<getScannerResults_args> {
16129
16130 @Override
16131 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerResults_args struct) throws org.apache.thrift.TException {
16132 TTupleProtocol oprot = (TTupleProtocol) prot;
16133 oprot.writeBinary(struct.table);
16134 struct.scan.write(oprot);
16135 BitSet optionals = new BitSet();
16136 if (struct.isSetNumRows()) {
16137 optionals.set(0);
16138 }
16139 oprot.writeBitSet(optionals, 1);
16140 if (struct.isSetNumRows()) {
16141 oprot.writeI32(struct.numRows);
16142 }
16143 }
16144
16145 @Override
16146 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerResults_args struct) throws org.apache.thrift.TException {
16147 TTupleProtocol iprot = (TTupleProtocol) prot;
16148 struct.table = iprot.readBinary();
16149 struct.setTableIsSet(true);
16150 struct.scan = new TScan();
16151 struct.scan.read(iprot);
16152 struct.setScanIsSet(true);
16153 BitSet incoming = iprot.readBitSet(1);
16154 if (incoming.get(0)) {
16155 struct.numRows = iprot.readI32();
16156 struct.setNumRowsIsSet(true);
16157 }
16158 }
16159 }
16160
16161 }
16162
16163 public static class getScannerResults_result implements org.apache.thrift.TBase<getScannerResults_result, getScannerResults_result._Fields>, java.io.Serializable, Cloneable {
16164 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerResults_result");
16165
16166 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);
16167 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);
16168
16169 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
16170 static {
16171 schemes.put(StandardScheme.class, new getScannerResults_resultStandardSchemeFactory());
16172 schemes.put(TupleScheme.class, new getScannerResults_resultTupleSchemeFactory());
16173 }
16174
16175 public List<TResult> success;
16176 public TIOError io;
16177
16178
16179 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
16180 SUCCESS((short)0, "success"),
16181 IO((short)1, "io");
16182
16183 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16184
16185 static {
16186 for (_Fields field : EnumSet.allOf(_Fields.class)) {
16187 byName.put(field.getFieldName(), field);
16188 }
16189 }
16190
16191
16192
16193
16194 public static _Fields findByThriftId(int fieldId) {
16195 switch(fieldId) {
16196 case 0:
16197 return SUCCESS;
16198 case 1:
16199 return IO;
16200 default:
16201 return null;
16202 }
16203 }
16204
16205
16206
16207
16208
16209 public static _Fields findByThriftIdOrThrow(int fieldId) {
16210 _Fields fields = findByThriftId(fieldId);
16211 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16212 return fields;
16213 }
16214
16215
16216
16217
16218 public static _Fields findByName(String name) {
16219 return byName.get(name);
16220 }
16221
16222 private final short _thriftId;
16223 private final String _fieldName;
16224
16225 _Fields(short thriftId, String fieldName) {
16226 _thriftId = thriftId;
16227 _fieldName = fieldName;
16228 }
16229
16230 public short getThriftFieldId() {
16231 return _thriftId;
16232 }
16233
16234 public String getFieldName() {
16235 return _fieldName;
16236 }
16237 }
16238
16239
16240 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
16241 static {
16242 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
16243 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
16244 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
16245 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
16246 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
16247 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
16248 metaDataMap = Collections.unmodifiableMap(tmpMap);
16249 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerResults_result.class, metaDataMap);
16250 }
16251
16252 public getScannerResults_result() {
16253 }
16254
16255 public getScannerResults_result(
16256 List<TResult> success,
16257 TIOError io)
16258 {
16259 this();
16260 this.success = success;
16261 this.io = io;
16262 }
16263
16264
16265
16266
16267 public getScannerResults_result(getScannerResults_result other) {
16268 if (other.isSetSuccess()) {
16269 List<TResult> __this__success = new ArrayList<TResult>();
16270 for (TResult other_element : other.success) {
16271 __this__success.add(new TResult(other_element));
16272 }
16273 this.success = __this__success;
16274 }
16275 if (other.isSetIo()) {
16276 this.io = new TIOError(other.io);
16277 }
16278 }
16279
16280 public getScannerResults_result deepCopy() {
16281 return new getScannerResults_result(this);
16282 }
16283
16284 @Override
16285 public void clear() {
16286 this.success = null;
16287 this.io = null;
16288 }
16289
16290 public int getSuccessSize() {
16291 return (this.success == null) ? 0 : this.success.size();
16292 }
16293
16294 public java.util.Iterator<TResult> getSuccessIterator() {
16295 return (this.success == null) ? null : this.success.iterator();
16296 }
16297
16298 public void addToSuccess(TResult elem) {
16299 if (this.success == null) {
16300 this.success = new ArrayList<TResult>();
16301 }
16302 this.success.add(elem);
16303 }
16304
16305 public List<TResult> getSuccess() {
16306 return this.success;
16307 }
16308
16309 public getScannerResults_result setSuccess(List<TResult> success) {
16310 this.success = success;
16311 return this;
16312 }
16313
16314 public void unsetSuccess() {
16315 this.success = null;
16316 }
16317
16318
16319 public boolean isSetSuccess() {
16320 return this.success != null;
16321 }
16322
16323 public void setSuccessIsSet(boolean value) {
16324 if (!value) {
16325 this.success = null;
16326 }
16327 }
16328
16329 public TIOError getIo() {
16330 return this.io;
16331 }
16332
16333 public getScannerResults_result setIo(TIOError io) {
16334 this.io = io;
16335 return this;
16336 }
16337
16338 public void unsetIo() {
16339 this.io = null;
16340 }
16341
16342
16343 public boolean isSetIo() {
16344 return this.io != null;
16345 }
16346
16347 public void setIoIsSet(boolean value) {
16348 if (!value) {
16349 this.io = null;
16350 }
16351 }
16352
16353 public void setFieldValue(_Fields field, Object value) {
16354 switch (field) {
16355 case SUCCESS:
16356 if (value == null) {
16357 unsetSuccess();
16358 } else {
16359 setSuccess((List<TResult>)value);
16360 }
16361 break;
16362
16363 case IO:
16364 if (value == null) {
16365 unsetIo();
16366 } else {
16367 setIo((TIOError)value);
16368 }
16369 break;
16370
16371 }
16372 }
16373
16374 public Object getFieldValue(_Fields field) {
16375 switch (field) {
16376 case SUCCESS:
16377 return getSuccess();
16378
16379 case IO:
16380 return getIo();
16381
16382 }
16383 throw new IllegalStateException();
16384 }
16385
16386
16387 public boolean isSet(_Fields field) {
16388 if (field == null) {
16389 throw new IllegalArgumentException();
16390 }
16391
16392 switch (field) {
16393 case SUCCESS:
16394 return isSetSuccess();
16395 case IO:
16396 return isSetIo();
16397 }
16398 throw new IllegalStateException();
16399 }
16400
16401 @Override
16402 public boolean equals(Object that) {
16403 if (that == null)
16404 return false;
16405 if (that instanceof getScannerResults_result)
16406 return this.equals((getScannerResults_result)that);
16407 return false;
16408 }
16409
16410 public boolean equals(getScannerResults_result that) {
16411 if (that == null)
16412 return false;
16413
16414 boolean this_present_success = true && this.isSetSuccess();
16415 boolean that_present_success = true && that.isSetSuccess();
16416 if (this_present_success || that_present_success) {
16417 if (!(this_present_success && that_present_success))
16418 return false;
16419 if (!this.success.equals(that.success))
16420 return false;
16421 }
16422
16423 boolean this_present_io = true && this.isSetIo();
16424 boolean that_present_io = true && that.isSetIo();
16425 if (this_present_io || that_present_io) {
16426 if (!(this_present_io && that_present_io))
16427 return false;
16428 if (!this.io.equals(that.io))
16429 return false;
16430 }
16431
16432 return true;
16433 }
16434
16435 @Override
16436 public int hashCode() {
16437 return 0;
16438 }
16439
16440 public int compareTo(getScannerResults_result other) {
16441 if (!getClass().equals(other.getClass())) {
16442 return getClass().getName().compareTo(other.getClass().getName());
16443 }
16444
16445 int lastComparison = 0;
16446 getScannerResults_result typedOther = (getScannerResults_result)other;
16447
16448 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
16449 if (lastComparison != 0) {
16450 return lastComparison;
16451 }
16452 if (isSetSuccess()) {
16453 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
16454 if (lastComparison != 0) {
16455 return lastComparison;
16456 }
16457 }
16458 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
16459 if (lastComparison != 0) {
16460 return lastComparison;
16461 }
16462 if (isSetIo()) {
16463 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
16464 if (lastComparison != 0) {
16465 return lastComparison;
16466 }
16467 }
16468 return 0;
16469 }
16470
16471 public _Fields fieldForId(int fieldId) {
16472 return _Fields.findByThriftId(fieldId);
16473 }
16474
16475 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
16476 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
16477 }
16478
16479 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
16480 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
16481 }
16482
16483 @Override
16484 public String toString() {
16485 StringBuilder sb = new StringBuilder("getScannerResults_result(");
16486 boolean first = true;
16487
16488 sb.append("success:");
16489 if (this.success == null) {
16490 sb.append("null");
16491 } else {
16492 sb.append(this.success);
16493 }
16494 first = false;
16495 if (!first) sb.append(", ");
16496 sb.append("io:");
16497 if (this.io == null) {
16498 sb.append("null");
16499 } else {
16500 sb.append(this.io);
16501 }
16502 first = false;
16503 sb.append(")");
16504 return sb.toString();
16505 }
16506
16507 public void validate() throws org.apache.thrift.TException {
16508
16509 }
16510
16511 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
16512 try {
16513 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
16514 } catch (org.apache.thrift.TException te) {
16515 throw new java.io.IOException(te);
16516 }
16517 }
16518
16519 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
16520 try {
16521 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
16522 } catch (org.apache.thrift.TException te) {
16523 throw new java.io.IOException(te);
16524 }
16525 }
16526
16527 private static class getScannerResults_resultStandardSchemeFactory implements SchemeFactory {
16528 public getScannerResults_resultStandardScheme getScheme() {
16529 return new getScannerResults_resultStandardScheme();
16530 }
16531 }
16532
16533 private static class getScannerResults_resultStandardScheme extends StandardScheme<getScannerResults_result> {
16534
16535 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerResults_result struct) throws org.apache.thrift.TException {
16536 org.apache.thrift.protocol.TField schemeField;
16537 iprot.readStructBegin();
16538 while (true)
16539 {
16540 schemeField = iprot.readFieldBegin();
16541 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
16542 break;
16543 }
16544 switch (schemeField.id) {
16545 case 0:
16546 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
16547 {
16548 org.apache.thrift.protocol.TList _list144 = iprot.readListBegin();
16549 struct.success = new ArrayList<TResult>(_list144.size);
16550 for (int _i145 = 0; _i145 < _list144.size; ++_i145)
16551 {
16552 TResult _elem146;
16553 _elem146 = new TResult();
16554 _elem146.read(iprot);
16555 struct.success.add(_elem146);
16556 }
16557 iprot.readListEnd();
16558 }
16559 struct.setSuccessIsSet(true);
16560 } else {
16561 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16562 }
16563 break;
16564 case 1:
16565 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
16566 struct.io = new TIOError();
16567 struct.io.read(iprot);
16568 struct.setIoIsSet(true);
16569 } else {
16570 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16571 }
16572 break;
16573 default:
16574 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
16575 }
16576 iprot.readFieldEnd();
16577 }
16578 iprot.readStructEnd();
16579
16580
16581 struct.validate();
16582 }
16583
16584 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerResults_result struct) throws org.apache.thrift.TException {
16585 struct.validate();
16586
16587 oprot.writeStructBegin(STRUCT_DESC);
16588 if (struct.success != null) {
16589 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
16590 {
16591 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
16592 for (TResult _iter147 : struct.success)
16593 {
16594 _iter147.write(oprot);
16595 }
16596 oprot.writeListEnd();
16597 }
16598 oprot.writeFieldEnd();
16599 }
16600 if (struct.io != null) {
16601 oprot.writeFieldBegin(IO_FIELD_DESC);
16602 struct.io.write(oprot);
16603 oprot.writeFieldEnd();
16604 }
16605 oprot.writeFieldStop();
16606 oprot.writeStructEnd();
16607 }
16608
16609 }
16610
16611 private static class getScannerResults_resultTupleSchemeFactory implements SchemeFactory {
16612 public getScannerResults_resultTupleScheme getScheme() {
16613 return new getScannerResults_resultTupleScheme();
16614 }
16615 }
16616
16617 private static class getScannerResults_resultTupleScheme extends TupleScheme<getScannerResults_result> {
16618
16619 @Override
16620 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerResults_result struct) throws org.apache.thrift.TException {
16621 TTupleProtocol oprot = (TTupleProtocol) prot;
16622 BitSet optionals = new BitSet();
16623 if (struct.isSetSuccess()) {
16624 optionals.set(0);
16625 }
16626 if (struct.isSetIo()) {
16627 optionals.set(1);
16628 }
16629 oprot.writeBitSet(optionals, 2);
16630 if (struct.isSetSuccess()) {
16631 {
16632 oprot.writeI32(struct.success.size());
16633 for (TResult _iter148 : struct.success)
16634 {
16635 _iter148.write(oprot);
16636 }
16637 }
16638 }
16639 if (struct.isSetIo()) {
16640 struct.io.write(oprot);
16641 }
16642 }
16643
16644 @Override
16645 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerResults_result struct) throws org.apache.thrift.TException {
16646 TTupleProtocol iprot = (TTupleProtocol) prot;
16647 BitSet incoming = iprot.readBitSet(2);
16648 if (incoming.get(0)) {
16649 {
16650 org.apache.thrift.protocol.TList _list149 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
16651 struct.success = new ArrayList<TResult>(_list149.size);
16652 for (int _i150 = 0; _i150 < _list149.size; ++_i150)
16653 {
16654 TResult _elem151;
16655 _elem151 = new TResult();
16656 _elem151.read(iprot);
16657 struct.success.add(_elem151);
16658 }
16659 }
16660 struct.setSuccessIsSet(true);
16661 }
16662 if (incoming.get(1)) {
16663 struct.io = new TIOError();
16664 struct.io.read(iprot);
16665 struct.setIoIsSet(true);
16666 }
16667 }
16668 }
16669
16670 }
16671
16672 }