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
195 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
196
197
198
199
200
201
202
203
204 public void mutateRow(ByteBuffer table, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException;
205
206 }
207
208 public interface AsyncIface {
209
210 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.exists_call> resultHandler) throws org.apache.thrift.TException;
211
212 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.get_call> resultHandler) throws org.apache.thrift.TException;
213
214 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getMultiple_call> resultHandler) throws org.apache.thrift.TException;
215
216 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.put_call> resultHandler) throws org.apache.thrift.TException;
217
218 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;
219
220 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.putMultiple_call> resultHandler) throws org.apache.thrift.TException;
221
222 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteSingle_call> resultHandler) throws org.apache.thrift.TException;
223
224 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteMultiple_call> resultHandler) throws org.apache.thrift.TException;
225
226 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;
227
228 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.increment_call> resultHandler) throws org.apache.thrift.TException;
229
230 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.openScanner_call> resultHandler) throws org.apache.thrift.TException;
231
232 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getScannerRows_call> resultHandler) throws org.apache.thrift.TException;
233
234 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeScanner_call> resultHandler) throws org.apache.thrift.TException;
235
236 public void mutateRow(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.mutateRow_call> resultHandler) throws org.apache.thrift.TException;
237
238 }
239
240 public static class Client extends org.apache.thrift.TServiceClient implements Iface {
241 public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
242 public Factory() {}
243 public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
244 return new Client(prot);
245 }
246 public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
247 return new Client(iprot, oprot);
248 }
249 }
250
251 public Client(org.apache.thrift.protocol.TProtocol prot)
252 {
253 super(prot, prot);
254 }
255
256 public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
257 super(iprot, oprot);
258 }
259
260 public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
261 {
262 send_exists(table, get);
263 return recv_exists();
264 }
265
266 public void send_exists(ByteBuffer table, TGet get) throws org.apache.thrift.TException
267 {
268 exists_args args = new exists_args();
269 args.setTable(table);
270 args.setGet(get);
271 sendBase("exists", args);
272 }
273
274 public boolean recv_exists() throws TIOError, org.apache.thrift.TException
275 {
276 exists_result result = new exists_result();
277 receiveBase(result, "exists");
278 if (result.isSetSuccess()) {
279 return result.success;
280 }
281 if (result.io != null) {
282 throw result.io;
283 }
284 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "exists failed: unknown result");
285 }
286
287 public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
288 {
289 send_get(table, get);
290 return recv_get();
291 }
292
293 public void send_get(ByteBuffer table, TGet get) throws org.apache.thrift.TException
294 {
295 get_args args = new get_args();
296 args.setTable(table);
297 args.setGet(get);
298 sendBase("get", args);
299 }
300
301 public TResult recv_get() throws TIOError, org.apache.thrift.TException
302 {
303 get_result result = new get_result();
304 receiveBase(result, "get");
305 if (result.isSetSuccess()) {
306 return result.success;
307 }
308 if (result.io != null) {
309 throw result.io;
310 }
311 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get failed: unknown result");
312 }
313
314 public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException
315 {
316 send_getMultiple(table, gets);
317 return recv_getMultiple();
318 }
319
320 public void send_getMultiple(ByteBuffer table, List<TGet> gets) throws org.apache.thrift.TException
321 {
322 getMultiple_args args = new getMultiple_args();
323 args.setTable(table);
324 args.setGets(gets);
325 sendBase("getMultiple", args);
326 }
327
328 public List<TResult> recv_getMultiple() throws TIOError, org.apache.thrift.TException
329 {
330 getMultiple_result result = new getMultiple_result();
331 receiveBase(result, "getMultiple");
332 if (result.isSetSuccess()) {
333 return result.success;
334 }
335 if (result.io != null) {
336 throw result.io;
337 }
338 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getMultiple failed: unknown result");
339 }
340
341 public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException
342 {
343 send_put(table, put);
344 recv_put();
345 }
346
347 public void send_put(ByteBuffer table, TPut put) throws org.apache.thrift.TException
348 {
349 put_args args = new put_args();
350 args.setTable(table);
351 args.setPut(put);
352 sendBase("put", args);
353 }
354
355 public void recv_put() throws TIOError, org.apache.thrift.TException
356 {
357 put_result result = new put_result();
358 receiveBase(result, "put");
359 if (result.io != null) {
360 throw result.io;
361 }
362 return;
363 }
364
365 public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException
366 {
367 send_checkAndPut(table, row, family, qualifier, value, put);
368 return recv_checkAndPut();
369 }
370
371 public void send_checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws org.apache.thrift.TException
372 {
373 checkAndPut_args args = new checkAndPut_args();
374 args.setTable(table);
375 args.setRow(row);
376 args.setFamily(family);
377 args.setQualifier(qualifier);
378 args.setValue(value);
379 args.setPut(put);
380 sendBase("checkAndPut", args);
381 }
382
383 public boolean recv_checkAndPut() throws TIOError, org.apache.thrift.TException
384 {
385 checkAndPut_result result = new checkAndPut_result();
386 receiveBase(result, "checkAndPut");
387 if (result.isSetSuccess()) {
388 return result.success;
389 }
390 if (result.io != null) {
391 throw result.io;
392 }
393 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndPut failed: unknown result");
394 }
395
396 public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException
397 {
398 send_putMultiple(table, puts);
399 recv_putMultiple();
400 }
401
402 public void send_putMultiple(ByteBuffer table, List<TPut> puts) throws org.apache.thrift.TException
403 {
404 putMultiple_args args = new putMultiple_args();
405 args.setTable(table);
406 args.setPuts(puts);
407 sendBase("putMultiple", args);
408 }
409
410 public void recv_putMultiple() throws TIOError, org.apache.thrift.TException
411 {
412 putMultiple_result result = new putMultiple_result();
413 receiveBase(result, "putMultiple");
414 if (result.io != null) {
415 throw result.io;
416 }
417 return;
418 }
419
420 public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
421 {
422 send_deleteSingle(table, deleteSingle);
423 recv_deleteSingle();
424 }
425
426 public void send_deleteSingle(ByteBuffer table, TDelete deleteSingle) throws org.apache.thrift.TException
427 {
428 deleteSingle_args args = new deleteSingle_args();
429 args.setTable(table);
430 args.setDeleteSingle(deleteSingle);
431 sendBase("deleteSingle", args);
432 }
433
434 public void recv_deleteSingle() throws TIOError, org.apache.thrift.TException
435 {
436 deleteSingle_result result = new deleteSingle_result();
437 receiveBase(result, "deleteSingle");
438 if (result.io != null) {
439 throw result.io;
440 }
441 return;
442 }
443
444 public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException
445 {
446 send_deleteMultiple(table, deletes);
447 return recv_deleteMultiple();
448 }
449
450 public void send_deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws org.apache.thrift.TException
451 {
452 deleteMultiple_args args = new deleteMultiple_args();
453 args.setTable(table);
454 args.setDeletes(deletes);
455 sendBase("deleteMultiple", args);
456 }
457
458 public List<TDelete> recv_deleteMultiple() throws TIOError, org.apache.thrift.TException
459 {
460 deleteMultiple_result result = new deleteMultiple_result();
461 receiveBase(result, "deleteMultiple");
462 if (result.isSetSuccess()) {
463 return result.success;
464 }
465 if (result.io != null) {
466 throw result.io;
467 }
468 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "deleteMultiple failed: unknown result");
469 }
470
471 public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
472 {
473 send_checkAndDelete(table, row, family, qualifier, value, deleteSingle);
474 return recv_checkAndDelete();
475 }
476
477 public void send_checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws org.apache.thrift.TException
478 {
479 checkAndDelete_args args = new checkAndDelete_args();
480 args.setTable(table);
481 args.setRow(row);
482 args.setFamily(family);
483 args.setQualifier(qualifier);
484 args.setValue(value);
485 args.setDeleteSingle(deleteSingle);
486 sendBase("checkAndDelete", args);
487 }
488
489 public boolean recv_checkAndDelete() throws TIOError, org.apache.thrift.TException
490 {
491 checkAndDelete_result result = new checkAndDelete_result();
492 receiveBase(result, "checkAndDelete");
493 if (result.isSetSuccess()) {
494 return result.success;
495 }
496 if (result.io != null) {
497 throw result.io;
498 }
499 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndDelete failed: unknown result");
500 }
501
502 public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException
503 {
504 send_increment(table, increment);
505 return recv_increment();
506 }
507
508 public void send_increment(ByteBuffer table, TIncrement increment) throws org.apache.thrift.TException
509 {
510 increment_args args = new increment_args();
511 args.setTable(table);
512 args.setIncrement(increment);
513 sendBase("increment", args);
514 }
515
516 public TResult recv_increment() throws TIOError, org.apache.thrift.TException
517 {
518 increment_result result = new increment_result();
519 receiveBase(result, "increment");
520 if (result.isSetSuccess()) {
521 return result.success;
522 }
523 if (result.io != null) {
524 throw result.io;
525 }
526 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "increment failed: unknown result");
527 }
528
529 public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException
530 {
531 send_openScanner(table, scan);
532 return recv_openScanner();
533 }
534
535 public void send_openScanner(ByteBuffer table, TScan scan) throws org.apache.thrift.TException
536 {
537 openScanner_args args = new openScanner_args();
538 args.setTable(table);
539 args.setScan(scan);
540 sendBase("openScanner", args);
541 }
542
543 public int recv_openScanner() throws TIOError, org.apache.thrift.TException
544 {
545 openScanner_result result = new openScanner_result();
546 receiveBase(result, "openScanner");
547 if (result.isSetSuccess()) {
548 return result.success;
549 }
550 if (result.io != null) {
551 throw result.io;
552 }
553 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "openScanner failed: unknown result");
554 }
555
556 public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException
557 {
558 send_getScannerRows(scannerId, numRows);
559 return recv_getScannerRows();
560 }
561
562 public void send_getScannerRows(int scannerId, int numRows) throws org.apache.thrift.TException
563 {
564 getScannerRows_args args = new getScannerRows_args();
565 args.setScannerId(scannerId);
566 args.setNumRows(numRows);
567 sendBase("getScannerRows", args);
568 }
569
570 public List<TResult> recv_getScannerRows() throws TIOError, TIllegalArgument, org.apache.thrift.TException
571 {
572 getScannerRows_result result = new getScannerRows_result();
573 receiveBase(result, "getScannerRows");
574 if (result.isSetSuccess()) {
575 return result.success;
576 }
577 if (result.io != null) {
578 throw result.io;
579 }
580 if (result.ia != null) {
581 throw result.ia;
582 }
583 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerRows failed: unknown result");
584 }
585
586 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException
587 {
588 send_closeScanner(scannerId);
589 recv_closeScanner();
590 }
591
592 public void send_closeScanner(int scannerId) throws org.apache.thrift.TException
593 {
594 closeScanner_args args = new closeScanner_args();
595 args.setScannerId(scannerId);
596 sendBase("closeScanner", args);
597 }
598
599 public void recv_closeScanner() throws TIOError, TIllegalArgument, org.apache.thrift.TException
600 {
601 closeScanner_result result = new closeScanner_result();
602 receiveBase(result, "closeScanner");
603 if (result.io != null) {
604 throw result.io;
605 }
606 if (result.ia != null) {
607 throw result.ia;
608 }
609 return;
610 }
611
612 public void mutateRow(ByteBuffer table, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException
613 {
614 send_mutateRow(table, rowMutations);
615 recv_mutateRow();
616 }
617
618 public void send_mutateRow(ByteBuffer table, TRowMutations rowMutations) throws org.apache.thrift.TException
619 {
620 mutateRow_args args = new mutateRow_args();
621 args.setTable(table);
622 args.setRowMutations(rowMutations);
623 sendBase("mutateRow", args);
624 }
625
626 public void recv_mutateRow() throws TIOError, org.apache.thrift.TException
627 {
628 mutateRow_result result = new mutateRow_result();
629 receiveBase(result, "mutateRow");
630 if (result.io != null) {
631 throw result.io;
632 }
633 return;
634 }
635
636 }
637 public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
638 public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
639 private org.apache.thrift.async.TAsyncClientManager clientManager;
640 private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
641 public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) {
642 this.clientManager = clientManager;
643 this.protocolFactory = protocolFactory;
644 }
645 public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) {
646 return new AsyncClient(protocolFactory, clientManager, transport);
647 }
648 }
649
650 public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) {
651 super(protocolFactory, clientManager, transport);
652 }
653
654 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<exists_call> resultHandler) throws org.apache.thrift.TException {
655 checkReady();
656 exists_call method_call = new exists_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
657 this.___currentMethod = method_call;
658 ___manager.call(method_call);
659 }
660
661 public static class exists_call extends org.apache.thrift.async.TAsyncMethodCall {
662 private ByteBuffer table;
663 private TGet get;
664 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 {
665 super(client, protocolFactory, transport, resultHandler, false);
666 this.table = table;
667 this.get = get;
668 }
669
670 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
671 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("exists", org.apache.thrift.protocol.TMessageType.CALL, 0));
672 exists_args args = new exists_args();
673 args.setTable(table);
674 args.setGet(get);
675 args.write(prot);
676 prot.writeMessageEnd();
677 }
678
679 public boolean getResult() throws TIOError, org.apache.thrift.TException {
680 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
681 throw new IllegalStateException("Method call not finished!");
682 }
683 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
684 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
685 return (new Client(prot)).recv_exists();
686 }
687 }
688
689 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<get_call> resultHandler) throws org.apache.thrift.TException {
690 checkReady();
691 get_call method_call = new get_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
692 this.___currentMethod = method_call;
693 ___manager.call(method_call);
694 }
695
696 public static class get_call extends org.apache.thrift.async.TAsyncMethodCall {
697 private ByteBuffer table;
698 private TGet get;
699 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 {
700 super(client, protocolFactory, transport, resultHandler, false);
701 this.table = table;
702 this.get = get;
703 }
704
705 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
706 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.CALL, 0));
707 get_args args = new get_args();
708 args.setTable(table);
709 args.setGet(get);
710 args.write(prot);
711 prot.writeMessageEnd();
712 }
713
714 public TResult getResult() throws TIOError, org.apache.thrift.TException {
715 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
716 throw new IllegalStateException("Method call not finished!");
717 }
718 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
719 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
720 return (new Client(prot)).recv_get();
721 }
722 }
723
724 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<getMultiple_call> resultHandler) throws org.apache.thrift.TException {
725 checkReady();
726 getMultiple_call method_call = new getMultiple_call(table, gets, resultHandler, this, ___protocolFactory, ___transport);
727 this.___currentMethod = method_call;
728 ___manager.call(method_call);
729 }
730
731 public static class getMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
732 private ByteBuffer table;
733 private List<TGet> gets;
734 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 {
735 super(client, protocolFactory, transport, resultHandler, false);
736 this.table = table;
737 this.gets = gets;
738 }
739
740 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
741 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
742 getMultiple_args args = new getMultiple_args();
743 args.setTable(table);
744 args.setGets(gets);
745 args.write(prot);
746 prot.writeMessageEnd();
747 }
748
749 public List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
750 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
751 throw new IllegalStateException("Method call not finished!");
752 }
753 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
754 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
755 return (new Client(prot)).recv_getMultiple();
756 }
757 }
758
759 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<put_call> resultHandler) throws org.apache.thrift.TException {
760 checkReady();
761 put_call method_call = new put_call(table, put, resultHandler, this, ___protocolFactory, ___transport);
762 this.___currentMethod = method_call;
763 ___manager.call(method_call);
764 }
765
766 public static class put_call extends org.apache.thrift.async.TAsyncMethodCall {
767 private ByteBuffer table;
768 private TPut put;
769 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 {
770 super(client, protocolFactory, transport, resultHandler, false);
771 this.table = table;
772 this.put = put;
773 }
774
775 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
776 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("put", org.apache.thrift.protocol.TMessageType.CALL, 0));
777 put_args args = new put_args();
778 args.setTable(table);
779 args.setPut(put);
780 args.write(prot);
781 prot.writeMessageEnd();
782 }
783
784 public void getResult() throws TIOError, org.apache.thrift.TException {
785 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
786 throw new IllegalStateException("Method call not finished!");
787 }
788 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
789 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
790 (new Client(prot)).recv_put();
791 }
792 }
793
794 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 {
795 checkReady();
796 checkAndPut_call method_call = new checkAndPut_call(table, row, family, qualifier, value, put, resultHandler, this, ___protocolFactory, ___transport);
797 this.___currentMethod = method_call;
798 ___manager.call(method_call);
799 }
800
801 public static class checkAndPut_call extends org.apache.thrift.async.TAsyncMethodCall {
802 private ByteBuffer table;
803 private ByteBuffer row;
804 private ByteBuffer family;
805 private ByteBuffer qualifier;
806 private ByteBuffer value;
807 private TPut put;
808 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 {
809 super(client, protocolFactory, transport, resultHandler, false);
810 this.table = table;
811 this.row = row;
812 this.family = family;
813 this.qualifier = qualifier;
814 this.value = value;
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("checkAndPut", org.apache.thrift.protocol.TMessageType.CALL, 0));
820 checkAndPut_args args = new checkAndPut_args();
821 args.setTable(table);
822 args.setRow(row);
823 args.setFamily(family);
824 args.setQualifier(qualifier);
825 args.setValue(value);
826 args.setPut(put);
827 args.write(prot);
828 prot.writeMessageEnd();
829 }
830
831 public boolean getResult() throws TIOError, org.apache.thrift.TException {
832 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
833 throw new IllegalStateException("Method call not finished!");
834 }
835 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
836 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
837 return (new Client(prot)).recv_checkAndPut();
838 }
839 }
840
841 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<putMultiple_call> resultHandler) throws org.apache.thrift.TException {
842 checkReady();
843 putMultiple_call method_call = new putMultiple_call(table, puts, resultHandler, this, ___protocolFactory, ___transport);
844 this.___currentMethod = method_call;
845 ___manager.call(method_call);
846 }
847
848 public static class putMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
849 private ByteBuffer table;
850 private List<TPut> puts;
851 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 {
852 super(client, protocolFactory, transport, resultHandler, false);
853 this.table = table;
854 this.puts = puts;
855 }
856
857 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
858 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("putMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
859 putMultiple_args args = new putMultiple_args();
860 args.setTable(table);
861 args.setPuts(puts);
862 args.write(prot);
863 prot.writeMessageEnd();
864 }
865
866 public void getResult() throws TIOError, org.apache.thrift.TException {
867 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
868 throw new IllegalStateException("Method call not finished!");
869 }
870 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
871 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
872 (new Client(prot)).recv_putMultiple();
873 }
874 }
875
876 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<deleteSingle_call> resultHandler) throws org.apache.thrift.TException {
877 checkReady();
878 deleteSingle_call method_call = new deleteSingle_call(table, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
879 this.___currentMethod = method_call;
880 ___manager.call(method_call);
881 }
882
883 public static class deleteSingle_call extends org.apache.thrift.async.TAsyncMethodCall {
884 private ByteBuffer table;
885 private TDelete deleteSingle;
886 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 {
887 super(client, protocolFactory, transport, resultHandler, false);
888 this.table = table;
889 this.deleteSingle = deleteSingle;
890 }
891
892 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
893 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteSingle", org.apache.thrift.protocol.TMessageType.CALL, 0));
894 deleteSingle_args args = new deleteSingle_args();
895 args.setTable(table);
896 args.setDeleteSingle(deleteSingle);
897 args.write(prot);
898 prot.writeMessageEnd();
899 }
900
901 public void getResult() throws TIOError, org.apache.thrift.TException {
902 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
903 throw new IllegalStateException("Method call not finished!");
904 }
905 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
906 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
907 (new Client(prot)).recv_deleteSingle();
908 }
909 }
910
911 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<deleteMultiple_call> resultHandler) throws org.apache.thrift.TException {
912 checkReady();
913 deleteMultiple_call method_call = new deleteMultiple_call(table, deletes, resultHandler, this, ___protocolFactory, ___transport);
914 this.___currentMethod = method_call;
915 ___manager.call(method_call);
916 }
917
918 public static class deleteMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
919 private ByteBuffer table;
920 private List<TDelete> deletes;
921 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 {
922 super(client, protocolFactory, transport, resultHandler, false);
923 this.table = table;
924 this.deletes = deletes;
925 }
926
927 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
928 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
929 deleteMultiple_args args = new deleteMultiple_args();
930 args.setTable(table);
931 args.setDeletes(deletes);
932 args.write(prot);
933 prot.writeMessageEnd();
934 }
935
936 public List<TDelete> getResult() throws TIOError, org.apache.thrift.TException {
937 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
938 throw new IllegalStateException("Method call not finished!");
939 }
940 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
941 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
942 return (new Client(prot)).recv_deleteMultiple();
943 }
944 }
945
946 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 {
947 checkReady();
948 checkAndDelete_call method_call = new checkAndDelete_call(table, row, family, qualifier, value, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
949 this.___currentMethod = method_call;
950 ___manager.call(method_call);
951 }
952
953 public static class checkAndDelete_call extends org.apache.thrift.async.TAsyncMethodCall {
954 private ByteBuffer table;
955 private ByteBuffer row;
956 private ByteBuffer family;
957 private ByteBuffer qualifier;
958 private ByteBuffer value;
959 private TDelete deleteSingle;
960 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 {
961 super(client, protocolFactory, transport, resultHandler, false);
962 this.table = table;
963 this.row = row;
964 this.family = family;
965 this.qualifier = qualifier;
966 this.value = value;
967 this.deleteSingle = deleteSingle;
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("checkAndDelete", org.apache.thrift.protocol.TMessageType.CALL, 0));
972 checkAndDelete_args args = new checkAndDelete_args();
973 args.setTable(table);
974 args.setRow(row);
975 args.setFamily(family);
976 args.setQualifier(qualifier);
977 args.setValue(value);
978 args.setDeleteSingle(deleteSingle);
979 args.write(prot);
980 prot.writeMessageEnd();
981 }
982
983 public boolean getResult() throws TIOError, org.apache.thrift.TException {
984 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
985 throw new IllegalStateException("Method call not finished!");
986 }
987 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
988 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
989 return (new Client(prot)).recv_checkAndDelete();
990 }
991 }
992
993 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<increment_call> resultHandler) throws org.apache.thrift.TException {
994 checkReady();
995 increment_call method_call = new increment_call(table, increment, resultHandler, this, ___protocolFactory, ___transport);
996 this.___currentMethod = method_call;
997 ___manager.call(method_call);
998 }
999
1000 public static class increment_call extends org.apache.thrift.async.TAsyncMethodCall {
1001 private ByteBuffer table;
1002 private TIncrement increment;
1003 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 {
1004 super(client, protocolFactory, transport, resultHandler, false);
1005 this.table = table;
1006 this.increment = increment;
1007 }
1008
1009 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1010 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("increment", org.apache.thrift.protocol.TMessageType.CALL, 0));
1011 increment_args args = new increment_args();
1012 args.setTable(table);
1013 args.setIncrement(increment);
1014 args.write(prot);
1015 prot.writeMessageEnd();
1016 }
1017
1018 public TResult getResult() throws TIOError, org.apache.thrift.TException {
1019 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1020 throw new IllegalStateException("Method call not finished!");
1021 }
1022 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1023 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1024 return (new Client(prot)).recv_increment();
1025 }
1026 }
1027
1028 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<openScanner_call> resultHandler) throws org.apache.thrift.TException {
1029 checkReady();
1030 openScanner_call method_call = new openScanner_call(table, scan, resultHandler, this, ___protocolFactory, ___transport);
1031 this.___currentMethod = method_call;
1032 ___manager.call(method_call);
1033 }
1034
1035 public static class openScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1036 private ByteBuffer table;
1037 private TScan scan;
1038 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 {
1039 super(client, protocolFactory, transport, resultHandler, false);
1040 this.table = table;
1041 this.scan = scan;
1042 }
1043
1044 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1045 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("openScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1046 openScanner_args args = new openScanner_args();
1047 args.setTable(table);
1048 args.setScan(scan);
1049 args.write(prot);
1050 prot.writeMessageEnd();
1051 }
1052
1053 public int getResult() throws TIOError, org.apache.thrift.TException {
1054 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1055 throw new IllegalStateException("Method call not finished!");
1056 }
1057 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1058 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1059 return (new Client(prot)).recv_openScanner();
1060 }
1061 }
1062
1063 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerRows_call> resultHandler) throws org.apache.thrift.TException {
1064 checkReady();
1065 getScannerRows_call method_call = new getScannerRows_call(scannerId, numRows, resultHandler, this, ___protocolFactory, ___transport);
1066 this.___currentMethod = method_call;
1067 ___manager.call(method_call);
1068 }
1069
1070 public static class getScannerRows_call extends org.apache.thrift.async.TAsyncMethodCall {
1071 private int scannerId;
1072 private int numRows;
1073 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 {
1074 super(client, protocolFactory, transport, resultHandler, false);
1075 this.scannerId = scannerId;
1076 this.numRows = numRows;
1077 }
1078
1079 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1080 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerRows", org.apache.thrift.protocol.TMessageType.CALL, 0));
1081 getScannerRows_args args = new getScannerRows_args();
1082 args.setScannerId(scannerId);
1083 args.setNumRows(numRows);
1084 args.write(prot);
1085 prot.writeMessageEnd();
1086 }
1087
1088 public List<TResult> getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1089 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1090 throw new IllegalStateException("Method call not finished!");
1091 }
1092 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1093 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1094 return (new Client(prot)).recv_getScannerRows();
1095 }
1096 }
1097
1098 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<closeScanner_call> resultHandler) throws org.apache.thrift.TException {
1099 checkReady();
1100 closeScanner_call method_call = new closeScanner_call(scannerId, resultHandler, this, ___protocolFactory, ___transport);
1101 this.___currentMethod = method_call;
1102 ___manager.call(method_call);
1103 }
1104
1105 public static class closeScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1106 private int scannerId;
1107 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 {
1108 super(client, protocolFactory, transport, resultHandler, false);
1109 this.scannerId = scannerId;
1110 }
1111
1112 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1113 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1114 closeScanner_args args = new closeScanner_args();
1115 args.setScannerId(scannerId);
1116 args.write(prot);
1117 prot.writeMessageEnd();
1118 }
1119
1120 public void getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1121 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1122 throw new IllegalStateException("Method call not finished!");
1123 }
1124 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1125 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1126 (new Client(prot)).recv_closeScanner();
1127 }
1128 }
1129
1130 public void mutateRow(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<mutateRow_call> resultHandler) throws org.apache.thrift.TException {
1131 checkReady();
1132 mutateRow_call method_call = new mutateRow_call(table, rowMutations, resultHandler, this, ___protocolFactory, ___transport);
1133 this.___currentMethod = method_call;
1134 ___manager.call(method_call);
1135 }
1136
1137 public static class mutateRow_call extends org.apache.thrift.async.TAsyncMethodCall {
1138 private ByteBuffer table;
1139 private TRowMutations rowMutations;
1140 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 {
1141 super(client, protocolFactory, transport, resultHandler, false);
1142 this.table = table;
1143 this.rowMutations = rowMutations;
1144 }
1145
1146 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1147 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRow", org.apache.thrift.protocol.TMessageType.CALL, 0));
1148 mutateRow_args args = new mutateRow_args();
1149 args.setTable(table);
1150 args.setRowMutations(rowMutations);
1151 args.write(prot);
1152 prot.writeMessageEnd();
1153 }
1154
1155 public void getResult() throws TIOError, org.apache.thrift.TException {
1156 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1157 throw new IllegalStateException("Method call not finished!");
1158 }
1159 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1160 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1161 (new Client(prot)).recv_mutateRow();
1162 }
1163 }
1164
1165 }
1166
1167 public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
1168 private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1169 public Processor(I iface) {
1170 super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
1171 }
1172
1173 protected Processor(I iface, Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
1174 super(iface, getProcessMap(processMap));
1175 }
1176
1177 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) {
1178 processMap.put("exists", new exists());
1179 processMap.put("get", new get());
1180 processMap.put("getMultiple", new getMultiple());
1181 processMap.put("put", new put());
1182 processMap.put("checkAndPut", new checkAndPut());
1183 processMap.put("putMultiple", new putMultiple());
1184 processMap.put("deleteSingle", new deleteSingle());
1185 processMap.put("deleteMultiple", new deleteMultiple());
1186 processMap.put("checkAndDelete", new checkAndDelete());
1187 processMap.put("increment", new increment());
1188 processMap.put("openScanner", new openScanner());
1189 processMap.put("getScannerRows", new getScannerRows());
1190 processMap.put("closeScanner", new closeScanner());
1191 processMap.put("mutateRow", new mutateRow());
1192 return processMap;
1193 }
1194
1195 private static class exists<I extends Iface> extends org.apache.thrift.ProcessFunction<I, exists_args> {
1196 public exists() {
1197 super("exists");
1198 }
1199
1200 protected exists_args getEmptyArgsInstance() {
1201 return new exists_args();
1202 }
1203
1204 protected exists_result getResult(I iface, exists_args args) throws org.apache.thrift.TException {
1205 exists_result result = new exists_result();
1206 try {
1207 result.success = iface.exists(args.table, args.get);
1208 result.setSuccessIsSet(true);
1209 } catch (TIOError io) {
1210 result.io = io;
1211 }
1212 return result;
1213 }
1214 }
1215
1216 private static class get<I extends Iface> extends org.apache.thrift.ProcessFunction<I, get_args> {
1217 public get() {
1218 super("get");
1219 }
1220
1221 protected get_args getEmptyArgsInstance() {
1222 return new get_args();
1223 }
1224
1225 protected get_result getResult(I iface, get_args args) throws org.apache.thrift.TException {
1226 get_result result = new get_result();
1227 try {
1228 result.success = iface.get(args.table, args.get);
1229 } catch (TIOError io) {
1230 result.io = io;
1231 }
1232 return result;
1233 }
1234 }
1235
1236 private static class getMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getMultiple_args> {
1237 public getMultiple() {
1238 super("getMultiple");
1239 }
1240
1241 protected getMultiple_args getEmptyArgsInstance() {
1242 return new getMultiple_args();
1243 }
1244
1245 protected getMultiple_result getResult(I iface, getMultiple_args args) throws org.apache.thrift.TException {
1246 getMultiple_result result = new getMultiple_result();
1247 try {
1248 result.success = iface.getMultiple(args.table, args.gets);
1249 } catch (TIOError io) {
1250 result.io = io;
1251 }
1252 return result;
1253 }
1254 }
1255
1256 private static class put<I extends Iface> extends org.apache.thrift.ProcessFunction<I, put_args> {
1257 public put() {
1258 super("put");
1259 }
1260
1261 protected put_args getEmptyArgsInstance() {
1262 return new put_args();
1263 }
1264
1265 protected put_result getResult(I iface, put_args args) throws org.apache.thrift.TException {
1266 put_result result = new put_result();
1267 try {
1268 iface.put(args.table, args.put);
1269 } catch (TIOError io) {
1270 result.io = io;
1271 }
1272 return result;
1273 }
1274 }
1275
1276 private static class checkAndPut<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndPut_args> {
1277 public checkAndPut() {
1278 super("checkAndPut");
1279 }
1280
1281 protected checkAndPut_args getEmptyArgsInstance() {
1282 return new checkAndPut_args();
1283 }
1284
1285 protected checkAndPut_result getResult(I iface, checkAndPut_args args) throws org.apache.thrift.TException {
1286 checkAndPut_result result = new checkAndPut_result();
1287 try {
1288 result.success = iface.checkAndPut(args.table, args.row, args.family, args.qualifier, args.value, args.put);
1289 result.setSuccessIsSet(true);
1290 } catch (TIOError io) {
1291 result.io = io;
1292 }
1293 return result;
1294 }
1295 }
1296
1297 private static class putMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, putMultiple_args> {
1298 public putMultiple() {
1299 super("putMultiple");
1300 }
1301
1302 protected putMultiple_args getEmptyArgsInstance() {
1303 return new putMultiple_args();
1304 }
1305
1306 protected putMultiple_result getResult(I iface, putMultiple_args args) throws org.apache.thrift.TException {
1307 putMultiple_result result = new putMultiple_result();
1308 try {
1309 iface.putMultiple(args.table, args.puts);
1310 } catch (TIOError io) {
1311 result.io = io;
1312 }
1313 return result;
1314 }
1315 }
1316
1317 private static class deleteSingle<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteSingle_args> {
1318 public deleteSingle() {
1319 super("deleteSingle");
1320 }
1321
1322 protected deleteSingle_args getEmptyArgsInstance() {
1323 return new deleteSingle_args();
1324 }
1325
1326 protected deleteSingle_result getResult(I iface, deleteSingle_args args) throws org.apache.thrift.TException {
1327 deleteSingle_result result = new deleteSingle_result();
1328 try {
1329 iface.deleteSingle(args.table, args.deleteSingle);
1330 } catch (TIOError io) {
1331 result.io = io;
1332 }
1333 return result;
1334 }
1335 }
1336
1337 private static class deleteMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteMultiple_args> {
1338 public deleteMultiple() {
1339 super("deleteMultiple");
1340 }
1341
1342 protected deleteMultiple_args getEmptyArgsInstance() {
1343 return new deleteMultiple_args();
1344 }
1345
1346 protected deleteMultiple_result getResult(I iface, deleteMultiple_args args) throws org.apache.thrift.TException {
1347 deleteMultiple_result result = new deleteMultiple_result();
1348 try {
1349 result.success = iface.deleteMultiple(args.table, args.deletes);
1350 } catch (TIOError io) {
1351 result.io = io;
1352 }
1353 return result;
1354 }
1355 }
1356
1357 private static class checkAndDelete<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndDelete_args> {
1358 public checkAndDelete() {
1359 super("checkAndDelete");
1360 }
1361
1362 protected checkAndDelete_args getEmptyArgsInstance() {
1363 return new checkAndDelete_args();
1364 }
1365
1366 protected checkAndDelete_result getResult(I iface, checkAndDelete_args args) throws org.apache.thrift.TException {
1367 checkAndDelete_result result = new checkAndDelete_result();
1368 try {
1369 result.success = iface.checkAndDelete(args.table, args.row, args.family, args.qualifier, args.value, args.deleteSingle);
1370 result.setSuccessIsSet(true);
1371 } catch (TIOError io) {
1372 result.io = io;
1373 }
1374 return result;
1375 }
1376 }
1377
1378 private static class increment<I extends Iface> extends org.apache.thrift.ProcessFunction<I, increment_args> {
1379 public increment() {
1380 super("increment");
1381 }
1382
1383 protected increment_args getEmptyArgsInstance() {
1384 return new increment_args();
1385 }
1386
1387 protected increment_result getResult(I iface, increment_args args) throws org.apache.thrift.TException {
1388 increment_result result = new increment_result();
1389 try {
1390 result.success = iface.increment(args.table, args.increment);
1391 } catch (TIOError io) {
1392 result.io = io;
1393 }
1394 return result;
1395 }
1396 }
1397
1398 private static class openScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, openScanner_args> {
1399 public openScanner() {
1400 super("openScanner");
1401 }
1402
1403 protected openScanner_args getEmptyArgsInstance() {
1404 return new openScanner_args();
1405 }
1406
1407 protected openScanner_result getResult(I iface, openScanner_args args) throws org.apache.thrift.TException {
1408 openScanner_result result = new openScanner_result();
1409 try {
1410 result.success = iface.openScanner(args.table, args.scan);
1411 result.setSuccessIsSet(true);
1412 } catch (TIOError io) {
1413 result.io = io;
1414 }
1415 return result;
1416 }
1417 }
1418
1419 private static class getScannerRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerRows_args> {
1420 public getScannerRows() {
1421 super("getScannerRows");
1422 }
1423
1424 protected getScannerRows_args getEmptyArgsInstance() {
1425 return new getScannerRows_args();
1426 }
1427
1428 protected getScannerRows_result getResult(I iface, getScannerRows_args args) throws org.apache.thrift.TException {
1429 getScannerRows_result result = new getScannerRows_result();
1430 try {
1431 result.success = iface.getScannerRows(args.scannerId, args.numRows);
1432 } catch (TIOError io) {
1433 result.io = io;
1434 } catch (TIllegalArgument ia) {
1435 result.ia = ia;
1436 }
1437 return result;
1438 }
1439 }
1440
1441 private static class closeScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeScanner_args> {
1442 public closeScanner() {
1443 super("closeScanner");
1444 }
1445
1446 protected closeScanner_args getEmptyArgsInstance() {
1447 return new closeScanner_args();
1448 }
1449
1450 protected closeScanner_result getResult(I iface, closeScanner_args args) throws org.apache.thrift.TException {
1451 closeScanner_result result = new closeScanner_result();
1452 try {
1453 iface.closeScanner(args.scannerId);
1454 } catch (TIOError io) {
1455 result.io = io;
1456 } catch (TIllegalArgument ia) {
1457 result.ia = ia;
1458 }
1459 return result;
1460 }
1461 }
1462
1463 private static class mutateRow<I extends Iface> extends org.apache.thrift.ProcessFunction<I, mutateRow_args> {
1464 public mutateRow() {
1465 super("mutateRow");
1466 }
1467
1468 protected mutateRow_args getEmptyArgsInstance() {
1469 return new mutateRow_args();
1470 }
1471
1472 protected mutateRow_result getResult(I iface, mutateRow_args args) throws org.apache.thrift.TException {
1473 mutateRow_result result = new mutateRow_result();
1474 try {
1475 iface.mutateRow(args.table, args.rowMutations);
1476 } catch (TIOError io) {
1477 result.io = io;
1478 }
1479 return result;
1480 }
1481 }
1482
1483 }
1484
1485 public static class exists_args implements org.apache.thrift.TBase<exists_args, exists_args._Fields>, java.io.Serializable, Cloneable {
1486 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_args");
1487
1488 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);
1489 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);
1490
1491 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
1492 static {
1493 schemes.put(StandardScheme.class, new exists_argsStandardSchemeFactory());
1494 schemes.put(TupleScheme.class, new exists_argsTupleSchemeFactory());
1495 }
1496
1497
1498
1499
1500 public ByteBuffer table;
1501
1502
1503
1504 public TGet get;
1505
1506
1507 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
1508
1509
1510
1511 TABLE((short)1, "table"),
1512
1513
1514
1515 GET((short)2, "get");
1516
1517 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
1518
1519 static {
1520 for (_Fields field : EnumSet.allOf(_Fields.class)) {
1521 byName.put(field.getFieldName(), field);
1522 }
1523 }
1524
1525
1526
1527
1528 public static _Fields findByThriftId(int fieldId) {
1529 switch(fieldId) {
1530 case 1:
1531 return TABLE;
1532 case 2:
1533 return GET;
1534 default:
1535 return null;
1536 }
1537 }
1538
1539
1540
1541
1542
1543 public static _Fields findByThriftIdOrThrow(int fieldId) {
1544 _Fields fields = findByThriftId(fieldId);
1545 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
1546 return fields;
1547 }
1548
1549
1550
1551
1552 public static _Fields findByName(String name) {
1553 return byName.get(name);
1554 }
1555
1556 private final short _thriftId;
1557 private final String _fieldName;
1558
1559 _Fields(short thriftId, String fieldName) {
1560 _thriftId = thriftId;
1561 _fieldName = fieldName;
1562 }
1563
1564 public short getThriftFieldId() {
1565 return _thriftId;
1566 }
1567
1568 public String getFieldName() {
1569 return _fieldName;
1570 }
1571 }
1572
1573
1574 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
1575 static {
1576 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
1577 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
1578 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
1579 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
1580 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
1581 metaDataMap = Collections.unmodifiableMap(tmpMap);
1582 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_args.class, metaDataMap);
1583 }
1584
1585 public exists_args() {
1586 }
1587
1588 public exists_args(
1589 ByteBuffer table,
1590 TGet get)
1591 {
1592 this();
1593 this.table = table;
1594 this.get = get;
1595 }
1596
1597
1598
1599
1600 public exists_args(exists_args other) {
1601 if (other.isSetTable()) {
1602 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
1603 ;
1604 }
1605 if (other.isSetGet()) {
1606 this.get = new TGet(other.get);
1607 }
1608 }
1609
1610 public exists_args deepCopy() {
1611 return new exists_args(this);
1612 }
1613
1614 @Override
1615 public void clear() {
1616 this.table = null;
1617 this.get = null;
1618 }
1619
1620
1621
1622
1623 public byte[] getTable() {
1624 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
1625 return table == null ? null : table.array();
1626 }
1627
1628 public ByteBuffer bufferForTable() {
1629 return table;
1630 }
1631
1632
1633
1634
1635 public exists_args setTable(byte[] table) {
1636 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
1637 return this;
1638 }
1639
1640 public exists_args setTable(ByteBuffer table) {
1641 this.table = table;
1642 return this;
1643 }
1644
1645 public void unsetTable() {
1646 this.table = null;
1647 }
1648
1649
1650 public boolean isSetTable() {
1651 return this.table != null;
1652 }
1653
1654 public void setTableIsSet(boolean value) {
1655 if (!value) {
1656 this.table = null;
1657 }
1658 }
1659
1660
1661
1662
1663 public TGet getGet() {
1664 return this.get;
1665 }
1666
1667
1668
1669
1670 public exists_args setGet(TGet get) {
1671 this.get = get;
1672 return this;
1673 }
1674
1675 public void unsetGet() {
1676 this.get = null;
1677 }
1678
1679
1680 public boolean isSetGet() {
1681 return this.get != null;
1682 }
1683
1684 public void setGetIsSet(boolean value) {
1685 if (!value) {
1686 this.get = null;
1687 }
1688 }
1689
1690 public void setFieldValue(_Fields field, Object value) {
1691 switch (field) {
1692 case TABLE:
1693 if (value == null) {
1694 unsetTable();
1695 } else {
1696 setTable((ByteBuffer)value);
1697 }
1698 break;
1699
1700 case GET:
1701 if (value == null) {
1702 unsetGet();
1703 } else {
1704 setGet((TGet)value);
1705 }
1706 break;
1707
1708 }
1709 }
1710
1711 public Object getFieldValue(_Fields field) {
1712 switch (field) {
1713 case TABLE:
1714 return getTable();
1715
1716 case GET:
1717 return getGet();
1718
1719 }
1720 throw new IllegalStateException();
1721 }
1722
1723
1724 public boolean isSet(_Fields field) {
1725 if (field == null) {
1726 throw new IllegalArgumentException();
1727 }
1728
1729 switch (field) {
1730 case TABLE:
1731 return isSetTable();
1732 case GET:
1733 return isSetGet();
1734 }
1735 throw new IllegalStateException();
1736 }
1737
1738 @Override
1739 public boolean equals(Object that) {
1740 if (that == null)
1741 return false;
1742 if (that instanceof exists_args)
1743 return this.equals((exists_args)that);
1744 return false;
1745 }
1746
1747 public boolean equals(exists_args that) {
1748 if (that == null)
1749 return false;
1750
1751 boolean this_present_table = true && this.isSetTable();
1752 boolean that_present_table = true && that.isSetTable();
1753 if (this_present_table || that_present_table) {
1754 if (!(this_present_table && that_present_table))
1755 return false;
1756 if (!this.table.equals(that.table))
1757 return false;
1758 }
1759
1760 boolean this_present_get = true && this.isSetGet();
1761 boolean that_present_get = true && that.isSetGet();
1762 if (this_present_get || that_present_get) {
1763 if (!(this_present_get && that_present_get))
1764 return false;
1765 if (!this.get.equals(that.get))
1766 return false;
1767 }
1768
1769 return true;
1770 }
1771
1772 @Override
1773 public int hashCode() {
1774 return 0;
1775 }
1776
1777 public int compareTo(exists_args other) {
1778 if (!getClass().equals(other.getClass())) {
1779 return getClass().getName().compareTo(other.getClass().getName());
1780 }
1781
1782 int lastComparison = 0;
1783 exists_args typedOther = (exists_args)other;
1784
1785 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
1786 if (lastComparison != 0) {
1787 return lastComparison;
1788 }
1789 if (isSetTable()) {
1790 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
1791 if (lastComparison != 0) {
1792 return lastComparison;
1793 }
1794 }
1795 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
1796 if (lastComparison != 0) {
1797 return lastComparison;
1798 }
1799 if (isSetGet()) {
1800 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
1801 if (lastComparison != 0) {
1802 return lastComparison;
1803 }
1804 }
1805 return 0;
1806 }
1807
1808 public _Fields fieldForId(int fieldId) {
1809 return _Fields.findByThriftId(fieldId);
1810 }
1811
1812 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
1813 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
1814 }
1815
1816 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
1817 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
1818 }
1819
1820 @Override
1821 public String toString() {
1822 StringBuilder sb = new StringBuilder("exists_args(");
1823 boolean first = true;
1824
1825 sb.append("table:");
1826 if (this.table == null) {
1827 sb.append("null");
1828 } else {
1829 org.apache.thrift.TBaseHelper.toString(this.table, sb);
1830 }
1831 first = false;
1832 if (!first) sb.append(", ");
1833 sb.append("get:");
1834 if (this.get == null) {
1835 sb.append("null");
1836 } else {
1837 sb.append(this.get);
1838 }
1839 first = false;
1840 sb.append(")");
1841 return sb.toString();
1842 }
1843
1844 public void validate() throws org.apache.thrift.TException {
1845
1846 if (table == null) {
1847 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
1848 }
1849 if (get == null) {
1850 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
1851 }
1852 }
1853
1854 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
1855 try {
1856 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
1857 } catch (org.apache.thrift.TException te) {
1858 throw new java.io.IOException(te);
1859 }
1860 }
1861
1862 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
1863 try {
1864 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
1865 } catch (org.apache.thrift.TException te) {
1866 throw new java.io.IOException(te);
1867 }
1868 }
1869
1870 private static class exists_argsStandardSchemeFactory implements SchemeFactory {
1871 public exists_argsStandardScheme getScheme() {
1872 return new exists_argsStandardScheme();
1873 }
1874 }
1875
1876 private static class exists_argsStandardScheme extends StandardScheme<exists_args> {
1877
1878 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_args struct) throws org.apache.thrift.TException {
1879 org.apache.thrift.protocol.TField schemeField;
1880 iprot.readStructBegin();
1881 while (true)
1882 {
1883 schemeField = iprot.readFieldBegin();
1884 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
1885 break;
1886 }
1887 switch (schemeField.id) {
1888 case 1:
1889 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
1890 struct.table = iprot.readBinary();
1891 struct.setTableIsSet(true);
1892 } else {
1893 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1894 }
1895 break;
1896 case 2:
1897 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
1898 struct.get = new TGet();
1899 struct.get.read(iprot);
1900 struct.setGetIsSet(true);
1901 } else {
1902 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1903 }
1904 break;
1905 default:
1906 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1907 }
1908 iprot.readFieldEnd();
1909 }
1910 iprot.readStructEnd();
1911
1912
1913 struct.validate();
1914 }
1915
1916 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_args struct) throws org.apache.thrift.TException {
1917 struct.validate();
1918
1919 oprot.writeStructBegin(STRUCT_DESC);
1920 if (struct.table != null) {
1921 oprot.writeFieldBegin(TABLE_FIELD_DESC);
1922 oprot.writeBinary(struct.table);
1923 oprot.writeFieldEnd();
1924 }
1925 if (struct.get != null) {
1926 oprot.writeFieldBegin(GET_FIELD_DESC);
1927 struct.get.write(oprot);
1928 oprot.writeFieldEnd();
1929 }
1930 oprot.writeFieldStop();
1931 oprot.writeStructEnd();
1932 }
1933
1934 }
1935
1936 private static class exists_argsTupleSchemeFactory implements SchemeFactory {
1937 public exists_argsTupleScheme getScheme() {
1938 return new exists_argsTupleScheme();
1939 }
1940 }
1941
1942 private static class exists_argsTupleScheme extends TupleScheme<exists_args> {
1943
1944 @Override
1945 public void write(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
1946 TTupleProtocol oprot = (TTupleProtocol) prot;
1947 oprot.writeBinary(struct.table);
1948 struct.get.write(oprot);
1949 }
1950
1951 @Override
1952 public void read(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
1953 TTupleProtocol iprot = (TTupleProtocol) prot;
1954 struct.table = iprot.readBinary();
1955 struct.setTableIsSet(true);
1956 struct.get = new TGet();
1957 struct.get.read(iprot);
1958 struct.setGetIsSet(true);
1959 }
1960 }
1961
1962 }
1963
1964 public static class exists_result implements org.apache.thrift.TBase<exists_result, exists_result._Fields>, java.io.Serializable, Cloneable {
1965 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_result");
1966
1967 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);
1968 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);
1969
1970 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
1971 static {
1972 schemes.put(StandardScheme.class, new exists_resultStandardSchemeFactory());
1973 schemes.put(TupleScheme.class, new exists_resultTupleSchemeFactory());
1974 }
1975
1976 public boolean success;
1977 public TIOError io;
1978
1979
1980 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
1981 SUCCESS((short)0, "success"),
1982 IO((short)1, "io");
1983
1984 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
1985
1986 static {
1987 for (_Fields field : EnumSet.allOf(_Fields.class)) {
1988 byName.put(field.getFieldName(), field);
1989 }
1990 }
1991
1992
1993
1994
1995 public static _Fields findByThriftId(int fieldId) {
1996 switch(fieldId) {
1997 case 0:
1998 return SUCCESS;
1999 case 1:
2000 return IO;
2001 default:
2002 return null;
2003 }
2004 }
2005
2006
2007
2008
2009
2010 public static _Fields findByThriftIdOrThrow(int fieldId) {
2011 _Fields fields = findByThriftId(fieldId);
2012 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2013 return fields;
2014 }
2015
2016
2017
2018
2019 public static _Fields findByName(String name) {
2020 return byName.get(name);
2021 }
2022
2023 private final short _thriftId;
2024 private final String _fieldName;
2025
2026 _Fields(short thriftId, String fieldName) {
2027 _thriftId = thriftId;
2028 _fieldName = fieldName;
2029 }
2030
2031 public short getThriftFieldId() {
2032 return _thriftId;
2033 }
2034
2035 public String getFieldName() {
2036 return _fieldName;
2037 }
2038 }
2039
2040
2041 private static final int __SUCCESS_ISSET_ID = 0;
2042 private BitSet __isset_bit_vector = new BitSet(1);
2043 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2044 static {
2045 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2046 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
2047 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
2048 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
2049 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
2050 metaDataMap = Collections.unmodifiableMap(tmpMap);
2051 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_result.class, metaDataMap);
2052 }
2053
2054 public exists_result() {
2055 }
2056
2057 public exists_result(
2058 boolean success,
2059 TIOError io)
2060 {
2061 this();
2062 this.success = success;
2063 setSuccessIsSet(true);
2064 this.io = io;
2065 }
2066
2067
2068
2069
2070 public exists_result(exists_result other) {
2071 __isset_bit_vector.clear();
2072 __isset_bit_vector.or(other.__isset_bit_vector);
2073 this.success = other.success;
2074 if (other.isSetIo()) {
2075 this.io = new TIOError(other.io);
2076 }
2077 }
2078
2079 public exists_result deepCopy() {
2080 return new exists_result(this);
2081 }
2082
2083 @Override
2084 public void clear() {
2085 setSuccessIsSet(false);
2086 this.success = false;
2087 this.io = null;
2088 }
2089
2090 public boolean isSuccess() {
2091 return this.success;
2092 }
2093
2094 public exists_result setSuccess(boolean success) {
2095 this.success = success;
2096 setSuccessIsSet(true);
2097 return this;
2098 }
2099
2100 public void unsetSuccess() {
2101 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
2102 }
2103
2104
2105 public boolean isSetSuccess() {
2106 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
2107 }
2108
2109 public void setSuccessIsSet(boolean value) {
2110 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
2111 }
2112
2113 public TIOError getIo() {
2114 return this.io;
2115 }
2116
2117 public exists_result setIo(TIOError io) {
2118 this.io = io;
2119 return this;
2120 }
2121
2122 public void unsetIo() {
2123 this.io = null;
2124 }
2125
2126
2127 public boolean isSetIo() {
2128 return this.io != null;
2129 }
2130
2131 public void setIoIsSet(boolean value) {
2132 if (!value) {
2133 this.io = null;
2134 }
2135 }
2136
2137 public void setFieldValue(_Fields field, Object value) {
2138 switch (field) {
2139 case SUCCESS:
2140 if (value == null) {
2141 unsetSuccess();
2142 } else {
2143 setSuccess((Boolean)value);
2144 }
2145 break;
2146
2147 case IO:
2148 if (value == null) {
2149 unsetIo();
2150 } else {
2151 setIo((TIOError)value);
2152 }
2153 break;
2154
2155 }
2156 }
2157
2158 public Object getFieldValue(_Fields field) {
2159 switch (field) {
2160 case SUCCESS:
2161 return Boolean.valueOf(isSuccess());
2162
2163 case IO:
2164 return getIo();
2165
2166 }
2167 throw new IllegalStateException();
2168 }
2169
2170
2171 public boolean isSet(_Fields field) {
2172 if (field == null) {
2173 throw new IllegalArgumentException();
2174 }
2175
2176 switch (field) {
2177 case SUCCESS:
2178 return isSetSuccess();
2179 case IO:
2180 return isSetIo();
2181 }
2182 throw new IllegalStateException();
2183 }
2184
2185 @Override
2186 public boolean equals(Object that) {
2187 if (that == null)
2188 return false;
2189 if (that instanceof exists_result)
2190 return this.equals((exists_result)that);
2191 return false;
2192 }
2193
2194 public boolean equals(exists_result that) {
2195 if (that == null)
2196 return false;
2197
2198 boolean this_present_success = true;
2199 boolean that_present_success = true;
2200 if (this_present_success || that_present_success) {
2201 if (!(this_present_success && that_present_success))
2202 return false;
2203 if (this.success != that.success)
2204 return false;
2205 }
2206
2207 boolean this_present_io = true && this.isSetIo();
2208 boolean that_present_io = true && that.isSetIo();
2209 if (this_present_io || that_present_io) {
2210 if (!(this_present_io && that_present_io))
2211 return false;
2212 if (!this.io.equals(that.io))
2213 return false;
2214 }
2215
2216 return true;
2217 }
2218
2219 @Override
2220 public int hashCode() {
2221 return 0;
2222 }
2223
2224 public int compareTo(exists_result other) {
2225 if (!getClass().equals(other.getClass())) {
2226 return getClass().getName().compareTo(other.getClass().getName());
2227 }
2228
2229 int lastComparison = 0;
2230 exists_result typedOther = (exists_result)other;
2231
2232 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
2233 if (lastComparison != 0) {
2234 return lastComparison;
2235 }
2236 if (isSetSuccess()) {
2237 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
2238 if (lastComparison != 0) {
2239 return lastComparison;
2240 }
2241 }
2242 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
2243 if (lastComparison != 0) {
2244 return lastComparison;
2245 }
2246 if (isSetIo()) {
2247 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
2248 if (lastComparison != 0) {
2249 return lastComparison;
2250 }
2251 }
2252 return 0;
2253 }
2254
2255 public _Fields fieldForId(int fieldId) {
2256 return _Fields.findByThriftId(fieldId);
2257 }
2258
2259 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2260 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2261 }
2262
2263 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2264 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2265 }
2266
2267 @Override
2268 public String toString() {
2269 StringBuilder sb = new StringBuilder("exists_result(");
2270 boolean first = true;
2271
2272 sb.append("success:");
2273 sb.append(this.success);
2274 first = false;
2275 if (!first) sb.append(", ");
2276 sb.append("io:");
2277 if (this.io == null) {
2278 sb.append("null");
2279 } else {
2280 sb.append(this.io);
2281 }
2282 first = false;
2283 sb.append(")");
2284 return sb.toString();
2285 }
2286
2287 public void validate() throws org.apache.thrift.TException {
2288
2289 }
2290
2291 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2292 try {
2293 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2294 } catch (org.apache.thrift.TException te) {
2295 throw new java.io.IOException(te);
2296 }
2297 }
2298
2299 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2300 try {
2301
2302 __isset_bit_vector = new BitSet(1);
2303 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2304 } catch (org.apache.thrift.TException te) {
2305 throw new java.io.IOException(te);
2306 }
2307 }
2308
2309 private static class exists_resultStandardSchemeFactory implements SchemeFactory {
2310 public exists_resultStandardScheme getScheme() {
2311 return new exists_resultStandardScheme();
2312 }
2313 }
2314
2315 private static class exists_resultStandardScheme extends StandardScheme<exists_result> {
2316
2317 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_result struct) throws org.apache.thrift.TException {
2318 org.apache.thrift.protocol.TField schemeField;
2319 iprot.readStructBegin();
2320 while (true)
2321 {
2322 schemeField = iprot.readFieldBegin();
2323 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2324 break;
2325 }
2326 switch (schemeField.id) {
2327 case 0:
2328 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
2329 struct.success = iprot.readBool();
2330 struct.setSuccessIsSet(true);
2331 } else {
2332 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2333 }
2334 break;
2335 case 1:
2336 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2337 struct.io = new TIOError();
2338 struct.io.read(iprot);
2339 struct.setIoIsSet(true);
2340 } else {
2341 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2342 }
2343 break;
2344 default:
2345 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2346 }
2347 iprot.readFieldEnd();
2348 }
2349 iprot.readStructEnd();
2350
2351
2352 struct.validate();
2353 }
2354
2355 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_result struct) throws org.apache.thrift.TException {
2356 struct.validate();
2357
2358 oprot.writeStructBegin(STRUCT_DESC);
2359 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
2360 oprot.writeBool(struct.success);
2361 oprot.writeFieldEnd();
2362 if (struct.io != null) {
2363 oprot.writeFieldBegin(IO_FIELD_DESC);
2364 struct.io.write(oprot);
2365 oprot.writeFieldEnd();
2366 }
2367 oprot.writeFieldStop();
2368 oprot.writeStructEnd();
2369 }
2370
2371 }
2372
2373 private static class exists_resultTupleSchemeFactory implements SchemeFactory {
2374 public exists_resultTupleScheme getScheme() {
2375 return new exists_resultTupleScheme();
2376 }
2377 }
2378
2379 private static class exists_resultTupleScheme extends TupleScheme<exists_result> {
2380
2381 @Override
2382 public void write(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2383 TTupleProtocol oprot = (TTupleProtocol) prot;
2384 BitSet optionals = new BitSet();
2385 if (struct.isSetSuccess()) {
2386 optionals.set(0);
2387 }
2388 if (struct.isSetIo()) {
2389 optionals.set(1);
2390 }
2391 oprot.writeBitSet(optionals, 2);
2392 if (struct.isSetSuccess()) {
2393 oprot.writeBool(struct.success);
2394 }
2395 if (struct.isSetIo()) {
2396 struct.io.write(oprot);
2397 }
2398 }
2399
2400 @Override
2401 public void read(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2402 TTupleProtocol iprot = (TTupleProtocol) prot;
2403 BitSet incoming = iprot.readBitSet(2);
2404 if (incoming.get(0)) {
2405 struct.success = iprot.readBool();
2406 struct.setSuccessIsSet(true);
2407 }
2408 if (incoming.get(1)) {
2409 struct.io = new TIOError();
2410 struct.io.read(iprot);
2411 struct.setIoIsSet(true);
2412 }
2413 }
2414 }
2415
2416 }
2417
2418 public static class get_args implements org.apache.thrift.TBase<get_args, get_args._Fields>, java.io.Serializable, Cloneable {
2419 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_args");
2420
2421 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);
2422 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);
2423
2424 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2425 static {
2426 schemes.put(StandardScheme.class, new get_argsStandardSchemeFactory());
2427 schemes.put(TupleScheme.class, new get_argsTupleSchemeFactory());
2428 }
2429
2430
2431
2432
2433 public ByteBuffer table;
2434
2435
2436
2437 public TGet get;
2438
2439
2440 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2441
2442
2443
2444 TABLE((short)1, "table"),
2445
2446
2447
2448 GET((short)2, "get");
2449
2450 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2451
2452 static {
2453 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2454 byName.put(field.getFieldName(), field);
2455 }
2456 }
2457
2458
2459
2460
2461 public static _Fields findByThriftId(int fieldId) {
2462 switch(fieldId) {
2463 case 1:
2464 return TABLE;
2465 case 2:
2466 return GET;
2467 default:
2468 return null;
2469 }
2470 }
2471
2472
2473
2474
2475
2476 public static _Fields findByThriftIdOrThrow(int fieldId) {
2477 _Fields fields = findByThriftId(fieldId);
2478 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2479 return fields;
2480 }
2481
2482
2483
2484
2485 public static _Fields findByName(String name) {
2486 return byName.get(name);
2487 }
2488
2489 private final short _thriftId;
2490 private final String _fieldName;
2491
2492 _Fields(short thriftId, String fieldName) {
2493 _thriftId = thriftId;
2494 _fieldName = fieldName;
2495 }
2496
2497 public short getThriftFieldId() {
2498 return _thriftId;
2499 }
2500
2501 public String getFieldName() {
2502 return _fieldName;
2503 }
2504 }
2505
2506
2507 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2508 static {
2509 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2510 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
2511 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
2512 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
2513 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
2514 metaDataMap = Collections.unmodifiableMap(tmpMap);
2515 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
2516 }
2517
2518 public get_args() {
2519 }
2520
2521 public get_args(
2522 ByteBuffer table,
2523 TGet get)
2524 {
2525 this();
2526 this.table = table;
2527 this.get = get;
2528 }
2529
2530
2531
2532
2533 public get_args(get_args other) {
2534 if (other.isSetTable()) {
2535 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
2536 ;
2537 }
2538 if (other.isSetGet()) {
2539 this.get = new TGet(other.get);
2540 }
2541 }
2542
2543 public get_args deepCopy() {
2544 return new get_args(this);
2545 }
2546
2547 @Override
2548 public void clear() {
2549 this.table = null;
2550 this.get = null;
2551 }
2552
2553
2554
2555
2556 public byte[] getTable() {
2557 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
2558 return table == null ? null : table.array();
2559 }
2560
2561 public ByteBuffer bufferForTable() {
2562 return table;
2563 }
2564
2565
2566
2567
2568 public get_args setTable(byte[] table) {
2569 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
2570 return this;
2571 }
2572
2573 public get_args setTable(ByteBuffer table) {
2574 this.table = table;
2575 return this;
2576 }
2577
2578 public void unsetTable() {
2579 this.table = null;
2580 }
2581
2582
2583 public boolean isSetTable() {
2584 return this.table != null;
2585 }
2586
2587 public void setTableIsSet(boolean value) {
2588 if (!value) {
2589 this.table = null;
2590 }
2591 }
2592
2593
2594
2595
2596 public TGet getGet() {
2597 return this.get;
2598 }
2599
2600
2601
2602
2603 public get_args setGet(TGet get) {
2604 this.get = get;
2605 return this;
2606 }
2607
2608 public void unsetGet() {
2609 this.get = null;
2610 }
2611
2612
2613 public boolean isSetGet() {
2614 return this.get != null;
2615 }
2616
2617 public void setGetIsSet(boolean value) {
2618 if (!value) {
2619 this.get = null;
2620 }
2621 }
2622
2623 public void setFieldValue(_Fields field, Object value) {
2624 switch (field) {
2625 case TABLE:
2626 if (value == null) {
2627 unsetTable();
2628 } else {
2629 setTable((ByteBuffer)value);
2630 }
2631 break;
2632
2633 case GET:
2634 if (value == null) {
2635 unsetGet();
2636 } else {
2637 setGet((TGet)value);
2638 }
2639 break;
2640
2641 }
2642 }
2643
2644 public Object getFieldValue(_Fields field) {
2645 switch (field) {
2646 case TABLE:
2647 return getTable();
2648
2649 case GET:
2650 return getGet();
2651
2652 }
2653 throw new IllegalStateException();
2654 }
2655
2656
2657 public boolean isSet(_Fields field) {
2658 if (field == null) {
2659 throw new IllegalArgumentException();
2660 }
2661
2662 switch (field) {
2663 case TABLE:
2664 return isSetTable();
2665 case GET:
2666 return isSetGet();
2667 }
2668 throw new IllegalStateException();
2669 }
2670
2671 @Override
2672 public boolean equals(Object that) {
2673 if (that == null)
2674 return false;
2675 if (that instanceof get_args)
2676 return this.equals((get_args)that);
2677 return false;
2678 }
2679
2680 public boolean equals(get_args that) {
2681 if (that == null)
2682 return false;
2683
2684 boolean this_present_table = true && this.isSetTable();
2685 boolean that_present_table = true && that.isSetTable();
2686 if (this_present_table || that_present_table) {
2687 if (!(this_present_table && that_present_table))
2688 return false;
2689 if (!this.table.equals(that.table))
2690 return false;
2691 }
2692
2693 boolean this_present_get = true && this.isSetGet();
2694 boolean that_present_get = true && that.isSetGet();
2695 if (this_present_get || that_present_get) {
2696 if (!(this_present_get && that_present_get))
2697 return false;
2698 if (!this.get.equals(that.get))
2699 return false;
2700 }
2701
2702 return true;
2703 }
2704
2705 @Override
2706 public int hashCode() {
2707 return 0;
2708 }
2709
2710 public int compareTo(get_args other) {
2711 if (!getClass().equals(other.getClass())) {
2712 return getClass().getName().compareTo(other.getClass().getName());
2713 }
2714
2715 int lastComparison = 0;
2716 get_args typedOther = (get_args)other;
2717
2718 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
2719 if (lastComparison != 0) {
2720 return lastComparison;
2721 }
2722 if (isSetTable()) {
2723 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
2724 if (lastComparison != 0) {
2725 return lastComparison;
2726 }
2727 }
2728 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
2729 if (lastComparison != 0) {
2730 return lastComparison;
2731 }
2732 if (isSetGet()) {
2733 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
2734 if (lastComparison != 0) {
2735 return lastComparison;
2736 }
2737 }
2738 return 0;
2739 }
2740
2741 public _Fields fieldForId(int fieldId) {
2742 return _Fields.findByThriftId(fieldId);
2743 }
2744
2745 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2746 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2747 }
2748
2749 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2750 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2751 }
2752
2753 @Override
2754 public String toString() {
2755 StringBuilder sb = new StringBuilder("get_args(");
2756 boolean first = true;
2757
2758 sb.append("table:");
2759 if (this.table == null) {
2760 sb.append("null");
2761 } else {
2762 org.apache.thrift.TBaseHelper.toString(this.table, sb);
2763 }
2764 first = false;
2765 if (!first) sb.append(", ");
2766 sb.append("get:");
2767 if (this.get == null) {
2768 sb.append("null");
2769 } else {
2770 sb.append(this.get);
2771 }
2772 first = false;
2773 sb.append(")");
2774 return sb.toString();
2775 }
2776
2777 public void validate() throws org.apache.thrift.TException {
2778
2779 if (table == null) {
2780 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
2781 }
2782 if (get == null) {
2783 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
2784 }
2785 }
2786
2787 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2788 try {
2789 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2790 } catch (org.apache.thrift.TException te) {
2791 throw new java.io.IOException(te);
2792 }
2793 }
2794
2795 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2796 try {
2797 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2798 } catch (org.apache.thrift.TException te) {
2799 throw new java.io.IOException(te);
2800 }
2801 }
2802
2803 private static class get_argsStandardSchemeFactory implements SchemeFactory {
2804 public get_argsStandardScheme getScheme() {
2805 return new get_argsStandardScheme();
2806 }
2807 }
2808
2809 private static class get_argsStandardScheme extends StandardScheme<get_args> {
2810
2811 public void read(org.apache.thrift.protocol.TProtocol iprot, get_args struct) throws org.apache.thrift.TException {
2812 org.apache.thrift.protocol.TField schemeField;
2813 iprot.readStructBegin();
2814 while (true)
2815 {
2816 schemeField = iprot.readFieldBegin();
2817 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2818 break;
2819 }
2820 switch (schemeField.id) {
2821 case 1:
2822 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
2823 struct.table = iprot.readBinary();
2824 struct.setTableIsSet(true);
2825 } else {
2826 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2827 }
2828 break;
2829 case 2:
2830 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2831 struct.get = new TGet();
2832 struct.get.read(iprot);
2833 struct.setGetIsSet(true);
2834 } else {
2835 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2836 }
2837 break;
2838 default:
2839 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2840 }
2841 iprot.readFieldEnd();
2842 }
2843 iprot.readStructEnd();
2844
2845
2846 struct.validate();
2847 }
2848
2849 public void write(org.apache.thrift.protocol.TProtocol oprot, get_args struct) throws org.apache.thrift.TException {
2850 struct.validate();
2851
2852 oprot.writeStructBegin(STRUCT_DESC);
2853 if (struct.table != null) {
2854 oprot.writeFieldBegin(TABLE_FIELD_DESC);
2855 oprot.writeBinary(struct.table);
2856 oprot.writeFieldEnd();
2857 }
2858 if (struct.get != null) {
2859 oprot.writeFieldBegin(GET_FIELD_DESC);
2860 struct.get.write(oprot);
2861 oprot.writeFieldEnd();
2862 }
2863 oprot.writeFieldStop();
2864 oprot.writeStructEnd();
2865 }
2866
2867 }
2868
2869 private static class get_argsTupleSchemeFactory implements SchemeFactory {
2870 public get_argsTupleScheme getScheme() {
2871 return new get_argsTupleScheme();
2872 }
2873 }
2874
2875 private static class get_argsTupleScheme extends TupleScheme<get_args> {
2876
2877 @Override
2878 public void write(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2879 TTupleProtocol oprot = (TTupleProtocol) prot;
2880 oprot.writeBinary(struct.table);
2881 struct.get.write(oprot);
2882 }
2883
2884 @Override
2885 public void read(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2886 TTupleProtocol iprot = (TTupleProtocol) prot;
2887 struct.table = iprot.readBinary();
2888 struct.setTableIsSet(true);
2889 struct.get = new TGet();
2890 struct.get.read(iprot);
2891 struct.setGetIsSet(true);
2892 }
2893 }
2894
2895 }
2896
2897 public static class get_result implements org.apache.thrift.TBase<get_result, get_result._Fields>, java.io.Serializable, Cloneable {
2898 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_result");
2899
2900 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);
2901 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);
2902
2903 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2904 static {
2905 schemes.put(StandardScheme.class, new get_resultStandardSchemeFactory());
2906 schemes.put(TupleScheme.class, new get_resultTupleSchemeFactory());
2907 }
2908
2909 public TResult success;
2910 public TIOError io;
2911
2912
2913 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2914 SUCCESS((short)0, "success"),
2915 IO((short)1, "io");
2916
2917 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2918
2919 static {
2920 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2921 byName.put(field.getFieldName(), field);
2922 }
2923 }
2924
2925
2926
2927
2928 public static _Fields findByThriftId(int fieldId) {
2929 switch(fieldId) {
2930 case 0:
2931 return SUCCESS;
2932 case 1:
2933 return IO;
2934 default:
2935 return null;
2936 }
2937 }
2938
2939
2940
2941
2942
2943 public static _Fields findByThriftIdOrThrow(int fieldId) {
2944 _Fields fields = findByThriftId(fieldId);
2945 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2946 return fields;
2947 }
2948
2949
2950
2951
2952 public static _Fields findByName(String name) {
2953 return byName.get(name);
2954 }
2955
2956 private final short _thriftId;
2957 private final String _fieldName;
2958
2959 _Fields(short thriftId, String fieldName) {
2960 _thriftId = thriftId;
2961 _fieldName = fieldName;
2962 }
2963
2964 public short getThriftFieldId() {
2965 return _thriftId;
2966 }
2967
2968 public String getFieldName() {
2969 return _fieldName;
2970 }
2971 }
2972
2973
2974 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2975 static {
2976 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2977 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
2978 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
2979 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
2980 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
2981 metaDataMap = Collections.unmodifiableMap(tmpMap);
2982 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
2983 }
2984
2985 public get_result() {
2986 }
2987
2988 public get_result(
2989 TResult success,
2990 TIOError io)
2991 {
2992 this();
2993 this.success = success;
2994 this.io = io;
2995 }
2996
2997
2998
2999
3000 public get_result(get_result other) {
3001 if (other.isSetSuccess()) {
3002 this.success = new TResult(other.success);
3003 }
3004 if (other.isSetIo()) {
3005 this.io = new TIOError(other.io);
3006 }
3007 }
3008
3009 public get_result deepCopy() {
3010 return new get_result(this);
3011 }
3012
3013 @Override
3014 public void clear() {
3015 this.success = null;
3016 this.io = null;
3017 }
3018
3019 public TResult getSuccess() {
3020 return this.success;
3021 }
3022
3023 public get_result setSuccess(TResult success) {
3024 this.success = success;
3025 return this;
3026 }
3027
3028 public void unsetSuccess() {
3029 this.success = null;
3030 }
3031
3032
3033 public boolean isSetSuccess() {
3034 return this.success != null;
3035 }
3036
3037 public void setSuccessIsSet(boolean value) {
3038 if (!value) {
3039 this.success = null;
3040 }
3041 }
3042
3043 public TIOError getIo() {
3044 return this.io;
3045 }
3046
3047 public get_result setIo(TIOError io) {
3048 this.io = io;
3049 return this;
3050 }
3051
3052 public void unsetIo() {
3053 this.io = null;
3054 }
3055
3056
3057 public boolean isSetIo() {
3058 return this.io != null;
3059 }
3060
3061 public void setIoIsSet(boolean value) {
3062 if (!value) {
3063 this.io = null;
3064 }
3065 }
3066
3067 public void setFieldValue(_Fields field, Object value) {
3068 switch (field) {
3069 case SUCCESS:
3070 if (value == null) {
3071 unsetSuccess();
3072 } else {
3073 setSuccess((TResult)value);
3074 }
3075 break;
3076
3077 case IO:
3078 if (value == null) {
3079 unsetIo();
3080 } else {
3081 setIo((TIOError)value);
3082 }
3083 break;
3084
3085 }
3086 }
3087
3088 public Object getFieldValue(_Fields field) {
3089 switch (field) {
3090 case SUCCESS:
3091 return getSuccess();
3092
3093 case IO:
3094 return getIo();
3095
3096 }
3097 throw new IllegalStateException();
3098 }
3099
3100
3101 public boolean isSet(_Fields field) {
3102 if (field == null) {
3103 throw new IllegalArgumentException();
3104 }
3105
3106 switch (field) {
3107 case SUCCESS:
3108 return isSetSuccess();
3109 case IO:
3110 return isSetIo();
3111 }
3112 throw new IllegalStateException();
3113 }
3114
3115 @Override
3116 public boolean equals(Object that) {
3117 if (that == null)
3118 return false;
3119 if (that instanceof get_result)
3120 return this.equals((get_result)that);
3121 return false;
3122 }
3123
3124 public boolean equals(get_result that) {
3125 if (that == null)
3126 return false;
3127
3128 boolean this_present_success = true && this.isSetSuccess();
3129 boolean that_present_success = true && that.isSetSuccess();
3130 if (this_present_success || that_present_success) {
3131 if (!(this_present_success && that_present_success))
3132 return false;
3133 if (!this.success.equals(that.success))
3134 return false;
3135 }
3136
3137 boolean this_present_io = true && this.isSetIo();
3138 boolean that_present_io = true && that.isSetIo();
3139 if (this_present_io || that_present_io) {
3140 if (!(this_present_io && that_present_io))
3141 return false;
3142 if (!this.io.equals(that.io))
3143 return false;
3144 }
3145
3146 return true;
3147 }
3148
3149 @Override
3150 public int hashCode() {
3151 return 0;
3152 }
3153
3154 public int compareTo(get_result other) {
3155 if (!getClass().equals(other.getClass())) {
3156 return getClass().getName().compareTo(other.getClass().getName());
3157 }
3158
3159 int lastComparison = 0;
3160 get_result typedOther = (get_result)other;
3161
3162 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
3163 if (lastComparison != 0) {
3164 return lastComparison;
3165 }
3166 if (isSetSuccess()) {
3167 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
3168 if (lastComparison != 0) {
3169 return lastComparison;
3170 }
3171 }
3172 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
3173 if (lastComparison != 0) {
3174 return lastComparison;
3175 }
3176 if (isSetIo()) {
3177 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
3178 if (lastComparison != 0) {
3179 return lastComparison;
3180 }
3181 }
3182 return 0;
3183 }
3184
3185 public _Fields fieldForId(int fieldId) {
3186 return _Fields.findByThriftId(fieldId);
3187 }
3188
3189 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3190 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3191 }
3192
3193 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3194 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3195 }
3196
3197 @Override
3198 public String toString() {
3199 StringBuilder sb = new StringBuilder("get_result(");
3200 boolean first = true;
3201
3202 sb.append("success:");
3203 if (this.success == null) {
3204 sb.append("null");
3205 } else {
3206 sb.append(this.success);
3207 }
3208 first = false;
3209 if (!first) sb.append(", ");
3210 sb.append("io:");
3211 if (this.io == null) {
3212 sb.append("null");
3213 } else {
3214 sb.append(this.io);
3215 }
3216 first = false;
3217 sb.append(")");
3218 return sb.toString();
3219 }
3220
3221 public void validate() throws org.apache.thrift.TException {
3222
3223 }
3224
3225 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3226 try {
3227 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3228 } catch (org.apache.thrift.TException te) {
3229 throw new java.io.IOException(te);
3230 }
3231 }
3232
3233 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3234 try {
3235 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3236 } catch (org.apache.thrift.TException te) {
3237 throw new java.io.IOException(te);
3238 }
3239 }
3240
3241 private static class get_resultStandardSchemeFactory implements SchemeFactory {
3242 public get_resultStandardScheme getScheme() {
3243 return new get_resultStandardScheme();
3244 }
3245 }
3246
3247 private static class get_resultStandardScheme extends StandardScheme<get_result> {
3248
3249 public void read(org.apache.thrift.protocol.TProtocol iprot, get_result struct) throws org.apache.thrift.TException {
3250 org.apache.thrift.protocol.TField schemeField;
3251 iprot.readStructBegin();
3252 while (true)
3253 {
3254 schemeField = iprot.readFieldBegin();
3255 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3256 break;
3257 }
3258 switch (schemeField.id) {
3259 case 0:
3260 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3261 struct.success = new TResult();
3262 struct.success.read(iprot);
3263 struct.setSuccessIsSet(true);
3264 } else {
3265 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3266 }
3267 break;
3268 case 1:
3269 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3270 struct.io = new TIOError();
3271 struct.io.read(iprot);
3272 struct.setIoIsSet(true);
3273 } else {
3274 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3275 }
3276 break;
3277 default:
3278 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3279 }
3280 iprot.readFieldEnd();
3281 }
3282 iprot.readStructEnd();
3283
3284
3285 struct.validate();
3286 }
3287
3288 public void write(org.apache.thrift.protocol.TProtocol oprot, get_result struct) throws org.apache.thrift.TException {
3289 struct.validate();
3290
3291 oprot.writeStructBegin(STRUCT_DESC);
3292 if (struct.success != null) {
3293 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3294 struct.success.write(oprot);
3295 oprot.writeFieldEnd();
3296 }
3297 if (struct.io != null) {
3298 oprot.writeFieldBegin(IO_FIELD_DESC);
3299 struct.io.write(oprot);
3300 oprot.writeFieldEnd();
3301 }
3302 oprot.writeFieldStop();
3303 oprot.writeStructEnd();
3304 }
3305
3306 }
3307
3308 private static class get_resultTupleSchemeFactory implements SchemeFactory {
3309 public get_resultTupleScheme getScheme() {
3310 return new get_resultTupleScheme();
3311 }
3312 }
3313
3314 private static class get_resultTupleScheme extends TupleScheme<get_result> {
3315
3316 @Override
3317 public void write(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3318 TTupleProtocol oprot = (TTupleProtocol) prot;
3319 BitSet optionals = new BitSet();
3320 if (struct.isSetSuccess()) {
3321 optionals.set(0);
3322 }
3323 if (struct.isSetIo()) {
3324 optionals.set(1);
3325 }
3326 oprot.writeBitSet(optionals, 2);
3327 if (struct.isSetSuccess()) {
3328 struct.success.write(oprot);
3329 }
3330 if (struct.isSetIo()) {
3331 struct.io.write(oprot);
3332 }
3333 }
3334
3335 @Override
3336 public void read(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3337 TTupleProtocol iprot = (TTupleProtocol) prot;
3338 BitSet incoming = iprot.readBitSet(2);
3339 if (incoming.get(0)) {
3340 struct.success = new TResult();
3341 struct.success.read(iprot);
3342 struct.setSuccessIsSet(true);
3343 }
3344 if (incoming.get(1)) {
3345 struct.io = new TIOError();
3346 struct.io.read(iprot);
3347 struct.setIoIsSet(true);
3348 }
3349 }
3350 }
3351
3352 }
3353
3354 public static class getMultiple_args implements org.apache.thrift.TBase<getMultiple_args, getMultiple_args._Fields>, java.io.Serializable, Cloneable {
3355 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_args");
3356
3357 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);
3358 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);
3359
3360 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3361 static {
3362 schemes.put(StandardScheme.class, new getMultiple_argsStandardSchemeFactory());
3363 schemes.put(TupleScheme.class, new getMultiple_argsTupleSchemeFactory());
3364 }
3365
3366
3367
3368
3369 public ByteBuffer table;
3370
3371
3372
3373
3374
3375 public List<TGet> gets;
3376
3377
3378 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3379
3380
3381
3382 TABLE((short)1, "table"),
3383
3384
3385
3386
3387
3388 GETS((short)2, "gets");
3389
3390 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3391
3392 static {
3393 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3394 byName.put(field.getFieldName(), field);
3395 }
3396 }
3397
3398
3399
3400
3401 public static _Fields findByThriftId(int fieldId) {
3402 switch(fieldId) {
3403 case 1:
3404 return TABLE;
3405 case 2:
3406 return GETS;
3407 default:
3408 return null;
3409 }
3410 }
3411
3412
3413
3414
3415
3416 public static _Fields findByThriftIdOrThrow(int fieldId) {
3417 _Fields fields = findByThriftId(fieldId);
3418 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3419 return fields;
3420 }
3421
3422
3423
3424
3425 public static _Fields findByName(String name) {
3426 return byName.get(name);
3427 }
3428
3429 private final short _thriftId;
3430 private final String _fieldName;
3431
3432 _Fields(short thriftId, String fieldName) {
3433 _thriftId = thriftId;
3434 _fieldName = fieldName;
3435 }
3436
3437 public short getThriftFieldId() {
3438 return _thriftId;
3439 }
3440
3441 public String getFieldName() {
3442 return _fieldName;
3443 }
3444 }
3445
3446
3447 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3448 static {
3449 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3450 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
3451 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
3452 tmpMap.put(_Fields.GETS, new org.apache.thrift.meta_data.FieldMetaData("gets", org.apache.thrift.TFieldRequirementType.REQUIRED,
3453 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
3454 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class))));
3455 metaDataMap = Collections.unmodifiableMap(tmpMap);
3456 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_args.class, metaDataMap);
3457 }
3458
3459 public getMultiple_args() {
3460 }
3461
3462 public getMultiple_args(
3463 ByteBuffer table,
3464 List<TGet> gets)
3465 {
3466 this();
3467 this.table = table;
3468 this.gets = gets;
3469 }
3470
3471
3472
3473
3474 public getMultiple_args(getMultiple_args other) {
3475 if (other.isSetTable()) {
3476 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
3477 ;
3478 }
3479 if (other.isSetGets()) {
3480 List<TGet> __this__gets = new ArrayList<TGet>();
3481 for (TGet other_element : other.gets) {
3482 __this__gets.add(new TGet(other_element));
3483 }
3484 this.gets = __this__gets;
3485 }
3486 }
3487
3488 public getMultiple_args deepCopy() {
3489 return new getMultiple_args(this);
3490 }
3491
3492 @Override
3493 public void clear() {
3494 this.table = null;
3495 this.gets = null;
3496 }
3497
3498
3499
3500
3501 public byte[] getTable() {
3502 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
3503 return table == null ? null : table.array();
3504 }
3505
3506 public ByteBuffer bufferForTable() {
3507 return table;
3508 }
3509
3510
3511
3512
3513 public getMultiple_args setTable(byte[] table) {
3514 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
3515 return this;
3516 }
3517
3518 public getMultiple_args setTable(ByteBuffer table) {
3519 this.table = table;
3520 return this;
3521 }
3522
3523 public void unsetTable() {
3524 this.table = null;
3525 }
3526
3527
3528 public boolean isSetTable() {
3529 return this.table != null;
3530 }
3531
3532 public void setTableIsSet(boolean value) {
3533 if (!value) {
3534 this.table = null;
3535 }
3536 }
3537
3538 public int getGetsSize() {
3539 return (this.gets == null) ? 0 : this.gets.size();
3540 }
3541
3542 public java.util.Iterator<TGet> getGetsIterator() {
3543 return (this.gets == null) ? null : this.gets.iterator();
3544 }
3545
3546 public void addToGets(TGet elem) {
3547 if (this.gets == null) {
3548 this.gets = new ArrayList<TGet>();
3549 }
3550 this.gets.add(elem);
3551 }
3552
3553
3554
3555
3556
3557
3558 public List<TGet> getGets() {
3559 return this.gets;
3560 }
3561
3562
3563
3564
3565
3566
3567 public getMultiple_args setGets(List<TGet> gets) {
3568 this.gets = gets;
3569 return this;
3570 }
3571
3572 public void unsetGets() {
3573 this.gets = null;
3574 }
3575
3576
3577 public boolean isSetGets() {
3578 return this.gets != null;
3579 }
3580
3581 public void setGetsIsSet(boolean value) {
3582 if (!value) {
3583 this.gets = null;
3584 }
3585 }
3586
3587 public void setFieldValue(_Fields field, Object value) {
3588 switch (field) {
3589 case TABLE:
3590 if (value == null) {
3591 unsetTable();
3592 } else {
3593 setTable((ByteBuffer)value);
3594 }
3595 break;
3596
3597 case GETS:
3598 if (value == null) {
3599 unsetGets();
3600 } else {
3601 setGets((List<TGet>)value);
3602 }
3603 break;
3604
3605 }
3606 }
3607
3608 public Object getFieldValue(_Fields field) {
3609 switch (field) {
3610 case TABLE:
3611 return getTable();
3612
3613 case GETS:
3614 return getGets();
3615
3616 }
3617 throw new IllegalStateException();
3618 }
3619
3620
3621 public boolean isSet(_Fields field) {
3622 if (field == null) {
3623 throw new IllegalArgumentException();
3624 }
3625
3626 switch (field) {
3627 case TABLE:
3628 return isSetTable();
3629 case GETS:
3630 return isSetGets();
3631 }
3632 throw new IllegalStateException();
3633 }
3634
3635 @Override
3636 public boolean equals(Object that) {
3637 if (that == null)
3638 return false;
3639 if (that instanceof getMultiple_args)
3640 return this.equals((getMultiple_args)that);
3641 return false;
3642 }
3643
3644 public boolean equals(getMultiple_args that) {
3645 if (that == null)
3646 return false;
3647
3648 boolean this_present_table = true && this.isSetTable();
3649 boolean that_present_table = true && that.isSetTable();
3650 if (this_present_table || that_present_table) {
3651 if (!(this_present_table && that_present_table))
3652 return false;
3653 if (!this.table.equals(that.table))
3654 return false;
3655 }
3656
3657 boolean this_present_gets = true && this.isSetGets();
3658 boolean that_present_gets = true && that.isSetGets();
3659 if (this_present_gets || that_present_gets) {
3660 if (!(this_present_gets && that_present_gets))
3661 return false;
3662 if (!this.gets.equals(that.gets))
3663 return false;
3664 }
3665
3666 return true;
3667 }
3668
3669 @Override
3670 public int hashCode() {
3671 return 0;
3672 }
3673
3674 public int compareTo(getMultiple_args other) {
3675 if (!getClass().equals(other.getClass())) {
3676 return getClass().getName().compareTo(other.getClass().getName());
3677 }
3678
3679 int lastComparison = 0;
3680 getMultiple_args typedOther = (getMultiple_args)other;
3681
3682 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
3683 if (lastComparison != 0) {
3684 return lastComparison;
3685 }
3686 if (isSetTable()) {
3687 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
3688 if (lastComparison != 0) {
3689 return lastComparison;
3690 }
3691 }
3692 lastComparison = Boolean.valueOf(isSetGets()).compareTo(typedOther.isSetGets());
3693 if (lastComparison != 0) {
3694 return lastComparison;
3695 }
3696 if (isSetGets()) {
3697 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gets, typedOther.gets);
3698 if (lastComparison != 0) {
3699 return lastComparison;
3700 }
3701 }
3702 return 0;
3703 }
3704
3705 public _Fields fieldForId(int fieldId) {
3706 return _Fields.findByThriftId(fieldId);
3707 }
3708
3709 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3710 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3711 }
3712
3713 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3714 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3715 }
3716
3717 @Override
3718 public String toString() {
3719 StringBuilder sb = new StringBuilder("getMultiple_args(");
3720 boolean first = true;
3721
3722 sb.append("table:");
3723 if (this.table == null) {
3724 sb.append("null");
3725 } else {
3726 org.apache.thrift.TBaseHelper.toString(this.table, sb);
3727 }
3728 first = false;
3729 if (!first) sb.append(", ");
3730 sb.append("gets:");
3731 if (this.gets == null) {
3732 sb.append("null");
3733 } else {
3734 sb.append(this.gets);
3735 }
3736 first = false;
3737 sb.append(")");
3738 return sb.toString();
3739 }
3740
3741 public void validate() throws org.apache.thrift.TException {
3742
3743 if (table == null) {
3744 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
3745 }
3746 if (gets == null) {
3747 throw new org.apache.thrift.protocol.TProtocolException("Required field 'gets' was not present! Struct: " + toString());
3748 }
3749 }
3750
3751 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3752 try {
3753 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3754 } catch (org.apache.thrift.TException te) {
3755 throw new java.io.IOException(te);
3756 }
3757 }
3758
3759 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3760 try {
3761 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3762 } catch (org.apache.thrift.TException te) {
3763 throw new java.io.IOException(te);
3764 }
3765 }
3766
3767 private static class getMultiple_argsStandardSchemeFactory implements SchemeFactory {
3768 public getMultiple_argsStandardScheme getScheme() {
3769 return new getMultiple_argsStandardScheme();
3770 }
3771 }
3772
3773 private static class getMultiple_argsStandardScheme extends StandardScheme<getMultiple_args> {
3774
3775 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_args struct) throws org.apache.thrift.TException {
3776 org.apache.thrift.protocol.TField schemeField;
3777 iprot.readStructBegin();
3778 while (true)
3779 {
3780 schemeField = iprot.readFieldBegin();
3781 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3782 break;
3783 }
3784 switch (schemeField.id) {
3785 case 1:
3786 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
3787 struct.table = iprot.readBinary();
3788 struct.setTableIsSet(true);
3789 } else {
3790 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3791 }
3792 break;
3793 case 2:
3794 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
3795 {
3796 org.apache.thrift.protocol.TList _list106 = iprot.readListBegin();
3797 struct.gets = new ArrayList<TGet>(_list106.size);
3798 for (int _i107 = 0; _i107 < _list106.size; ++_i107)
3799 {
3800 TGet _elem108;
3801 _elem108 = new TGet();
3802 _elem108.read(iprot);
3803 struct.gets.add(_elem108);
3804 }
3805 iprot.readListEnd();
3806 }
3807 struct.setGetsIsSet(true);
3808 } else {
3809 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3810 }
3811 break;
3812 default:
3813 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3814 }
3815 iprot.readFieldEnd();
3816 }
3817 iprot.readStructEnd();
3818
3819
3820 struct.validate();
3821 }
3822
3823 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_args struct) throws org.apache.thrift.TException {
3824 struct.validate();
3825
3826 oprot.writeStructBegin(STRUCT_DESC);
3827 if (struct.table != null) {
3828 oprot.writeFieldBegin(TABLE_FIELD_DESC);
3829 oprot.writeBinary(struct.table);
3830 oprot.writeFieldEnd();
3831 }
3832 if (struct.gets != null) {
3833 oprot.writeFieldBegin(GETS_FIELD_DESC);
3834 {
3835 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.gets.size()));
3836 for (TGet _iter109 : struct.gets)
3837 {
3838 _iter109.write(oprot);
3839 }
3840 oprot.writeListEnd();
3841 }
3842 oprot.writeFieldEnd();
3843 }
3844 oprot.writeFieldStop();
3845 oprot.writeStructEnd();
3846 }
3847
3848 }
3849
3850 private static class getMultiple_argsTupleSchemeFactory implements SchemeFactory {
3851 public getMultiple_argsTupleScheme getScheme() {
3852 return new getMultiple_argsTupleScheme();
3853 }
3854 }
3855
3856 private static class getMultiple_argsTupleScheme extends TupleScheme<getMultiple_args> {
3857
3858 @Override
3859 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3860 TTupleProtocol oprot = (TTupleProtocol) prot;
3861 oprot.writeBinary(struct.table);
3862 {
3863 oprot.writeI32(struct.gets.size());
3864 for (TGet _iter110 : struct.gets)
3865 {
3866 _iter110.write(oprot);
3867 }
3868 }
3869 }
3870
3871 @Override
3872 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3873 TTupleProtocol iprot = (TTupleProtocol) prot;
3874 struct.table = iprot.readBinary();
3875 struct.setTableIsSet(true);
3876 {
3877 org.apache.thrift.protocol.TList _list111 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
3878 struct.gets = new ArrayList<TGet>(_list111.size);
3879 for (int _i112 = 0; _i112 < _list111.size; ++_i112)
3880 {
3881 TGet _elem113;
3882 _elem113 = new TGet();
3883 _elem113.read(iprot);
3884 struct.gets.add(_elem113);
3885 }
3886 }
3887 struct.setGetsIsSet(true);
3888 }
3889 }
3890
3891 }
3892
3893 public static class getMultiple_result implements org.apache.thrift.TBase<getMultiple_result, getMultiple_result._Fields>, java.io.Serializable, Cloneable {
3894 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_result");
3895
3896 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);
3897 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);
3898
3899 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3900 static {
3901 schemes.put(StandardScheme.class, new getMultiple_resultStandardSchemeFactory());
3902 schemes.put(TupleScheme.class, new getMultiple_resultTupleSchemeFactory());
3903 }
3904
3905 public List<TResult> success;
3906 public TIOError io;
3907
3908
3909 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3910 SUCCESS((short)0, "success"),
3911 IO((short)1, "io");
3912
3913 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3914
3915 static {
3916 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3917 byName.put(field.getFieldName(), field);
3918 }
3919 }
3920
3921
3922
3923
3924 public static _Fields findByThriftId(int fieldId) {
3925 switch(fieldId) {
3926 case 0:
3927 return SUCCESS;
3928 case 1:
3929 return IO;
3930 default:
3931 return null;
3932 }
3933 }
3934
3935
3936
3937
3938
3939 public static _Fields findByThriftIdOrThrow(int fieldId) {
3940 _Fields fields = findByThriftId(fieldId);
3941 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3942 return fields;
3943 }
3944
3945
3946
3947
3948 public static _Fields findByName(String name) {
3949 return byName.get(name);
3950 }
3951
3952 private final short _thriftId;
3953 private final String _fieldName;
3954
3955 _Fields(short thriftId, String fieldName) {
3956 _thriftId = thriftId;
3957 _fieldName = fieldName;
3958 }
3959
3960 public short getThriftFieldId() {
3961 return _thriftId;
3962 }
3963
3964 public String getFieldName() {
3965 return _fieldName;
3966 }
3967 }
3968
3969
3970 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3971 static {
3972 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3973 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
3974 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
3975 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
3976 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
3977 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
3978 metaDataMap = Collections.unmodifiableMap(tmpMap);
3979 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_result.class, metaDataMap);
3980 }
3981
3982 public getMultiple_result() {
3983 }
3984
3985 public getMultiple_result(
3986 List<TResult> success,
3987 TIOError io)
3988 {
3989 this();
3990 this.success = success;
3991 this.io = io;
3992 }
3993
3994
3995
3996
3997 public getMultiple_result(getMultiple_result other) {
3998 if (other.isSetSuccess()) {
3999 List<TResult> __this__success = new ArrayList<TResult>();
4000 for (TResult other_element : other.success) {
4001 __this__success.add(new TResult(other_element));
4002 }
4003 this.success = __this__success;
4004 }
4005 if (other.isSetIo()) {
4006 this.io = new TIOError(other.io);
4007 }
4008 }
4009
4010 public getMultiple_result deepCopy() {
4011 return new getMultiple_result(this);
4012 }
4013
4014 @Override
4015 public void clear() {
4016 this.success = null;
4017 this.io = null;
4018 }
4019
4020 public int getSuccessSize() {
4021 return (this.success == null) ? 0 : this.success.size();
4022 }
4023
4024 public java.util.Iterator<TResult> getSuccessIterator() {
4025 return (this.success == null) ? null : this.success.iterator();
4026 }
4027
4028 public void addToSuccess(TResult elem) {
4029 if (this.success == null) {
4030 this.success = new ArrayList<TResult>();
4031 }
4032 this.success.add(elem);
4033 }
4034
4035 public List<TResult> getSuccess() {
4036 return this.success;
4037 }
4038
4039 public getMultiple_result setSuccess(List<TResult> success) {
4040 this.success = success;
4041 return this;
4042 }
4043
4044 public void unsetSuccess() {
4045 this.success = null;
4046 }
4047
4048
4049 public boolean isSetSuccess() {
4050 return this.success != null;
4051 }
4052
4053 public void setSuccessIsSet(boolean value) {
4054 if (!value) {
4055 this.success = null;
4056 }
4057 }
4058
4059 public TIOError getIo() {
4060 return this.io;
4061 }
4062
4063 public getMultiple_result setIo(TIOError io) {
4064 this.io = io;
4065 return this;
4066 }
4067
4068 public void unsetIo() {
4069 this.io = null;
4070 }
4071
4072
4073 public boolean isSetIo() {
4074 return this.io != null;
4075 }
4076
4077 public void setIoIsSet(boolean value) {
4078 if (!value) {
4079 this.io = null;
4080 }
4081 }
4082
4083 public void setFieldValue(_Fields field, Object value) {
4084 switch (field) {
4085 case SUCCESS:
4086 if (value == null) {
4087 unsetSuccess();
4088 } else {
4089 setSuccess((List<TResult>)value);
4090 }
4091 break;
4092
4093 case IO:
4094 if (value == null) {
4095 unsetIo();
4096 } else {
4097 setIo((TIOError)value);
4098 }
4099 break;
4100
4101 }
4102 }
4103
4104 public Object getFieldValue(_Fields field) {
4105 switch (field) {
4106 case SUCCESS:
4107 return getSuccess();
4108
4109 case IO:
4110 return getIo();
4111
4112 }
4113 throw new IllegalStateException();
4114 }
4115
4116
4117 public boolean isSet(_Fields field) {
4118 if (field == null) {
4119 throw new IllegalArgumentException();
4120 }
4121
4122 switch (field) {
4123 case SUCCESS:
4124 return isSetSuccess();
4125 case IO:
4126 return isSetIo();
4127 }
4128 throw new IllegalStateException();
4129 }
4130
4131 @Override
4132 public boolean equals(Object that) {
4133 if (that == null)
4134 return false;
4135 if (that instanceof getMultiple_result)
4136 return this.equals((getMultiple_result)that);
4137 return false;
4138 }
4139
4140 public boolean equals(getMultiple_result that) {
4141 if (that == null)
4142 return false;
4143
4144 boolean this_present_success = true && this.isSetSuccess();
4145 boolean that_present_success = true && that.isSetSuccess();
4146 if (this_present_success || that_present_success) {
4147 if (!(this_present_success && that_present_success))
4148 return false;
4149 if (!this.success.equals(that.success))
4150 return false;
4151 }
4152
4153 boolean this_present_io = true && this.isSetIo();
4154 boolean that_present_io = true && that.isSetIo();
4155 if (this_present_io || that_present_io) {
4156 if (!(this_present_io && that_present_io))
4157 return false;
4158 if (!this.io.equals(that.io))
4159 return false;
4160 }
4161
4162 return true;
4163 }
4164
4165 @Override
4166 public int hashCode() {
4167 return 0;
4168 }
4169
4170 public int compareTo(getMultiple_result other) {
4171 if (!getClass().equals(other.getClass())) {
4172 return getClass().getName().compareTo(other.getClass().getName());
4173 }
4174
4175 int lastComparison = 0;
4176 getMultiple_result typedOther = (getMultiple_result)other;
4177
4178 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
4179 if (lastComparison != 0) {
4180 return lastComparison;
4181 }
4182 if (isSetSuccess()) {
4183 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
4184 if (lastComparison != 0) {
4185 return lastComparison;
4186 }
4187 }
4188 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
4189 if (lastComparison != 0) {
4190 return lastComparison;
4191 }
4192 if (isSetIo()) {
4193 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
4194 if (lastComparison != 0) {
4195 return lastComparison;
4196 }
4197 }
4198 return 0;
4199 }
4200
4201 public _Fields fieldForId(int fieldId) {
4202 return _Fields.findByThriftId(fieldId);
4203 }
4204
4205 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4206 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4207 }
4208
4209 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4210 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4211 }
4212
4213 @Override
4214 public String toString() {
4215 StringBuilder sb = new StringBuilder("getMultiple_result(");
4216 boolean first = true;
4217
4218 sb.append("success:");
4219 if (this.success == null) {
4220 sb.append("null");
4221 } else {
4222 sb.append(this.success);
4223 }
4224 first = false;
4225 if (!first) sb.append(", ");
4226 sb.append("io:");
4227 if (this.io == null) {
4228 sb.append("null");
4229 } else {
4230 sb.append(this.io);
4231 }
4232 first = false;
4233 sb.append(")");
4234 return sb.toString();
4235 }
4236
4237 public void validate() throws org.apache.thrift.TException {
4238
4239 }
4240
4241 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4242 try {
4243 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4244 } catch (org.apache.thrift.TException te) {
4245 throw new java.io.IOException(te);
4246 }
4247 }
4248
4249 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4250 try {
4251 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4252 } catch (org.apache.thrift.TException te) {
4253 throw new java.io.IOException(te);
4254 }
4255 }
4256
4257 private static class getMultiple_resultStandardSchemeFactory implements SchemeFactory {
4258 public getMultiple_resultStandardScheme getScheme() {
4259 return new getMultiple_resultStandardScheme();
4260 }
4261 }
4262
4263 private static class getMultiple_resultStandardScheme extends StandardScheme<getMultiple_result> {
4264
4265 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_result struct) throws org.apache.thrift.TException {
4266 org.apache.thrift.protocol.TField schemeField;
4267 iprot.readStructBegin();
4268 while (true)
4269 {
4270 schemeField = iprot.readFieldBegin();
4271 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4272 break;
4273 }
4274 switch (schemeField.id) {
4275 case 0:
4276 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
4277 {
4278 org.apache.thrift.protocol.TList _list114 = iprot.readListBegin();
4279 struct.success = new ArrayList<TResult>(_list114.size);
4280 for (int _i115 = 0; _i115 < _list114.size; ++_i115)
4281 {
4282 TResult _elem116;
4283 _elem116 = new TResult();
4284 _elem116.read(iprot);
4285 struct.success.add(_elem116);
4286 }
4287 iprot.readListEnd();
4288 }
4289 struct.setSuccessIsSet(true);
4290 } else {
4291 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4292 }
4293 break;
4294 case 1:
4295 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4296 struct.io = new TIOError();
4297 struct.io.read(iprot);
4298 struct.setIoIsSet(true);
4299 } else {
4300 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4301 }
4302 break;
4303 default:
4304 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4305 }
4306 iprot.readFieldEnd();
4307 }
4308 iprot.readStructEnd();
4309
4310
4311 struct.validate();
4312 }
4313
4314 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_result struct) throws org.apache.thrift.TException {
4315 struct.validate();
4316
4317 oprot.writeStructBegin(STRUCT_DESC);
4318 if (struct.success != null) {
4319 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4320 {
4321 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
4322 for (TResult _iter117 : struct.success)
4323 {
4324 _iter117.write(oprot);
4325 }
4326 oprot.writeListEnd();
4327 }
4328 oprot.writeFieldEnd();
4329 }
4330 if (struct.io != null) {
4331 oprot.writeFieldBegin(IO_FIELD_DESC);
4332 struct.io.write(oprot);
4333 oprot.writeFieldEnd();
4334 }
4335 oprot.writeFieldStop();
4336 oprot.writeStructEnd();
4337 }
4338
4339 }
4340
4341 private static class getMultiple_resultTupleSchemeFactory implements SchemeFactory {
4342 public getMultiple_resultTupleScheme getScheme() {
4343 return new getMultiple_resultTupleScheme();
4344 }
4345 }
4346
4347 private static class getMultiple_resultTupleScheme extends TupleScheme<getMultiple_result> {
4348
4349 @Override
4350 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4351 TTupleProtocol oprot = (TTupleProtocol) prot;
4352 BitSet optionals = new BitSet();
4353 if (struct.isSetSuccess()) {
4354 optionals.set(0);
4355 }
4356 if (struct.isSetIo()) {
4357 optionals.set(1);
4358 }
4359 oprot.writeBitSet(optionals, 2);
4360 if (struct.isSetSuccess()) {
4361 {
4362 oprot.writeI32(struct.success.size());
4363 for (TResult _iter118 : struct.success)
4364 {
4365 _iter118.write(oprot);
4366 }
4367 }
4368 }
4369 if (struct.isSetIo()) {
4370 struct.io.write(oprot);
4371 }
4372 }
4373
4374 @Override
4375 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4376 TTupleProtocol iprot = (TTupleProtocol) prot;
4377 BitSet incoming = iprot.readBitSet(2);
4378 if (incoming.get(0)) {
4379 {
4380 org.apache.thrift.protocol.TList _list119 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
4381 struct.success = new ArrayList<TResult>(_list119.size);
4382 for (int _i120 = 0; _i120 < _list119.size; ++_i120)
4383 {
4384 TResult _elem121;
4385 _elem121 = new TResult();
4386 _elem121.read(iprot);
4387 struct.success.add(_elem121);
4388 }
4389 }
4390 struct.setSuccessIsSet(true);
4391 }
4392 if (incoming.get(1)) {
4393 struct.io = new TIOError();
4394 struct.io.read(iprot);
4395 struct.setIoIsSet(true);
4396 }
4397 }
4398 }
4399
4400 }
4401
4402 public static class put_args implements org.apache.thrift.TBase<put_args, put_args._Fields>, java.io.Serializable, Cloneable {
4403 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_args");
4404
4405 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);
4406 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);
4407
4408 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4409 static {
4410 schemes.put(StandardScheme.class, new put_argsStandardSchemeFactory());
4411 schemes.put(TupleScheme.class, new put_argsTupleSchemeFactory());
4412 }
4413
4414
4415
4416
4417 public ByteBuffer table;
4418
4419
4420
4421 public TPut put;
4422
4423
4424 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4425
4426
4427
4428 TABLE((short)1, "table"),
4429
4430
4431
4432 PUT((short)2, "put");
4433
4434 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4435
4436 static {
4437 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4438 byName.put(field.getFieldName(), field);
4439 }
4440 }
4441
4442
4443
4444
4445 public static _Fields findByThriftId(int fieldId) {
4446 switch(fieldId) {
4447 case 1:
4448 return TABLE;
4449 case 2:
4450 return PUT;
4451 default:
4452 return null;
4453 }
4454 }
4455
4456
4457
4458
4459
4460 public static _Fields findByThriftIdOrThrow(int fieldId) {
4461 _Fields fields = findByThriftId(fieldId);
4462 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4463 return fields;
4464 }
4465
4466
4467
4468
4469 public static _Fields findByName(String name) {
4470 return byName.get(name);
4471 }
4472
4473 private final short _thriftId;
4474 private final String _fieldName;
4475
4476 _Fields(short thriftId, String fieldName) {
4477 _thriftId = thriftId;
4478 _fieldName = fieldName;
4479 }
4480
4481 public short getThriftFieldId() {
4482 return _thriftId;
4483 }
4484
4485 public String getFieldName() {
4486 return _fieldName;
4487 }
4488 }
4489
4490
4491 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4492 static {
4493 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4494 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
4495 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
4496 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
4497 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
4498 metaDataMap = Collections.unmodifiableMap(tmpMap);
4499 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_args.class, metaDataMap);
4500 }
4501
4502 public put_args() {
4503 }
4504
4505 public put_args(
4506 ByteBuffer table,
4507 TPut put)
4508 {
4509 this();
4510 this.table = table;
4511 this.put = put;
4512 }
4513
4514
4515
4516
4517 public put_args(put_args other) {
4518 if (other.isSetTable()) {
4519 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
4520 ;
4521 }
4522 if (other.isSetPut()) {
4523 this.put = new TPut(other.put);
4524 }
4525 }
4526
4527 public put_args deepCopy() {
4528 return new put_args(this);
4529 }
4530
4531 @Override
4532 public void clear() {
4533 this.table = null;
4534 this.put = null;
4535 }
4536
4537
4538
4539
4540 public byte[] getTable() {
4541 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
4542 return table == null ? null : table.array();
4543 }
4544
4545 public ByteBuffer bufferForTable() {
4546 return table;
4547 }
4548
4549
4550
4551
4552 public put_args setTable(byte[] table) {
4553 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
4554 return this;
4555 }
4556
4557 public put_args setTable(ByteBuffer table) {
4558 this.table = table;
4559 return this;
4560 }
4561
4562 public void unsetTable() {
4563 this.table = null;
4564 }
4565
4566
4567 public boolean isSetTable() {
4568 return this.table != null;
4569 }
4570
4571 public void setTableIsSet(boolean value) {
4572 if (!value) {
4573 this.table = null;
4574 }
4575 }
4576
4577
4578
4579
4580 public TPut getPut() {
4581 return this.put;
4582 }
4583
4584
4585
4586
4587 public put_args setPut(TPut put) {
4588 this.put = put;
4589 return this;
4590 }
4591
4592 public void unsetPut() {
4593 this.put = null;
4594 }
4595
4596
4597 public boolean isSetPut() {
4598 return this.put != null;
4599 }
4600
4601 public void setPutIsSet(boolean value) {
4602 if (!value) {
4603 this.put = null;
4604 }
4605 }
4606
4607 public void setFieldValue(_Fields field, Object value) {
4608 switch (field) {
4609 case TABLE:
4610 if (value == null) {
4611 unsetTable();
4612 } else {
4613 setTable((ByteBuffer)value);
4614 }
4615 break;
4616
4617 case PUT:
4618 if (value == null) {
4619 unsetPut();
4620 } else {
4621 setPut((TPut)value);
4622 }
4623 break;
4624
4625 }
4626 }
4627
4628 public Object getFieldValue(_Fields field) {
4629 switch (field) {
4630 case TABLE:
4631 return getTable();
4632
4633 case PUT:
4634 return getPut();
4635
4636 }
4637 throw new IllegalStateException();
4638 }
4639
4640
4641 public boolean isSet(_Fields field) {
4642 if (field == null) {
4643 throw new IllegalArgumentException();
4644 }
4645
4646 switch (field) {
4647 case TABLE:
4648 return isSetTable();
4649 case PUT:
4650 return isSetPut();
4651 }
4652 throw new IllegalStateException();
4653 }
4654
4655 @Override
4656 public boolean equals(Object that) {
4657 if (that == null)
4658 return false;
4659 if (that instanceof put_args)
4660 return this.equals((put_args)that);
4661 return false;
4662 }
4663
4664 public boolean equals(put_args that) {
4665 if (that == null)
4666 return false;
4667
4668 boolean this_present_table = true && this.isSetTable();
4669 boolean that_present_table = true && that.isSetTable();
4670 if (this_present_table || that_present_table) {
4671 if (!(this_present_table && that_present_table))
4672 return false;
4673 if (!this.table.equals(that.table))
4674 return false;
4675 }
4676
4677 boolean this_present_put = true && this.isSetPut();
4678 boolean that_present_put = true && that.isSetPut();
4679 if (this_present_put || that_present_put) {
4680 if (!(this_present_put && that_present_put))
4681 return false;
4682 if (!this.put.equals(that.put))
4683 return false;
4684 }
4685
4686 return true;
4687 }
4688
4689 @Override
4690 public int hashCode() {
4691 return 0;
4692 }
4693
4694 public int compareTo(put_args other) {
4695 if (!getClass().equals(other.getClass())) {
4696 return getClass().getName().compareTo(other.getClass().getName());
4697 }
4698
4699 int lastComparison = 0;
4700 put_args typedOther = (put_args)other;
4701
4702 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
4703 if (lastComparison != 0) {
4704 return lastComparison;
4705 }
4706 if (isSetTable()) {
4707 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
4708 if (lastComparison != 0) {
4709 return lastComparison;
4710 }
4711 }
4712 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
4713 if (lastComparison != 0) {
4714 return lastComparison;
4715 }
4716 if (isSetPut()) {
4717 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
4718 if (lastComparison != 0) {
4719 return lastComparison;
4720 }
4721 }
4722 return 0;
4723 }
4724
4725 public _Fields fieldForId(int fieldId) {
4726 return _Fields.findByThriftId(fieldId);
4727 }
4728
4729 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4730 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4731 }
4732
4733 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4734 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4735 }
4736
4737 @Override
4738 public String toString() {
4739 StringBuilder sb = new StringBuilder("put_args(");
4740 boolean first = true;
4741
4742 sb.append("table:");
4743 if (this.table == null) {
4744 sb.append("null");
4745 } else {
4746 org.apache.thrift.TBaseHelper.toString(this.table, sb);
4747 }
4748 first = false;
4749 if (!first) sb.append(", ");
4750 sb.append("put:");
4751 if (this.put == null) {
4752 sb.append("null");
4753 } else {
4754 sb.append(this.put);
4755 }
4756 first = false;
4757 sb.append(")");
4758 return sb.toString();
4759 }
4760
4761 public void validate() throws org.apache.thrift.TException {
4762
4763 if (table == null) {
4764 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
4765 }
4766 if (put == null) {
4767 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
4768 }
4769 }
4770
4771 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4772 try {
4773 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4774 } catch (org.apache.thrift.TException te) {
4775 throw new java.io.IOException(te);
4776 }
4777 }
4778
4779 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4780 try {
4781 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4782 } catch (org.apache.thrift.TException te) {
4783 throw new java.io.IOException(te);
4784 }
4785 }
4786
4787 private static class put_argsStandardSchemeFactory implements SchemeFactory {
4788 public put_argsStandardScheme getScheme() {
4789 return new put_argsStandardScheme();
4790 }
4791 }
4792
4793 private static class put_argsStandardScheme extends StandardScheme<put_args> {
4794
4795 public void read(org.apache.thrift.protocol.TProtocol iprot, put_args struct) throws org.apache.thrift.TException {
4796 org.apache.thrift.protocol.TField schemeField;
4797 iprot.readStructBegin();
4798 while (true)
4799 {
4800 schemeField = iprot.readFieldBegin();
4801 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4802 break;
4803 }
4804 switch (schemeField.id) {
4805 case 1:
4806 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
4807 struct.table = iprot.readBinary();
4808 struct.setTableIsSet(true);
4809 } else {
4810 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4811 }
4812 break;
4813 case 2:
4814 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4815 struct.put = new TPut();
4816 struct.put.read(iprot);
4817 struct.setPutIsSet(true);
4818 } else {
4819 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4820 }
4821 break;
4822 default:
4823 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4824 }
4825 iprot.readFieldEnd();
4826 }
4827 iprot.readStructEnd();
4828
4829
4830 struct.validate();
4831 }
4832
4833 public void write(org.apache.thrift.protocol.TProtocol oprot, put_args struct) throws org.apache.thrift.TException {
4834 struct.validate();
4835
4836 oprot.writeStructBegin(STRUCT_DESC);
4837 if (struct.table != null) {
4838 oprot.writeFieldBegin(TABLE_FIELD_DESC);
4839 oprot.writeBinary(struct.table);
4840 oprot.writeFieldEnd();
4841 }
4842 if (struct.put != null) {
4843 oprot.writeFieldBegin(PUT_FIELD_DESC);
4844 struct.put.write(oprot);
4845 oprot.writeFieldEnd();
4846 }
4847 oprot.writeFieldStop();
4848 oprot.writeStructEnd();
4849 }
4850
4851 }
4852
4853 private static class put_argsTupleSchemeFactory implements SchemeFactory {
4854 public put_argsTupleScheme getScheme() {
4855 return new put_argsTupleScheme();
4856 }
4857 }
4858
4859 private static class put_argsTupleScheme extends TupleScheme<put_args> {
4860
4861 @Override
4862 public void write(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4863 TTupleProtocol oprot = (TTupleProtocol) prot;
4864 oprot.writeBinary(struct.table);
4865 struct.put.write(oprot);
4866 }
4867
4868 @Override
4869 public void read(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4870 TTupleProtocol iprot = (TTupleProtocol) prot;
4871 struct.table = iprot.readBinary();
4872 struct.setTableIsSet(true);
4873 struct.put = new TPut();
4874 struct.put.read(iprot);
4875 struct.setPutIsSet(true);
4876 }
4877 }
4878
4879 }
4880
4881 public static class put_result implements org.apache.thrift.TBase<put_result, put_result._Fields>, java.io.Serializable, Cloneable {
4882 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_result");
4883
4884 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);
4885
4886 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4887 static {
4888 schemes.put(StandardScheme.class, new put_resultStandardSchemeFactory());
4889 schemes.put(TupleScheme.class, new put_resultTupleSchemeFactory());
4890 }
4891
4892 public TIOError io;
4893
4894
4895 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4896 IO((short)1, "io");
4897
4898 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4899
4900 static {
4901 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4902 byName.put(field.getFieldName(), field);
4903 }
4904 }
4905
4906
4907
4908
4909 public static _Fields findByThriftId(int fieldId) {
4910 switch(fieldId) {
4911 case 1:
4912 return IO;
4913 default:
4914 return null;
4915 }
4916 }
4917
4918
4919
4920
4921
4922 public static _Fields findByThriftIdOrThrow(int fieldId) {
4923 _Fields fields = findByThriftId(fieldId);
4924 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4925 return fields;
4926 }
4927
4928
4929
4930
4931 public static _Fields findByName(String name) {
4932 return byName.get(name);
4933 }
4934
4935 private final short _thriftId;
4936 private final String _fieldName;
4937
4938 _Fields(short thriftId, String fieldName) {
4939 _thriftId = thriftId;
4940 _fieldName = fieldName;
4941 }
4942
4943 public short getThriftFieldId() {
4944 return _thriftId;
4945 }
4946
4947 public String getFieldName() {
4948 return _fieldName;
4949 }
4950 }
4951
4952
4953 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4954 static {
4955 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4956 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
4957 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
4958 metaDataMap = Collections.unmodifiableMap(tmpMap);
4959 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_result.class, metaDataMap);
4960 }
4961
4962 public put_result() {
4963 }
4964
4965 public put_result(
4966 TIOError io)
4967 {
4968 this();
4969 this.io = io;
4970 }
4971
4972
4973
4974
4975 public put_result(put_result other) {
4976 if (other.isSetIo()) {
4977 this.io = new TIOError(other.io);
4978 }
4979 }
4980
4981 public put_result deepCopy() {
4982 return new put_result(this);
4983 }
4984
4985 @Override
4986 public void clear() {
4987 this.io = null;
4988 }
4989
4990 public TIOError getIo() {
4991 return this.io;
4992 }
4993
4994 public put_result setIo(TIOError io) {
4995 this.io = io;
4996 return this;
4997 }
4998
4999 public void unsetIo() {
5000 this.io = null;
5001 }
5002
5003
5004 public boolean isSetIo() {
5005 return this.io != null;
5006 }
5007
5008 public void setIoIsSet(boolean value) {
5009 if (!value) {
5010 this.io = null;
5011 }
5012 }
5013
5014 public void setFieldValue(_Fields field, Object value) {
5015 switch (field) {
5016 case IO:
5017 if (value == null) {
5018 unsetIo();
5019 } else {
5020 setIo((TIOError)value);
5021 }
5022 break;
5023
5024 }
5025 }
5026
5027 public Object getFieldValue(_Fields field) {
5028 switch (field) {
5029 case IO:
5030 return getIo();
5031
5032 }
5033 throw new IllegalStateException();
5034 }
5035
5036
5037 public boolean isSet(_Fields field) {
5038 if (field == null) {
5039 throw new IllegalArgumentException();
5040 }
5041
5042 switch (field) {
5043 case IO:
5044 return isSetIo();
5045 }
5046 throw new IllegalStateException();
5047 }
5048
5049 @Override
5050 public boolean equals(Object that) {
5051 if (that == null)
5052 return false;
5053 if (that instanceof put_result)
5054 return this.equals((put_result)that);
5055 return false;
5056 }
5057
5058 public boolean equals(put_result that) {
5059 if (that == null)
5060 return false;
5061
5062 boolean this_present_io = true && this.isSetIo();
5063 boolean that_present_io = true && that.isSetIo();
5064 if (this_present_io || that_present_io) {
5065 if (!(this_present_io && that_present_io))
5066 return false;
5067 if (!this.io.equals(that.io))
5068 return false;
5069 }
5070
5071 return true;
5072 }
5073
5074 @Override
5075 public int hashCode() {
5076 return 0;
5077 }
5078
5079 public int compareTo(put_result other) {
5080 if (!getClass().equals(other.getClass())) {
5081 return getClass().getName().compareTo(other.getClass().getName());
5082 }
5083
5084 int lastComparison = 0;
5085 put_result typedOther = (put_result)other;
5086
5087 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
5088 if (lastComparison != 0) {
5089 return lastComparison;
5090 }
5091 if (isSetIo()) {
5092 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
5093 if (lastComparison != 0) {
5094 return lastComparison;
5095 }
5096 }
5097 return 0;
5098 }
5099
5100 public _Fields fieldForId(int fieldId) {
5101 return _Fields.findByThriftId(fieldId);
5102 }
5103
5104 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
5105 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
5106 }
5107
5108 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
5109 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
5110 }
5111
5112 @Override
5113 public String toString() {
5114 StringBuilder sb = new StringBuilder("put_result(");
5115 boolean first = true;
5116
5117 sb.append("io:");
5118 if (this.io == null) {
5119 sb.append("null");
5120 } else {
5121 sb.append(this.io);
5122 }
5123 first = false;
5124 sb.append(")");
5125 return sb.toString();
5126 }
5127
5128 public void validate() throws org.apache.thrift.TException {
5129
5130 }
5131
5132 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
5133 try {
5134 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
5135 } catch (org.apache.thrift.TException te) {
5136 throw new java.io.IOException(te);
5137 }
5138 }
5139
5140 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
5141 try {
5142 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
5143 } catch (org.apache.thrift.TException te) {
5144 throw new java.io.IOException(te);
5145 }
5146 }
5147
5148 private static class put_resultStandardSchemeFactory implements SchemeFactory {
5149 public put_resultStandardScheme getScheme() {
5150 return new put_resultStandardScheme();
5151 }
5152 }
5153
5154 private static class put_resultStandardScheme extends StandardScheme<put_result> {
5155
5156 public void read(org.apache.thrift.protocol.TProtocol iprot, put_result struct) throws org.apache.thrift.TException {
5157 org.apache.thrift.protocol.TField schemeField;
5158 iprot.readStructBegin();
5159 while (true)
5160 {
5161 schemeField = iprot.readFieldBegin();
5162 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
5163 break;
5164 }
5165 switch (schemeField.id) {
5166 case 1:
5167 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
5168 struct.io = new TIOError();
5169 struct.io.read(iprot);
5170 struct.setIoIsSet(true);
5171 } else {
5172 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5173 }
5174 break;
5175 default:
5176 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5177 }
5178 iprot.readFieldEnd();
5179 }
5180 iprot.readStructEnd();
5181
5182
5183 struct.validate();
5184 }
5185
5186 public void write(org.apache.thrift.protocol.TProtocol oprot, put_result struct) throws org.apache.thrift.TException {
5187 struct.validate();
5188
5189 oprot.writeStructBegin(STRUCT_DESC);
5190 if (struct.io != null) {
5191 oprot.writeFieldBegin(IO_FIELD_DESC);
5192 struct.io.write(oprot);
5193 oprot.writeFieldEnd();
5194 }
5195 oprot.writeFieldStop();
5196 oprot.writeStructEnd();
5197 }
5198
5199 }
5200
5201 private static class put_resultTupleSchemeFactory implements SchemeFactory {
5202 public put_resultTupleScheme getScheme() {
5203 return new put_resultTupleScheme();
5204 }
5205 }
5206
5207 private static class put_resultTupleScheme extends TupleScheme<put_result> {
5208
5209 @Override
5210 public void write(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5211 TTupleProtocol oprot = (TTupleProtocol) prot;
5212 BitSet optionals = new BitSet();
5213 if (struct.isSetIo()) {
5214 optionals.set(0);
5215 }
5216 oprot.writeBitSet(optionals, 1);
5217 if (struct.isSetIo()) {
5218 struct.io.write(oprot);
5219 }
5220 }
5221
5222 @Override
5223 public void read(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5224 TTupleProtocol iprot = (TTupleProtocol) prot;
5225 BitSet incoming = iprot.readBitSet(1);
5226 if (incoming.get(0)) {
5227 struct.io = new TIOError();
5228 struct.io.read(iprot);
5229 struct.setIoIsSet(true);
5230 }
5231 }
5232 }
5233
5234 }
5235
5236 public static class checkAndPut_args implements org.apache.thrift.TBase<checkAndPut_args, checkAndPut_args._Fields>, java.io.Serializable, Cloneable {
5237 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_args");
5238
5239 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);
5240 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);
5241 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);
5242 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);
5243 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);
5244 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);
5245
5246 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
5247 static {
5248 schemes.put(StandardScheme.class, new checkAndPut_argsStandardSchemeFactory());
5249 schemes.put(TupleScheme.class, new checkAndPut_argsTupleSchemeFactory());
5250 }
5251
5252
5253
5254
5255 public ByteBuffer table;
5256
5257
5258
5259 public ByteBuffer row;
5260
5261
5262
5263 public ByteBuffer family;
5264
5265
5266
5267 public ByteBuffer qualifier;
5268
5269
5270
5271
5272
5273 public ByteBuffer value;
5274
5275
5276
5277 public TPut put;
5278
5279
5280 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
5281
5282
5283
5284 TABLE((short)1, "table"),
5285
5286
5287
5288 ROW((short)2, "row"),
5289
5290
5291
5292 FAMILY((short)3, "family"),
5293
5294
5295
5296 QUALIFIER((short)4, "qualifier"),
5297
5298
5299
5300
5301
5302 VALUE((short)5, "value"),
5303
5304
5305
5306 PUT((short)6, "put");
5307
5308 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5309
5310 static {
5311 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5312 byName.put(field.getFieldName(), field);
5313 }
5314 }
5315
5316
5317
5318
5319 public static _Fields findByThriftId(int fieldId) {
5320 switch(fieldId) {
5321 case 1:
5322 return TABLE;
5323 case 2:
5324 return ROW;
5325 case 3:
5326 return FAMILY;
5327 case 4:
5328 return QUALIFIER;
5329 case 5:
5330 return VALUE;
5331 case 6:
5332 return PUT;
5333 default:
5334 return null;
5335 }
5336 }
5337
5338
5339
5340
5341
5342 public static _Fields findByThriftIdOrThrow(int fieldId) {
5343 _Fields fields = findByThriftId(fieldId);
5344 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5345 return fields;
5346 }
5347
5348
5349
5350
5351 public static _Fields findByName(String name) {
5352 return byName.get(name);
5353 }
5354
5355 private final short _thriftId;
5356 private final String _fieldName;
5357
5358 _Fields(short thriftId, String fieldName) {
5359 _thriftId = thriftId;
5360 _fieldName = fieldName;
5361 }
5362
5363 public short getThriftFieldId() {
5364 return _thriftId;
5365 }
5366
5367 public String getFieldName() {
5368 return _fieldName;
5369 }
5370 }
5371
5372
5373 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
5374 static {
5375 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
5376 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
5377 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5378 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
5379 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5380 tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
5381 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5382 tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
5383 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5384 tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT,
5385 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5386 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
5387 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
5388 metaDataMap = Collections.unmodifiableMap(tmpMap);
5389 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_args.class, metaDataMap);
5390 }
5391
5392 public checkAndPut_args() {
5393 }
5394
5395 public checkAndPut_args(
5396 ByteBuffer table,
5397 ByteBuffer row,
5398 ByteBuffer family,
5399 ByteBuffer qualifier,
5400 ByteBuffer value,
5401 TPut put)
5402 {
5403 this();
5404 this.table = table;
5405 this.row = row;
5406 this.family = family;
5407 this.qualifier = qualifier;
5408 this.value = value;
5409 this.put = put;
5410 }
5411
5412
5413
5414
5415 public checkAndPut_args(checkAndPut_args other) {
5416 if (other.isSetTable()) {
5417 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
5418 ;
5419 }
5420 if (other.isSetRow()) {
5421 this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
5422 ;
5423 }
5424 if (other.isSetFamily()) {
5425 this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
5426 ;
5427 }
5428 if (other.isSetQualifier()) {
5429 this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
5430 ;
5431 }
5432 if (other.isSetValue()) {
5433 this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
5434 ;
5435 }
5436 if (other.isSetPut()) {
5437 this.put = new TPut(other.put);
5438 }
5439 }
5440
5441 public checkAndPut_args deepCopy() {
5442 return new checkAndPut_args(this);
5443 }
5444
5445 @Override
5446 public void clear() {
5447 this.table = null;
5448 this.row = null;
5449 this.family = null;
5450 this.qualifier = null;
5451 this.value = null;
5452 this.put = null;
5453 }
5454
5455
5456
5457
5458 public byte[] getTable() {
5459 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
5460 return table == null ? null : table.array();
5461 }
5462
5463 public ByteBuffer bufferForTable() {
5464 return table;
5465 }
5466
5467
5468
5469
5470 public checkAndPut_args setTable(byte[] table) {
5471 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
5472 return this;
5473 }
5474
5475 public checkAndPut_args setTable(ByteBuffer table) {
5476 this.table = table;
5477 return this;
5478 }
5479
5480 public void unsetTable() {
5481 this.table = null;
5482 }
5483
5484
5485 public boolean isSetTable() {
5486 return this.table != null;
5487 }
5488
5489 public void setTableIsSet(boolean value) {
5490 if (!value) {
5491 this.table = null;
5492 }
5493 }
5494
5495
5496
5497
5498 public byte[] getRow() {
5499 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
5500 return row == null ? null : row.array();
5501 }
5502
5503 public ByteBuffer bufferForRow() {
5504 return row;
5505 }
5506
5507
5508
5509
5510 public checkAndPut_args setRow(byte[] row) {
5511 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
5512 return this;
5513 }
5514
5515 public checkAndPut_args setRow(ByteBuffer row) {
5516 this.row = row;
5517 return this;
5518 }
5519
5520 public void unsetRow() {
5521 this.row = null;
5522 }
5523
5524
5525 public boolean isSetRow() {
5526 return this.row != null;
5527 }
5528
5529 public void setRowIsSet(boolean value) {
5530 if (!value) {
5531 this.row = null;
5532 }
5533 }
5534
5535
5536
5537
5538 public byte[] getFamily() {
5539 setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
5540 return family == null ? null : family.array();
5541 }
5542
5543 public ByteBuffer bufferForFamily() {
5544 return family;
5545 }
5546
5547
5548
5549
5550 public checkAndPut_args setFamily(byte[] family) {
5551 setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
5552 return this;
5553 }
5554
5555 public checkAndPut_args setFamily(ByteBuffer family) {
5556 this.family = family;
5557 return this;
5558 }
5559
5560 public void unsetFamily() {
5561 this.family = null;
5562 }
5563
5564
5565 public boolean isSetFamily() {
5566 return this.family != null;
5567 }
5568
5569 public void setFamilyIsSet(boolean value) {
5570 if (!value) {
5571 this.family = null;
5572 }
5573 }
5574
5575
5576
5577
5578 public byte[] getQualifier() {
5579 setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
5580 return qualifier == null ? null : qualifier.array();
5581 }
5582
5583 public ByteBuffer bufferForQualifier() {
5584 return qualifier;
5585 }
5586
5587
5588
5589
5590 public checkAndPut_args setQualifier(byte[] qualifier) {
5591 setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
5592 return this;
5593 }
5594
5595 public checkAndPut_args setQualifier(ByteBuffer qualifier) {
5596 this.qualifier = qualifier;
5597 return this;
5598 }
5599
5600 public void unsetQualifier() {
5601 this.qualifier = null;
5602 }
5603
5604
5605 public boolean isSetQualifier() {
5606 return this.qualifier != null;
5607 }
5608
5609 public void setQualifierIsSet(boolean value) {
5610 if (!value) {
5611 this.qualifier = null;
5612 }
5613 }
5614
5615
5616
5617
5618
5619
5620 public byte[] getValue() {
5621 setValue(org.apache.thrift.TBaseHelper.rightSize(value));
5622 return value == null ? null : value.array();
5623 }
5624
5625 public ByteBuffer bufferForValue() {
5626 return value;
5627 }
5628
5629
5630
5631
5632
5633
5634 public checkAndPut_args setValue(byte[] value) {
5635 setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
5636 return this;
5637 }
5638
5639 public checkAndPut_args setValue(ByteBuffer value) {
5640 this.value = value;
5641 return this;
5642 }
5643
5644 public void unsetValue() {
5645 this.value = null;
5646 }
5647
5648
5649 public boolean isSetValue() {
5650 return this.value != null;
5651 }
5652
5653 public void setValueIsSet(boolean value) {
5654 if (!value) {
5655 this.value = null;
5656 }
5657 }
5658
5659
5660
5661
5662 public TPut getPut() {
5663 return this.put;
5664 }
5665
5666
5667
5668
5669 public checkAndPut_args setPut(TPut put) {
5670 this.put = put;
5671 return this;
5672 }
5673
5674 public void unsetPut() {
5675 this.put = null;
5676 }
5677
5678
5679 public boolean isSetPut() {
5680 return this.put != null;
5681 }
5682
5683 public void setPutIsSet(boolean value) {
5684 if (!value) {
5685 this.put = null;
5686 }
5687 }
5688
5689 public void setFieldValue(_Fields field, Object value) {
5690 switch (field) {
5691 case TABLE:
5692 if (value == null) {
5693 unsetTable();
5694 } else {
5695 setTable((ByteBuffer)value);
5696 }
5697 break;
5698
5699 case ROW:
5700 if (value == null) {
5701 unsetRow();
5702 } else {
5703 setRow((ByteBuffer)value);
5704 }
5705 break;
5706
5707 case FAMILY:
5708 if (value == null) {
5709 unsetFamily();
5710 } else {
5711 setFamily((ByteBuffer)value);
5712 }
5713 break;
5714
5715 case QUALIFIER:
5716 if (value == null) {
5717 unsetQualifier();
5718 } else {
5719 setQualifier((ByteBuffer)value);
5720 }
5721 break;
5722
5723 case VALUE:
5724 if (value == null) {
5725 unsetValue();
5726 } else {
5727 setValue((ByteBuffer)value);
5728 }
5729 break;
5730
5731 case PUT:
5732 if (value == null) {
5733 unsetPut();
5734 } else {
5735 setPut((TPut)value);
5736 }
5737 break;
5738
5739 }
5740 }
5741
5742 public Object getFieldValue(_Fields field) {
5743 switch (field) {
5744 case TABLE:
5745 return getTable();
5746
5747 case ROW:
5748 return getRow();
5749
5750 case FAMILY:
5751 return getFamily();
5752
5753 case QUALIFIER:
5754 return getQualifier();
5755
5756 case VALUE:
5757 return getValue();
5758
5759 case PUT:
5760 return getPut();
5761
5762 }
5763 throw new IllegalStateException();
5764 }
5765
5766
5767 public boolean isSet(_Fields field) {
5768 if (field == null) {
5769 throw new IllegalArgumentException();
5770 }
5771
5772 switch (field) {
5773 case TABLE:
5774 return isSetTable();
5775 case ROW:
5776 return isSetRow();
5777 case FAMILY:
5778 return isSetFamily();
5779 case QUALIFIER:
5780 return isSetQualifier();
5781 case VALUE:
5782 return isSetValue();
5783 case PUT:
5784 return isSetPut();
5785 }
5786 throw new IllegalStateException();
5787 }
5788
5789 @Override
5790 public boolean equals(Object that) {
5791 if (that == null)
5792 return false;
5793 if (that instanceof checkAndPut_args)
5794 return this.equals((checkAndPut_args)that);
5795 return false;
5796 }
5797
5798 public boolean equals(checkAndPut_args that) {
5799 if (that == null)
5800 return false;
5801
5802 boolean this_present_table = true && this.isSetTable();
5803 boolean that_present_table = true && that.isSetTable();
5804 if (this_present_table || that_present_table) {
5805 if (!(this_present_table && that_present_table))
5806 return false;
5807 if (!this.table.equals(that.table))
5808 return false;
5809 }
5810
5811 boolean this_present_row = true && this.isSetRow();
5812 boolean that_present_row = true && that.isSetRow();
5813 if (this_present_row || that_present_row) {
5814 if (!(this_present_row && that_present_row))
5815 return false;
5816 if (!this.row.equals(that.row))
5817 return false;
5818 }
5819
5820 boolean this_present_family = true && this.isSetFamily();
5821 boolean that_present_family = true && that.isSetFamily();
5822 if (this_present_family || that_present_family) {
5823 if (!(this_present_family && that_present_family))
5824 return false;
5825 if (!this.family.equals(that.family))
5826 return false;
5827 }
5828
5829 boolean this_present_qualifier = true && this.isSetQualifier();
5830 boolean that_present_qualifier = true && that.isSetQualifier();
5831 if (this_present_qualifier || that_present_qualifier) {
5832 if (!(this_present_qualifier && that_present_qualifier))
5833 return false;
5834 if (!this.qualifier.equals(that.qualifier))
5835 return false;
5836 }
5837
5838 boolean this_present_value = true && this.isSetValue();
5839 boolean that_present_value = true && that.isSetValue();
5840 if (this_present_value || that_present_value) {
5841 if (!(this_present_value && that_present_value))
5842 return false;
5843 if (!this.value.equals(that.value))
5844 return false;
5845 }
5846
5847 boolean this_present_put = true && this.isSetPut();
5848 boolean that_present_put = true && that.isSetPut();
5849 if (this_present_put || that_present_put) {
5850 if (!(this_present_put && that_present_put))
5851 return false;
5852 if (!this.put.equals(that.put))
5853 return false;
5854 }
5855
5856 return true;
5857 }
5858
5859 @Override
5860 public int hashCode() {
5861 return 0;
5862 }
5863
5864 public int compareTo(checkAndPut_args other) {
5865 if (!getClass().equals(other.getClass())) {
5866 return getClass().getName().compareTo(other.getClass().getName());
5867 }
5868
5869 int lastComparison = 0;
5870 checkAndPut_args typedOther = (checkAndPut_args)other;
5871
5872 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
5873 if (lastComparison != 0) {
5874 return lastComparison;
5875 }
5876 if (isSetTable()) {
5877 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
5878 if (lastComparison != 0) {
5879 return lastComparison;
5880 }
5881 }
5882 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
5883 if (lastComparison != 0) {
5884 return lastComparison;
5885 }
5886 if (isSetRow()) {
5887 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
5888 if (lastComparison != 0) {
5889 return lastComparison;
5890 }
5891 }
5892 lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
5893 if (lastComparison != 0) {
5894 return lastComparison;
5895 }
5896 if (isSetFamily()) {
5897 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
5898 if (lastComparison != 0) {
5899 return lastComparison;
5900 }
5901 }
5902 lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
5903 if (lastComparison != 0) {
5904 return lastComparison;
5905 }
5906 if (isSetQualifier()) {
5907 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
5908 if (lastComparison != 0) {
5909 return lastComparison;
5910 }
5911 }
5912 lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
5913 if (lastComparison != 0) {
5914 return lastComparison;
5915 }
5916 if (isSetValue()) {
5917 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
5918 if (lastComparison != 0) {
5919 return lastComparison;
5920 }
5921 }
5922 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
5923 if (lastComparison != 0) {
5924 return lastComparison;
5925 }
5926 if (isSetPut()) {
5927 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
5928 if (lastComparison != 0) {
5929 return lastComparison;
5930 }
5931 }
5932 return 0;
5933 }
5934
5935 public _Fields fieldForId(int fieldId) {
5936 return _Fields.findByThriftId(fieldId);
5937 }
5938
5939 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
5940 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
5941 }
5942
5943 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
5944 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
5945 }
5946
5947 @Override
5948 public String toString() {
5949 StringBuilder sb = new StringBuilder("checkAndPut_args(");
5950 boolean first = true;
5951
5952 sb.append("table:");
5953 if (this.table == null) {
5954 sb.append("null");
5955 } else {
5956 org.apache.thrift.TBaseHelper.toString(this.table, sb);
5957 }
5958 first = false;
5959 if (!first) sb.append(", ");
5960 sb.append("row:");
5961 if (this.row == null) {
5962 sb.append("null");
5963 } else {
5964 org.apache.thrift.TBaseHelper.toString(this.row, sb);
5965 }
5966 first = false;
5967 if (!first) sb.append(", ");
5968 sb.append("family:");
5969 if (this.family == null) {
5970 sb.append("null");
5971 } else {
5972 org.apache.thrift.TBaseHelper.toString(this.family, sb);
5973 }
5974 first = false;
5975 if (!first) sb.append(", ");
5976 sb.append("qualifier:");
5977 if (this.qualifier == null) {
5978 sb.append("null");
5979 } else {
5980 org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
5981 }
5982 first = false;
5983 if (!first) sb.append(", ");
5984 sb.append("value:");
5985 if (this.value == null) {
5986 sb.append("null");
5987 } else {
5988 org.apache.thrift.TBaseHelper.toString(this.value, sb);
5989 }
5990 first = false;
5991 if (!first) sb.append(", ");
5992 sb.append("put:");
5993 if (this.put == null) {
5994 sb.append("null");
5995 } else {
5996 sb.append(this.put);
5997 }
5998 first = false;
5999 sb.append(")");
6000 return sb.toString();
6001 }
6002
6003 public void validate() throws org.apache.thrift.TException {
6004
6005 if (table == null) {
6006 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
6007 }
6008 if (row == null) {
6009 throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
6010 }
6011 if (family == null) {
6012 throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
6013 }
6014 if (qualifier == null) {
6015 throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
6016 }
6017 if (put == null) {
6018 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
6019 }
6020 }
6021
6022 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6023 try {
6024 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6025 } catch (org.apache.thrift.TException te) {
6026 throw new java.io.IOException(te);
6027 }
6028 }
6029
6030 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6031 try {
6032 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6033 } catch (org.apache.thrift.TException te) {
6034 throw new java.io.IOException(te);
6035 }
6036 }
6037
6038 private static class checkAndPut_argsStandardSchemeFactory implements SchemeFactory {
6039 public checkAndPut_argsStandardScheme getScheme() {
6040 return new checkAndPut_argsStandardScheme();
6041 }
6042 }
6043
6044 private static class checkAndPut_argsStandardScheme extends StandardScheme<checkAndPut_args> {
6045
6046 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6047 org.apache.thrift.protocol.TField schemeField;
6048 iprot.readStructBegin();
6049 while (true)
6050 {
6051 schemeField = iprot.readFieldBegin();
6052 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6053 break;
6054 }
6055 switch (schemeField.id) {
6056 case 1:
6057 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6058 struct.table = iprot.readBinary();
6059 struct.setTableIsSet(true);
6060 } else {
6061 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6062 }
6063 break;
6064 case 2:
6065 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6066 struct.row = iprot.readBinary();
6067 struct.setRowIsSet(true);
6068 } else {
6069 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6070 }
6071 break;
6072 case 3:
6073 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6074 struct.family = iprot.readBinary();
6075 struct.setFamilyIsSet(true);
6076 } else {
6077 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6078 }
6079 break;
6080 case 4:
6081 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6082 struct.qualifier = iprot.readBinary();
6083 struct.setQualifierIsSet(true);
6084 } else {
6085 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6086 }
6087 break;
6088 case 5:
6089 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6090 struct.value = iprot.readBinary();
6091 struct.setValueIsSet(true);
6092 } else {
6093 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6094 }
6095 break;
6096 case 6:
6097 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6098 struct.put = new TPut();
6099 struct.put.read(iprot);
6100 struct.setPutIsSet(true);
6101 } else {
6102 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6103 }
6104 break;
6105 default:
6106 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6107 }
6108 iprot.readFieldEnd();
6109 }
6110 iprot.readStructEnd();
6111
6112
6113 struct.validate();
6114 }
6115
6116 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6117 struct.validate();
6118
6119 oprot.writeStructBegin(STRUCT_DESC);
6120 if (struct.table != null) {
6121 oprot.writeFieldBegin(TABLE_FIELD_DESC);
6122 oprot.writeBinary(struct.table);
6123 oprot.writeFieldEnd();
6124 }
6125 if (struct.row != null) {
6126 oprot.writeFieldBegin(ROW_FIELD_DESC);
6127 oprot.writeBinary(struct.row);
6128 oprot.writeFieldEnd();
6129 }
6130 if (struct.family != null) {
6131 oprot.writeFieldBegin(FAMILY_FIELD_DESC);
6132 oprot.writeBinary(struct.family);
6133 oprot.writeFieldEnd();
6134 }
6135 if (struct.qualifier != null) {
6136 oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
6137 oprot.writeBinary(struct.qualifier);
6138 oprot.writeFieldEnd();
6139 }
6140 if (struct.value != null) {
6141 oprot.writeFieldBegin(VALUE_FIELD_DESC);
6142 oprot.writeBinary(struct.value);
6143 oprot.writeFieldEnd();
6144 }
6145 if (struct.put != null) {
6146 oprot.writeFieldBegin(PUT_FIELD_DESC);
6147 struct.put.write(oprot);
6148 oprot.writeFieldEnd();
6149 }
6150 oprot.writeFieldStop();
6151 oprot.writeStructEnd();
6152 }
6153
6154 }
6155
6156 private static class checkAndPut_argsTupleSchemeFactory implements SchemeFactory {
6157 public checkAndPut_argsTupleScheme getScheme() {
6158 return new checkAndPut_argsTupleScheme();
6159 }
6160 }
6161
6162 private static class checkAndPut_argsTupleScheme extends TupleScheme<checkAndPut_args> {
6163
6164 @Override
6165 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6166 TTupleProtocol oprot = (TTupleProtocol) prot;
6167 oprot.writeBinary(struct.table);
6168 oprot.writeBinary(struct.row);
6169 oprot.writeBinary(struct.family);
6170 oprot.writeBinary(struct.qualifier);
6171 struct.put.write(oprot);
6172 BitSet optionals = new BitSet();
6173 if (struct.isSetValue()) {
6174 optionals.set(0);
6175 }
6176 oprot.writeBitSet(optionals, 1);
6177 if (struct.isSetValue()) {
6178 oprot.writeBinary(struct.value);
6179 }
6180 }
6181
6182 @Override
6183 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6184 TTupleProtocol iprot = (TTupleProtocol) prot;
6185 struct.table = iprot.readBinary();
6186 struct.setTableIsSet(true);
6187 struct.row = iprot.readBinary();
6188 struct.setRowIsSet(true);
6189 struct.family = iprot.readBinary();
6190 struct.setFamilyIsSet(true);
6191 struct.qualifier = iprot.readBinary();
6192 struct.setQualifierIsSet(true);
6193 struct.put = new TPut();
6194 struct.put.read(iprot);
6195 struct.setPutIsSet(true);
6196 BitSet incoming = iprot.readBitSet(1);
6197 if (incoming.get(0)) {
6198 struct.value = iprot.readBinary();
6199 struct.setValueIsSet(true);
6200 }
6201 }
6202 }
6203
6204 }
6205
6206 public static class checkAndPut_result implements org.apache.thrift.TBase<checkAndPut_result, checkAndPut_result._Fields>, java.io.Serializable, Cloneable {
6207 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_result");
6208
6209 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);
6210 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);
6211
6212 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6213 static {
6214 schemes.put(StandardScheme.class, new checkAndPut_resultStandardSchemeFactory());
6215 schemes.put(TupleScheme.class, new checkAndPut_resultTupleSchemeFactory());
6216 }
6217
6218 public boolean success;
6219 public TIOError io;
6220
6221
6222 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6223 SUCCESS((short)0, "success"),
6224 IO((short)1, "io");
6225
6226 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6227
6228 static {
6229 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6230 byName.put(field.getFieldName(), field);
6231 }
6232 }
6233
6234
6235
6236
6237 public static _Fields findByThriftId(int fieldId) {
6238 switch(fieldId) {
6239 case 0:
6240 return SUCCESS;
6241 case 1:
6242 return IO;
6243 default:
6244 return null;
6245 }
6246 }
6247
6248
6249
6250
6251
6252 public static _Fields findByThriftIdOrThrow(int fieldId) {
6253 _Fields fields = findByThriftId(fieldId);
6254 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6255 return fields;
6256 }
6257
6258
6259
6260
6261 public static _Fields findByName(String name) {
6262 return byName.get(name);
6263 }
6264
6265 private final short _thriftId;
6266 private final String _fieldName;
6267
6268 _Fields(short thriftId, String fieldName) {
6269 _thriftId = thriftId;
6270 _fieldName = fieldName;
6271 }
6272
6273 public short getThriftFieldId() {
6274 return _thriftId;
6275 }
6276
6277 public String getFieldName() {
6278 return _fieldName;
6279 }
6280 }
6281
6282
6283 private static final int __SUCCESS_ISSET_ID = 0;
6284 private BitSet __isset_bit_vector = new BitSet(1);
6285 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6286 static {
6287 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6288 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
6289 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
6290 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
6291 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
6292 metaDataMap = Collections.unmodifiableMap(tmpMap);
6293 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_result.class, metaDataMap);
6294 }
6295
6296 public checkAndPut_result() {
6297 }
6298
6299 public checkAndPut_result(
6300 boolean success,
6301 TIOError io)
6302 {
6303 this();
6304 this.success = success;
6305 setSuccessIsSet(true);
6306 this.io = io;
6307 }
6308
6309
6310
6311
6312 public checkAndPut_result(checkAndPut_result other) {
6313 __isset_bit_vector.clear();
6314 __isset_bit_vector.or(other.__isset_bit_vector);
6315 this.success = other.success;
6316 if (other.isSetIo()) {
6317 this.io = new TIOError(other.io);
6318 }
6319 }
6320
6321 public checkAndPut_result deepCopy() {
6322 return new checkAndPut_result(this);
6323 }
6324
6325 @Override
6326 public void clear() {
6327 setSuccessIsSet(false);
6328 this.success = false;
6329 this.io = null;
6330 }
6331
6332 public boolean isSuccess() {
6333 return this.success;
6334 }
6335
6336 public checkAndPut_result setSuccess(boolean success) {
6337 this.success = success;
6338 setSuccessIsSet(true);
6339 return this;
6340 }
6341
6342 public void unsetSuccess() {
6343 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
6344 }
6345
6346
6347 public boolean isSetSuccess() {
6348 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
6349 }
6350
6351 public void setSuccessIsSet(boolean value) {
6352 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
6353 }
6354
6355 public TIOError getIo() {
6356 return this.io;
6357 }
6358
6359 public checkAndPut_result setIo(TIOError io) {
6360 this.io = io;
6361 return this;
6362 }
6363
6364 public void unsetIo() {
6365 this.io = null;
6366 }
6367
6368
6369 public boolean isSetIo() {
6370 return this.io != null;
6371 }
6372
6373 public void setIoIsSet(boolean value) {
6374 if (!value) {
6375 this.io = null;
6376 }
6377 }
6378
6379 public void setFieldValue(_Fields field, Object value) {
6380 switch (field) {
6381 case SUCCESS:
6382 if (value == null) {
6383 unsetSuccess();
6384 } else {
6385 setSuccess((Boolean)value);
6386 }
6387 break;
6388
6389 case IO:
6390 if (value == null) {
6391 unsetIo();
6392 } else {
6393 setIo((TIOError)value);
6394 }
6395 break;
6396
6397 }
6398 }
6399
6400 public Object getFieldValue(_Fields field) {
6401 switch (field) {
6402 case SUCCESS:
6403 return Boolean.valueOf(isSuccess());
6404
6405 case IO:
6406 return getIo();
6407
6408 }
6409 throw new IllegalStateException();
6410 }
6411
6412
6413 public boolean isSet(_Fields field) {
6414 if (field == null) {
6415 throw new IllegalArgumentException();
6416 }
6417
6418 switch (field) {
6419 case SUCCESS:
6420 return isSetSuccess();
6421 case IO:
6422 return isSetIo();
6423 }
6424 throw new IllegalStateException();
6425 }
6426
6427 @Override
6428 public boolean equals(Object that) {
6429 if (that == null)
6430 return false;
6431 if (that instanceof checkAndPut_result)
6432 return this.equals((checkAndPut_result)that);
6433 return false;
6434 }
6435
6436 public boolean equals(checkAndPut_result that) {
6437 if (that == null)
6438 return false;
6439
6440 boolean this_present_success = true;
6441 boolean that_present_success = true;
6442 if (this_present_success || that_present_success) {
6443 if (!(this_present_success && that_present_success))
6444 return false;
6445 if (this.success != that.success)
6446 return false;
6447 }
6448
6449 boolean this_present_io = true && this.isSetIo();
6450 boolean that_present_io = true && that.isSetIo();
6451 if (this_present_io || that_present_io) {
6452 if (!(this_present_io && that_present_io))
6453 return false;
6454 if (!this.io.equals(that.io))
6455 return false;
6456 }
6457
6458 return true;
6459 }
6460
6461 @Override
6462 public int hashCode() {
6463 return 0;
6464 }
6465
6466 public int compareTo(checkAndPut_result other) {
6467 if (!getClass().equals(other.getClass())) {
6468 return getClass().getName().compareTo(other.getClass().getName());
6469 }
6470
6471 int lastComparison = 0;
6472 checkAndPut_result typedOther = (checkAndPut_result)other;
6473
6474 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
6475 if (lastComparison != 0) {
6476 return lastComparison;
6477 }
6478 if (isSetSuccess()) {
6479 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
6480 if (lastComparison != 0) {
6481 return lastComparison;
6482 }
6483 }
6484 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
6485 if (lastComparison != 0) {
6486 return lastComparison;
6487 }
6488 if (isSetIo()) {
6489 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
6490 if (lastComparison != 0) {
6491 return lastComparison;
6492 }
6493 }
6494 return 0;
6495 }
6496
6497 public _Fields fieldForId(int fieldId) {
6498 return _Fields.findByThriftId(fieldId);
6499 }
6500
6501 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6502 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6503 }
6504
6505 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6506 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6507 }
6508
6509 @Override
6510 public String toString() {
6511 StringBuilder sb = new StringBuilder("checkAndPut_result(");
6512 boolean first = true;
6513
6514 sb.append("success:");
6515 sb.append(this.success);
6516 first = false;
6517 if (!first) sb.append(", ");
6518 sb.append("io:");
6519 if (this.io == null) {
6520 sb.append("null");
6521 } else {
6522 sb.append(this.io);
6523 }
6524 first = false;
6525 sb.append(")");
6526 return sb.toString();
6527 }
6528
6529 public void validate() throws org.apache.thrift.TException {
6530
6531 }
6532
6533 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6534 try {
6535 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6536 } catch (org.apache.thrift.TException te) {
6537 throw new java.io.IOException(te);
6538 }
6539 }
6540
6541 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6542 try {
6543
6544 __isset_bit_vector = new BitSet(1);
6545 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6546 } catch (org.apache.thrift.TException te) {
6547 throw new java.io.IOException(te);
6548 }
6549 }
6550
6551 private static class checkAndPut_resultStandardSchemeFactory implements SchemeFactory {
6552 public checkAndPut_resultStandardScheme getScheme() {
6553 return new checkAndPut_resultStandardScheme();
6554 }
6555 }
6556
6557 private static class checkAndPut_resultStandardScheme extends StandardScheme<checkAndPut_result> {
6558
6559 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6560 org.apache.thrift.protocol.TField schemeField;
6561 iprot.readStructBegin();
6562 while (true)
6563 {
6564 schemeField = iprot.readFieldBegin();
6565 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6566 break;
6567 }
6568 switch (schemeField.id) {
6569 case 0:
6570 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
6571 struct.success = iprot.readBool();
6572 struct.setSuccessIsSet(true);
6573 } else {
6574 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6575 }
6576 break;
6577 case 1:
6578 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6579 struct.io = new TIOError();
6580 struct.io.read(iprot);
6581 struct.setIoIsSet(true);
6582 } else {
6583 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6584 }
6585 break;
6586 default:
6587 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6588 }
6589 iprot.readFieldEnd();
6590 }
6591 iprot.readStructEnd();
6592
6593
6594 struct.validate();
6595 }
6596
6597 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6598 struct.validate();
6599
6600 oprot.writeStructBegin(STRUCT_DESC);
6601 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6602 oprot.writeBool(struct.success);
6603 oprot.writeFieldEnd();
6604 if (struct.io != null) {
6605 oprot.writeFieldBegin(IO_FIELD_DESC);
6606 struct.io.write(oprot);
6607 oprot.writeFieldEnd();
6608 }
6609 oprot.writeFieldStop();
6610 oprot.writeStructEnd();
6611 }
6612
6613 }
6614
6615 private static class checkAndPut_resultTupleSchemeFactory implements SchemeFactory {
6616 public checkAndPut_resultTupleScheme getScheme() {
6617 return new checkAndPut_resultTupleScheme();
6618 }
6619 }
6620
6621 private static class checkAndPut_resultTupleScheme extends TupleScheme<checkAndPut_result> {
6622
6623 @Override
6624 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6625 TTupleProtocol oprot = (TTupleProtocol) prot;
6626 BitSet optionals = new BitSet();
6627 if (struct.isSetSuccess()) {
6628 optionals.set(0);
6629 }
6630 if (struct.isSetIo()) {
6631 optionals.set(1);
6632 }
6633 oprot.writeBitSet(optionals, 2);
6634 if (struct.isSetSuccess()) {
6635 oprot.writeBool(struct.success);
6636 }
6637 if (struct.isSetIo()) {
6638 struct.io.write(oprot);
6639 }
6640 }
6641
6642 @Override
6643 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6644 TTupleProtocol iprot = (TTupleProtocol) prot;
6645 BitSet incoming = iprot.readBitSet(2);
6646 if (incoming.get(0)) {
6647 struct.success = iprot.readBool();
6648 struct.setSuccessIsSet(true);
6649 }
6650 if (incoming.get(1)) {
6651 struct.io = new TIOError();
6652 struct.io.read(iprot);
6653 struct.setIoIsSet(true);
6654 }
6655 }
6656 }
6657
6658 }
6659
6660 public static class putMultiple_args implements org.apache.thrift.TBase<putMultiple_args, putMultiple_args._Fields>, java.io.Serializable, Cloneable {
6661 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_args");
6662
6663 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);
6664 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);
6665
6666 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6667 static {
6668 schemes.put(StandardScheme.class, new putMultiple_argsStandardSchemeFactory());
6669 schemes.put(TupleScheme.class, new putMultiple_argsTupleSchemeFactory());
6670 }
6671
6672
6673
6674
6675 public ByteBuffer table;
6676
6677
6678
6679 public List<TPut> puts;
6680
6681
6682 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6683
6684
6685
6686 TABLE((short)1, "table"),
6687
6688
6689
6690 PUTS((short)2, "puts");
6691
6692 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6693
6694 static {
6695 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6696 byName.put(field.getFieldName(), field);
6697 }
6698 }
6699
6700
6701
6702
6703 public static _Fields findByThriftId(int fieldId) {
6704 switch(fieldId) {
6705 case 1:
6706 return TABLE;
6707 case 2:
6708 return PUTS;
6709 default:
6710 return null;
6711 }
6712 }
6713
6714
6715
6716
6717
6718 public static _Fields findByThriftIdOrThrow(int fieldId) {
6719 _Fields fields = findByThriftId(fieldId);
6720 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6721 return fields;
6722 }
6723
6724
6725
6726
6727 public static _Fields findByName(String name) {
6728 return byName.get(name);
6729 }
6730
6731 private final short _thriftId;
6732 private final String _fieldName;
6733
6734 _Fields(short thriftId, String fieldName) {
6735 _thriftId = thriftId;
6736 _fieldName = fieldName;
6737 }
6738
6739 public short getThriftFieldId() {
6740 return _thriftId;
6741 }
6742
6743 public String getFieldName() {
6744 return _fieldName;
6745 }
6746 }
6747
6748
6749 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6750 static {
6751 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6752 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
6753 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
6754 tmpMap.put(_Fields.PUTS, new org.apache.thrift.meta_data.FieldMetaData("puts", org.apache.thrift.TFieldRequirementType.REQUIRED,
6755 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
6756 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class))));
6757 metaDataMap = Collections.unmodifiableMap(tmpMap);
6758 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_args.class, metaDataMap);
6759 }
6760
6761 public putMultiple_args() {
6762 }
6763
6764 public putMultiple_args(
6765 ByteBuffer table,
6766 List<TPut> puts)
6767 {
6768 this();
6769 this.table = table;
6770 this.puts = puts;
6771 }
6772
6773
6774
6775
6776 public putMultiple_args(putMultiple_args other) {
6777 if (other.isSetTable()) {
6778 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
6779 ;
6780 }
6781 if (other.isSetPuts()) {
6782 List<TPut> __this__puts = new ArrayList<TPut>();
6783 for (TPut other_element : other.puts) {
6784 __this__puts.add(new TPut(other_element));
6785 }
6786 this.puts = __this__puts;
6787 }
6788 }
6789
6790 public putMultiple_args deepCopy() {
6791 return new putMultiple_args(this);
6792 }
6793
6794 @Override
6795 public void clear() {
6796 this.table = null;
6797 this.puts = null;
6798 }
6799
6800
6801
6802
6803 public byte[] getTable() {
6804 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
6805 return table == null ? null : table.array();
6806 }
6807
6808 public ByteBuffer bufferForTable() {
6809 return table;
6810 }
6811
6812
6813
6814
6815 public putMultiple_args setTable(byte[] table) {
6816 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
6817 return this;
6818 }
6819
6820 public putMultiple_args setTable(ByteBuffer table) {
6821 this.table = table;
6822 return this;
6823 }
6824
6825 public void unsetTable() {
6826 this.table = null;
6827 }
6828
6829
6830 public boolean isSetTable() {
6831 return this.table != null;
6832 }
6833
6834 public void setTableIsSet(boolean value) {
6835 if (!value) {
6836 this.table = null;
6837 }
6838 }
6839
6840 public int getPutsSize() {
6841 return (this.puts == null) ? 0 : this.puts.size();
6842 }
6843
6844 public java.util.Iterator<TPut> getPutsIterator() {
6845 return (this.puts == null) ? null : this.puts.iterator();
6846 }
6847
6848 public void addToPuts(TPut elem) {
6849 if (this.puts == null) {
6850 this.puts = new ArrayList<TPut>();
6851 }
6852 this.puts.add(elem);
6853 }
6854
6855
6856
6857
6858 public List<TPut> getPuts() {
6859 return this.puts;
6860 }
6861
6862
6863
6864
6865 public putMultiple_args setPuts(List<TPut> puts) {
6866 this.puts = puts;
6867 return this;
6868 }
6869
6870 public void unsetPuts() {
6871 this.puts = null;
6872 }
6873
6874
6875 public boolean isSetPuts() {
6876 return this.puts != null;
6877 }
6878
6879 public void setPutsIsSet(boolean value) {
6880 if (!value) {
6881 this.puts = null;
6882 }
6883 }
6884
6885 public void setFieldValue(_Fields field, Object value) {
6886 switch (field) {
6887 case TABLE:
6888 if (value == null) {
6889 unsetTable();
6890 } else {
6891 setTable((ByteBuffer)value);
6892 }
6893 break;
6894
6895 case PUTS:
6896 if (value == null) {
6897 unsetPuts();
6898 } else {
6899 setPuts((List<TPut>)value);
6900 }
6901 break;
6902
6903 }
6904 }
6905
6906 public Object getFieldValue(_Fields field) {
6907 switch (field) {
6908 case TABLE:
6909 return getTable();
6910
6911 case PUTS:
6912 return getPuts();
6913
6914 }
6915 throw new IllegalStateException();
6916 }
6917
6918
6919 public boolean isSet(_Fields field) {
6920 if (field == null) {
6921 throw new IllegalArgumentException();
6922 }
6923
6924 switch (field) {
6925 case TABLE:
6926 return isSetTable();
6927 case PUTS:
6928 return isSetPuts();
6929 }
6930 throw new IllegalStateException();
6931 }
6932
6933 @Override
6934 public boolean equals(Object that) {
6935 if (that == null)
6936 return false;
6937 if (that instanceof putMultiple_args)
6938 return this.equals((putMultiple_args)that);
6939 return false;
6940 }
6941
6942 public boolean equals(putMultiple_args that) {
6943 if (that == null)
6944 return false;
6945
6946 boolean this_present_table = true && this.isSetTable();
6947 boolean that_present_table = true && that.isSetTable();
6948 if (this_present_table || that_present_table) {
6949 if (!(this_present_table && that_present_table))
6950 return false;
6951 if (!this.table.equals(that.table))
6952 return false;
6953 }
6954
6955 boolean this_present_puts = true && this.isSetPuts();
6956 boolean that_present_puts = true && that.isSetPuts();
6957 if (this_present_puts || that_present_puts) {
6958 if (!(this_present_puts && that_present_puts))
6959 return false;
6960 if (!this.puts.equals(that.puts))
6961 return false;
6962 }
6963
6964 return true;
6965 }
6966
6967 @Override
6968 public int hashCode() {
6969 return 0;
6970 }
6971
6972 public int compareTo(putMultiple_args other) {
6973 if (!getClass().equals(other.getClass())) {
6974 return getClass().getName().compareTo(other.getClass().getName());
6975 }
6976
6977 int lastComparison = 0;
6978 putMultiple_args typedOther = (putMultiple_args)other;
6979
6980 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
6981 if (lastComparison != 0) {
6982 return lastComparison;
6983 }
6984 if (isSetTable()) {
6985 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
6986 if (lastComparison != 0) {
6987 return lastComparison;
6988 }
6989 }
6990 lastComparison = Boolean.valueOf(isSetPuts()).compareTo(typedOther.isSetPuts());
6991 if (lastComparison != 0) {
6992 return lastComparison;
6993 }
6994 if (isSetPuts()) {
6995 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.puts, typedOther.puts);
6996 if (lastComparison != 0) {
6997 return lastComparison;
6998 }
6999 }
7000 return 0;
7001 }
7002
7003 public _Fields fieldForId(int fieldId) {
7004 return _Fields.findByThriftId(fieldId);
7005 }
7006
7007 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7008 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7009 }
7010
7011 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7012 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7013 }
7014
7015 @Override
7016 public String toString() {
7017 StringBuilder sb = new StringBuilder("putMultiple_args(");
7018 boolean first = true;
7019
7020 sb.append("table:");
7021 if (this.table == null) {
7022 sb.append("null");
7023 } else {
7024 org.apache.thrift.TBaseHelper.toString(this.table, sb);
7025 }
7026 first = false;
7027 if (!first) sb.append(", ");
7028 sb.append("puts:");
7029 if (this.puts == null) {
7030 sb.append("null");
7031 } else {
7032 sb.append(this.puts);
7033 }
7034 first = false;
7035 sb.append(")");
7036 return sb.toString();
7037 }
7038
7039 public void validate() throws org.apache.thrift.TException {
7040
7041 if (table == null) {
7042 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
7043 }
7044 if (puts == null) {
7045 throw new org.apache.thrift.protocol.TProtocolException("Required field 'puts' was not present! Struct: " + toString());
7046 }
7047 }
7048
7049 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7050 try {
7051 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7052 } catch (org.apache.thrift.TException te) {
7053 throw new java.io.IOException(te);
7054 }
7055 }
7056
7057 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7058 try {
7059 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7060 } catch (org.apache.thrift.TException te) {
7061 throw new java.io.IOException(te);
7062 }
7063 }
7064
7065 private static class putMultiple_argsStandardSchemeFactory implements SchemeFactory {
7066 public putMultiple_argsStandardScheme getScheme() {
7067 return new putMultiple_argsStandardScheme();
7068 }
7069 }
7070
7071 private static class putMultiple_argsStandardScheme extends StandardScheme<putMultiple_args> {
7072
7073 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_args struct) throws org.apache.thrift.TException {
7074 org.apache.thrift.protocol.TField schemeField;
7075 iprot.readStructBegin();
7076 while (true)
7077 {
7078 schemeField = iprot.readFieldBegin();
7079 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7080 break;
7081 }
7082 switch (schemeField.id) {
7083 case 1:
7084 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
7085 struct.table = iprot.readBinary();
7086 struct.setTableIsSet(true);
7087 } else {
7088 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7089 }
7090 break;
7091 case 2:
7092 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
7093 {
7094 org.apache.thrift.protocol.TList _list122 = iprot.readListBegin();
7095 struct.puts = new ArrayList<TPut>(_list122.size);
7096 for (int _i123 = 0; _i123 < _list122.size; ++_i123)
7097 {
7098 TPut _elem124;
7099 _elem124 = new TPut();
7100 _elem124.read(iprot);
7101 struct.puts.add(_elem124);
7102 }
7103 iprot.readListEnd();
7104 }
7105 struct.setPutsIsSet(true);
7106 } else {
7107 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7108 }
7109 break;
7110 default:
7111 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7112 }
7113 iprot.readFieldEnd();
7114 }
7115 iprot.readStructEnd();
7116
7117
7118 struct.validate();
7119 }
7120
7121 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_args struct) throws org.apache.thrift.TException {
7122 struct.validate();
7123
7124 oprot.writeStructBegin(STRUCT_DESC);
7125 if (struct.table != null) {
7126 oprot.writeFieldBegin(TABLE_FIELD_DESC);
7127 oprot.writeBinary(struct.table);
7128 oprot.writeFieldEnd();
7129 }
7130 if (struct.puts != null) {
7131 oprot.writeFieldBegin(PUTS_FIELD_DESC);
7132 {
7133 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.puts.size()));
7134 for (TPut _iter125 : struct.puts)
7135 {
7136 _iter125.write(oprot);
7137 }
7138 oprot.writeListEnd();
7139 }
7140 oprot.writeFieldEnd();
7141 }
7142 oprot.writeFieldStop();
7143 oprot.writeStructEnd();
7144 }
7145
7146 }
7147
7148 private static class putMultiple_argsTupleSchemeFactory implements SchemeFactory {
7149 public putMultiple_argsTupleScheme getScheme() {
7150 return new putMultiple_argsTupleScheme();
7151 }
7152 }
7153
7154 private static class putMultiple_argsTupleScheme extends TupleScheme<putMultiple_args> {
7155
7156 @Override
7157 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7158 TTupleProtocol oprot = (TTupleProtocol) prot;
7159 oprot.writeBinary(struct.table);
7160 {
7161 oprot.writeI32(struct.puts.size());
7162 for (TPut _iter126 : struct.puts)
7163 {
7164 _iter126.write(oprot);
7165 }
7166 }
7167 }
7168
7169 @Override
7170 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7171 TTupleProtocol iprot = (TTupleProtocol) prot;
7172 struct.table = iprot.readBinary();
7173 struct.setTableIsSet(true);
7174 {
7175 org.apache.thrift.protocol.TList _list127 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
7176 struct.puts = new ArrayList<TPut>(_list127.size);
7177 for (int _i128 = 0; _i128 < _list127.size; ++_i128)
7178 {
7179 TPut _elem129;
7180 _elem129 = new TPut();
7181 _elem129.read(iprot);
7182 struct.puts.add(_elem129);
7183 }
7184 }
7185 struct.setPutsIsSet(true);
7186 }
7187 }
7188
7189 }
7190
7191 public static class putMultiple_result implements org.apache.thrift.TBase<putMultiple_result, putMultiple_result._Fields>, java.io.Serializable, Cloneable {
7192 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_result");
7193
7194 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);
7195
7196 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7197 static {
7198 schemes.put(StandardScheme.class, new putMultiple_resultStandardSchemeFactory());
7199 schemes.put(TupleScheme.class, new putMultiple_resultTupleSchemeFactory());
7200 }
7201
7202 public TIOError io;
7203
7204
7205 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7206 IO((short)1, "io");
7207
7208 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7209
7210 static {
7211 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7212 byName.put(field.getFieldName(), field);
7213 }
7214 }
7215
7216
7217
7218
7219 public static _Fields findByThriftId(int fieldId) {
7220 switch(fieldId) {
7221 case 1:
7222 return IO;
7223 default:
7224 return null;
7225 }
7226 }
7227
7228
7229
7230
7231
7232 public static _Fields findByThriftIdOrThrow(int fieldId) {
7233 _Fields fields = findByThriftId(fieldId);
7234 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7235 return fields;
7236 }
7237
7238
7239
7240
7241 public static _Fields findByName(String name) {
7242 return byName.get(name);
7243 }
7244
7245 private final short _thriftId;
7246 private final String _fieldName;
7247
7248 _Fields(short thriftId, String fieldName) {
7249 _thriftId = thriftId;
7250 _fieldName = fieldName;
7251 }
7252
7253 public short getThriftFieldId() {
7254 return _thriftId;
7255 }
7256
7257 public String getFieldName() {
7258 return _fieldName;
7259 }
7260 }
7261
7262
7263 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7264 static {
7265 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7266 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
7267 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
7268 metaDataMap = Collections.unmodifiableMap(tmpMap);
7269 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_result.class, metaDataMap);
7270 }
7271
7272 public putMultiple_result() {
7273 }
7274
7275 public putMultiple_result(
7276 TIOError io)
7277 {
7278 this();
7279 this.io = io;
7280 }
7281
7282
7283
7284
7285 public putMultiple_result(putMultiple_result other) {
7286 if (other.isSetIo()) {
7287 this.io = new TIOError(other.io);
7288 }
7289 }
7290
7291 public putMultiple_result deepCopy() {
7292 return new putMultiple_result(this);
7293 }
7294
7295 @Override
7296 public void clear() {
7297 this.io = null;
7298 }
7299
7300 public TIOError getIo() {
7301 return this.io;
7302 }
7303
7304 public putMultiple_result setIo(TIOError io) {
7305 this.io = io;
7306 return this;
7307 }
7308
7309 public void unsetIo() {
7310 this.io = null;
7311 }
7312
7313
7314 public boolean isSetIo() {
7315 return this.io != null;
7316 }
7317
7318 public void setIoIsSet(boolean value) {
7319 if (!value) {
7320 this.io = null;
7321 }
7322 }
7323
7324 public void setFieldValue(_Fields field, Object value) {
7325 switch (field) {
7326 case IO:
7327 if (value == null) {
7328 unsetIo();
7329 } else {
7330 setIo((TIOError)value);
7331 }
7332 break;
7333
7334 }
7335 }
7336
7337 public Object getFieldValue(_Fields field) {
7338 switch (field) {
7339 case IO:
7340 return getIo();
7341
7342 }
7343 throw new IllegalStateException();
7344 }
7345
7346
7347 public boolean isSet(_Fields field) {
7348 if (field == null) {
7349 throw new IllegalArgumentException();
7350 }
7351
7352 switch (field) {
7353 case IO:
7354 return isSetIo();
7355 }
7356 throw new IllegalStateException();
7357 }
7358
7359 @Override
7360 public boolean equals(Object that) {
7361 if (that == null)
7362 return false;
7363 if (that instanceof putMultiple_result)
7364 return this.equals((putMultiple_result)that);
7365 return false;
7366 }
7367
7368 public boolean equals(putMultiple_result that) {
7369 if (that == null)
7370 return false;
7371
7372 boolean this_present_io = true && this.isSetIo();
7373 boolean that_present_io = true && that.isSetIo();
7374 if (this_present_io || that_present_io) {
7375 if (!(this_present_io && that_present_io))
7376 return false;
7377 if (!this.io.equals(that.io))
7378 return false;
7379 }
7380
7381 return true;
7382 }
7383
7384 @Override
7385 public int hashCode() {
7386 return 0;
7387 }
7388
7389 public int compareTo(putMultiple_result other) {
7390 if (!getClass().equals(other.getClass())) {
7391 return getClass().getName().compareTo(other.getClass().getName());
7392 }
7393
7394 int lastComparison = 0;
7395 putMultiple_result typedOther = (putMultiple_result)other;
7396
7397 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
7398 if (lastComparison != 0) {
7399 return lastComparison;
7400 }
7401 if (isSetIo()) {
7402 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
7403 if (lastComparison != 0) {
7404 return lastComparison;
7405 }
7406 }
7407 return 0;
7408 }
7409
7410 public _Fields fieldForId(int fieldId) {
7411 return _Fields.findByThriftId(fieldId);
7412 }
7413
7414 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7415 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7416 }
7417
7418 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7419 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7420 }
7421
7422 @Override
7423 public String toString() {
7424 StringBuilder sb = new StringBuilder("putMultiple_result(");
7425 boolean first = true;
7426
7427 sb.append("io:");
7428 if (this.io == null) {
7429 sb.append("null");
7430 } else {
7431 sb.append(this.io);
7432 }
7433 first = false;
7434 sb.append(")");
7435 return sb.toString();
7436 }
7437
7438 public void validate() throws org.apache.thrift.TException {
7439
7440 }
7441
7442 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7443 try {
7444 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7445 } catch (org.apache.thrift.TException te) {
7446 throw new java.io.IOException(te);
7447 }
7448 }
7449
7450 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7451 try {
7452 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7453 } catch (org.apache.thrift.TException te) {
7454 throw new java.io.IOException(te);
7455 }
7456 }
7457
7458 private static class putMultiple_resultStandardSchemeFactory implements SchemeFactory {
7459 public putMultiple_resultStandardScheme getScheme() {
7460 return new putMultiple_resultStandardScheme();
7461 }
7462 }
7463
7464 private static class putMultiple_resultStandardScheme extends StandardScheme<putMultiple_result> {
7465
7466 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_result struct) throws org.apache.thrift.TException {
7467 org.apache.thrift.protocol.TField schemeField;
7468 iprot.readStructBegin();
7469 while (true)
7470 {
7471 schemeField = iprot.readFieldBegin();
7472 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7473 break;
7474 }
7475 switch (schemeField.id) {
7476 case 1:
7477 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
7478 struct.io = new TIOError();
7479 struct.io.read(iprot);
7480 struct.setIoIsSet(true);
7481 } else {
7482 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7483 }
7484 break;
7485 default:
7486 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7487 }
7488 iprot.readFieldEnd();
7489 }
7490 iprot.readStructEnd();
7491
7492
7493 struct.validate();
7494 }
7495
7496 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_result struct) throws org.apache.thrift.TException {
7497 struct.validate();
7498
7499 oprot.writeStructBegin(STRUCT_DESC);
7500 if (struct.io != null) {
7501 oprot.writeFieldBegin(IO_FIELD_DESC);
7502 struct.io.write(oprot);
7503 oprot.writeFieldEnd();
7504 }
7505 oprot.writeFieldStop();
7506 oprot.writeStructEnd();
7507 }
7508
7509 }
7510
7511 private static class putMultiple_resultTupleSchemeFactory implements SchemeFactory {
7512 public putMultiple_resultTupleScheme getScheme() {
7513 return new putMultiple_resultTupleScheme();
7514 }
7515 }
7516
7517 private static class putMultiple_resultTupleScheme extends TupleScheme<putMultiple_result> {
7518
7519 @Override
7520 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7521 TTupleProtocol oprot = (TTupleProtocol) prot;
7522 BitSet optionals = new BitSet();
7523 if (struct.isSetIo()) {
7524 optionals.set(0);
7525 }
7526 oprot.writeBitSet(optionals, 1);
7527 if (struct.isSetIo()) {
7528 struct.io.write(oprot);
7529 }
7530 }
7531
7532 @Override
7533 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7534 TTupleProtocol iprot = (TTupleProtocol) prot;
7535 BitSet incoming = iprot.readBitSet(1);
7536 if (incoming.get(0)) {
7537 struct.io = new TIOError();
7538 struct.io.read(iprot);
7539 struct.setIoIsSet(true);
7540 }
7541 }
7542 }
7543
7544 }
7545
7546 public static class deleteSingle_args implements org.apache.thrift.TBase<deleteSingle_args, deleteSingle_args._Fields>, java.io.Serializable, Cloneable {
7547 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_args");
7548
7549 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);
7550 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);
7551
7552 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7553 static {
7554 schemes.put(StandardScheme.class, new deleteSingle_argsStandardSchemeFactory());
7555 schemes.put(TupleScheme.class, new deleteSingle_argsTupleSchemeFactory());
7556 }
7557
7558
7559
7560
7561 public ByteBuffer table;
7562
7563
7564
7565 public TDelete deleteSingle;
7566
7567
7568 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7569
7570
7571
7572 TABLE((short)1, "table"),
7573
7574
7575
7576 DELETE_SINGLE((short)2, "deleteSingle");
7577
7578 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7579
7580 static {
7581 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7582 byName.put(field.getFieldName(), field);
7583 }
7584 }
7585
7586
7587
7588
7589 public static _Fields findByThriftId(int fieldId) {
7590 switch(fieldId) {
7591 case 1:
7592 return TABLE;
7593 case 2:
7594 return DELETE_SINGLE;
7595 default:
7596 return null;
7597 }
7598 }
7599
7600
7601
7602
7603
7604 public static _Fields findByThriftIdOrThrow(int fieldId) {
7605 _Fields fields = findByThriftId(fieldId);
7606 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7607 return fields;
7608 }
7609
7610
7611
7612
7613 public static _Fields findByName(String name) {
7614 return byName.get(name);
7615 }
7616
7617 private final short _thriftId;
7618 private final String _fieldName;
7619
7620 _Fields(short thriftId, String fieldName) {
7621 _thriftId = thriftId;
7622 _fieldName = fieldName;
7623 }
7624
7625 public short getThriftFieldId() {
7626 return _thriftId;
7627 }
7628
7629 public String getFieldName() {
7630 return _fieldName;
7631 }
7632 }
7633
7634
7635 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7636 static {
7637 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7638 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
7639 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
7640 tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED,
7641 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
7642 metaDataMap = Collections.unmodifiableMap(tmpMap);
7643 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_args.class, metaDataMap);
7644 }
7645
7646 public deleteSingle_args() {
7647 }
7648
7649 public deleteSingle_args(
7650 ByteBuffer table,
7651 TDelete deleteSingle)
7652 {
7653 this();
7654 this.table = table;
7655 this.deleteSingle = deleteSingle;
7656 }
7657
7658
7659
7660
7661 public deleteSingle_args(deleteSingle_args other) {
7662 if (other.isSetTable()) {
7663 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
7664 ;
7665 }
7666 if (other.isSetDeleteSingle()) {
7667 this.deleteSingle = new TDelete(other.deleteSingle);
7668 }
7669 }
7670
7671 public deleteSingle_args deepCopy() {
7672 return new deleteSingle_args(this);
7673 }
7674
7675 @Override
7676 public void clear() {
7677 this.table = null;
7678 this.deleteSingle = null;
7679 }
7680
7681
7682
7683
7684 public byte[] getTable() {
7685 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
7686 return table == null ? null : table.array();
7687 }
7688
7689 public ByteBuffer bufferForTable() {
7690 return table;
7691 }
7692
7693
7694
7695
7696 public deleteSingle_args setTable(byte[] table) {
7697 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
7698 return this;
7699 }
7700
7701 public deleteSingle_args setTable(ByteBuffer table) {
7702 this.table = table;
7703 return this;
7704 }
7705
7706 public void unsetTable() {
7707 this.table = null;
7708 }
7709
7710
7711 public boolean isSetTable() {
7712 return this.table != null;
7713 }
7714
7715 public void setTableIsSet(boolean value) {
7716 if (!value) {
7717 this.table = null;
7718 }
7719 }
7720
7721
7722
7723
7724 public TDelete getDeleteSingle() {
7725 return this.deleteSingle;
7726 }
7727
7728
7729
7730
7731 public deleteSingle_args setDeleteSingle(TDelete deleteSingle) {
7732 this.deleteSingle = deleteSingle;
7733 return this;
7734 }
7735
7736 public void unsetDeleteSingle() {
7737 this.deleteSingle = null;
7738 }
7739
7740
7741 public boolean isSetDeleteSingle() {
7742 return this.deleteSingle != null;
7743 }
7744
7745 public void setDeleteSingleIsSet(boolean value) {
7746 if (!value) {
7747 this.deleteSingle = null;
7748 }
7749 }
7750
7751 public void setFieldValue(_Fields field, Object value) {
7752 switch (field) {
7753 case TABLE:
7754 if (value == null) {
7755 unsetTable();
7756 } else {
7757 setTable((ByteBuffer)value);
7758 }
7759 break;
7760
7761 case DELETE_SINGLE:
7762 if (value == null) {
7763 unsetDeleteSingle();
7764 } else {
7765 setDeleteSingle((TDelete)value);
7766 }
7767 break;
7768
7769 }
7770 }
7771
7772 public Object getFieldValue(_Fields field) {
7773 switch (field) {
7774 case TABLE:
7775 return getTable();
7776
7777 case DELETE_SINGLE:
7778 return getDeleteSingle();
7779
7780 }
7781 throw new IllegalStateException();
7782 }
7783
7784
7785 public boolean isSet(_Fields field) {
7786 if (field == null) {
7787 throw new IllegalArgumentException();
7788 }
7789
7790 switch (field) {
7791 case TABLE:
7792 return isSetTable();
7793 case DELETE_SINGLE:
7794 return isSetDeleteSingle();
7795 }
7796 throw new IllegalStateException();
7797 }
7798
7799 @Override
7800 public boolean equals(Object that) {
7801 if (that == null)
7802 return false;
7803 if (that instanceof deleteSingle_args)
7804 return this.equals((deleteSingle_args)that);
7805 return false;
7806 }
7807
7808 public boolean equals(deleteSingle_args that) {
7809 if (that == null)
7810 return false;
7811
7812 boolean this_present_table = true && this.isSetTable();
7813 boolean that_present_table = true && that.isSetTable();
7814 if (this_present_table || that_present_table) {
7815 if (!(this_present_table && that_present_table))
7816 return false;
7817 if (!this.table.equals(that.table))
7818 return false;
7819 }
7820
7821 boolean this_present_deleteSingle = true && this.isSetDeleteSingle();
7822 boolean that_present_deleteSingle = true && that.isSetDeleteSingle();
7823 if (this_present_deleteSingle || that_present_deleteSingle) {
7824 if (!(this_present_deleteSingle && that_present_deleteSingle))
7825 return false;
7826 if (!this.deleteSingle.equals(that.deleteSingle))
7827 return false;
7828 }
7829
7830 return true;
7831 }
7832
7833 @Override
7834 public int hashCode() {
7835 return 0;
7836 }
7837
7838 public int compareTo(deleteSingle_args other) {
7839 if (!getClass().equals(other.getClass())) {
7840 return getClass().getName().compareTo(other.getClass().getName());
7841 }
7842
7843 int lastComparison = 0;
7844 deleteSingle_args typedOther = (deleteSingle_args)other;
7845
7846 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
7847 if (lastComparison != 0) {
7848 return lastComparison;
7849 }
7850 if (isSetTable()) {
7851 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
7852 if (lastComparison != 0) {
7853 return lastComparison;
7854 }
7855 }
7856 lastComparison = Boolean.valueOf(isSetDeleteSingle()).compareTo(typedOther.isSetDeleteSingle());
7857 if (lastComparison != 0) {
7858 return lastComparison;
7859 }
7860 if (isSetDeleteSingle()) {
7861 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteSingle, typedOther.deleteSingle);
7862 if (lastComparison != 0) {
7863 return lastComparison;
7864 }
7865 }
7866 return 0;
7867 }
7868
7869 public _Fields fieldForId(int fieldId) {
7870 return _Fields.findByThriftId(fieldId);
7871 }
7872
7873 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7874 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7875 }
7876
7877 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7878 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7879 }
7880
7881 @Override
7882 public String toString() {
7883 StringBuilder sb = new StringBuilder("deleteSingle_args(");
7884 boolean first = true;
7885
7886 sb.append("table:");
7887 if (this.table == null) {
7888 sb.append("null");
7889 } else {
7890 org.apache.thrift.TBaseHelper.toString(this.table, sb);
7891 }
7892 first = false;
7893 if (!first) sb.append(", ");
7894 sb.append("deleteSingle:");
7895 if (this.deleteSingle == null) {
7896 sb.append("null");
7897 } else {
7898 sb.append(this.deleteSingle);
7899 }
7900 first = false;
7901 sb.append(")");
7902 return sb.toString();
7903 }
7904
7905 public void validate() throws org.apache.thrift.TException {
7906
7907 if (table == null) {
7908 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
7909 }
7910 if (deleteSingle == null) {
7911 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deleteSingle' was not present! Struct: " + toString());
7912 }
7913 }
7914
7915 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7916 try {
7917 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7918 } catch (org.apache.thrift.TException te) {
7919 throw new java.io.IOException(te);
7920 }
7921 }
7922
7923 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7924 try {
7925 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7926 } catch (org.apache.thrift.TException te) {
7927 throw new java.io.IOException(te);
7928 }
7929 }
7930
7931 private static class deleteSingle_argsStandardSchemeFactory implements SchemeFactory {
7932 public deleteSingle_argsStandardScheme getScheme() {
7933 return new deleteSingle_argsStandardScheme();
7934 }
7935 }
7936
7937 private static class deleteSingle_argsStandardScheme extends StandardScheme<deleteSingle_args> {
7938
7939 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_args struct) throws org.apache.thrift.TException {
7940 org.apache.thrift.protocol.TField schemeField;
7941 iprot.readStructBegin();
7942 while (true)
7943 {
7944 schemeField = iprot.readFieldBegin();
7945 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7946 break;
7947 }
7948 switch (schemeField.id) {
7949 case 1:
7950 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
7951 struct.table = iprot.readBinary();
7952 struct.setTableIsSet(true);
7953 } else {
7954 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7955 }
7956 break;
7957 case 2:
7958 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
7959 struct.deleteSingle = new TDelete();
7960 struct.deleteSingle.read(iprot);
7961 struct.setDeleteSingleIsSet(true);
7962 } else {
7963 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7964 }
7965 break;
7966 default:
7967 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7968 }
7969 iprot.readFieldEnd();
7970 }
7971 iprot.readStructEnd();
7972
7973
7974 struct.validate();
7975 }
7976
7977 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_args struct) throws org.apache.thrift.TException {
7978 struct.validate();
7979
7980 oprot.writeStructBegin(STRUCT_DESC);
7981 if (struct.table != null) {
7982 oprot.writeFieldBegin(TABLE_FIELD_DESC);
7983 oprot.writeBinary(struct.table);
7984 oprot.writeFieldEnd();
7985 }
7986 if (struct.deleteSingle != null) {
7987 oprot.writeFieldBegin(DELETE_SINGLE_FIELD_DESC);
7988 struct.deleteSingle.write(oprot);
7989 oprot.writeFieldEnd();
7990 }
7991 oprot.writeFieldStop();
7992 oprot.writeStructEnd();
7993 }
7994
7995 }
7996
7997 private static class deleteSingle_argsTupleSchemeFactory implements SchemeFactory {
7998 public deleteSingle_argsTupleScheme getScheme() {
7999 return new deleteSingle_argsTupleScheme();
8000 }
8001 }
8002
8003 private static class deleteSingle_argsTupleScheme extends TupleScheme<deleteSingle_args> {
8004
8005 @Override
8006 public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
8007 TTupleProtocol oprot = (TTupleProtocol) prot;
8008 oprot.writeBinary(struct.table);
8009 struct.deleteSingle.write(oprot);
8010 }
8011
8012 @Override
8013 public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
8014 TTupleProtocol iprot = (TTupleProtocol) prot;
8015 struct.table = iprot.readBinary();
8016 struct.setTableIsSet(true);
8017 struct.deleteSingle = new TDelete();
8018 struct.deleteSingle.read(iprot);
8019 struct.setDeleteSingleIsSet(true);
8020 }
8021 }
8022
8023 }
8024
8025 public static class deleteSingle_result implements org.apache.thrift.TBase<deleteSingle_result, deleteSingle_result._Fields>, java.io.Serializable, Cloneable {
8026 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_result");
8027
8028 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);
8029
8030 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8031 static {
8032 schemes.put(StandardScheme.class, new deleteSingle_resultStandardSchemeFactory());
8033 schemes.put(TupleScheme.class, new deleteSingle_resultTupleSchemeFactory());
8034 }
8035
8036 public TIOError io;
8037
8038
8039 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8040 IO((short)1, "io");
8041
8042 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8043
8044 static {
8045 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8046 byName.put(field.getFieldName(), field);
8047 }
8048 }
8049
8050
8051
8052
8053 public static _Fields findByThriftId(int fieldId) {
8054 switch(fieldId) {
8055 case 1:
8056 return IO;
8057 default:
8058 return null;
8059 }
8060 }
8061
8062
8063
8064
8065
8066 public static _Fields findByThriftIdOrThrow(int fieldId) {
8067 _Fields fields = findByThriftId(fieldId);
8068 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8069 return fields;
8070 }
8071
8072
8073
8074
8075 public static _Fields findByName(String name) {
8076 return byName.get(name);
8077 }
8078
8079 private final short _thriftId;
8080 private final String _fieldName;
8081
8082 _Fields(short thriftId, String fieldName) {
8083 _thriftId = thriftId;
8084 _fieldName = fieldName;
8085 }
8086
8087 public short getThriftFieldId() {
8088 return _thriftId;
8089 }
8090
8091 public String getFieldName() {
8092 return _fieldName;
8093 }
8094 }
8095
8096
8097 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8098 static {
8099 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8100 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
8101 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
8102 metaDataMap = Collections.unmodifiableMap(tmpMap);
8103 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_result.class, metaDataMap);
8104 }
8105
8106 public deleteSingle_result() {
8107 }
8108
8109 public deleteSingle_result(
8110 TIOError io)
8111 {
8112 this();
8113 this.io = io;
8114 }
8115
8116
8117
8118
8119 public deleteSingle_result(deleteSingle_result other) {
8120 if (other.isSetIo()) {
8121 this.io = new TIOError(other.io);
8122 }
8123 }
8124
8125 public deleteSingle_result deepCopy() {
8126 return new deleteSingle_result(this);
8127 }
8128
8129 @Override
8130 public void clear() {
8131 this.io = null;
8132 }
8133
8134 public TIOError getIo() {
8135 return this.io;
8136 }
8137
8138 public deleteSingle_result setIo(TIOError io) {
8139 this.io = io;
8140 return this;
8141 }
8142
8143 public void unsetIo() {
8144 this.io = null;
8145 }
8146
8147
8148 public boolean isSetIo() {
8149 return this.io != null;
8150 }
8151
8152 public void setIoIsSet(boolean value) {
8153 if (!value) {
8154 this.io = null;
8155 }
8156 }
8157
8158 public void setFieldValue(_Fields field, Object value) {
8159 switch (field) {
8160 case IO:
8161 if (value == null) {
8162 unsetIo();
8163 } else {
8164 setIo((TIOError)value);
8165 }
8166 break;
8167
8168 }
8169 }
8170
8171 public Object getFieldValue(_Fields field) {
8172 switch (field) {
8173 case IO:
8174 return getIo();
8175
8176 }
8177 throw new IllegalStateException();
8178 }
8179
8180
8181 public boolean isSet(_Fields field) {
8182 if (field == null) {
8183 throw new IllegalArgumentException();
8184 }
8185
8186 switch (field) {
8187 case IO:
8188 return isSetIo();
8189 }
8190 throw new IllegalStateException();
8191 }
8192
8193 @Override
8194 public boolean equals(Object that) {
8195 if (that == null)
8196 return false;
8197 if (that instanceof deleteSingle_result)
8198 return this.equals((deleteSingle_result)that);
8199 return false;
8200 }
8201
8202 public boolean equals(deleteSingle_result that) {
8203 if (that == null)
8204 return false;
8205
8206 boolean this_present_io = true && this.isSetIo();
8207 boolean that_present_io = true && that.isSetIo();
8208 if (this_present_io || that_present_io) {
8209 if (!(this_present_io && that_present_io))
8210 return false;
8211 if (!this.io.equals(that.io))
8212 return false;
8213 }
8214
8215 return true;
8216 }
8217
8218 @Override
8219 public int hashCode() {
8220 return 0;
8221 }
8222
8223 public int compareTo(deleteSingle_result other) {
8224 if (!getClass().equals(other.getClass())) {
8225 return getClass().getName().compareTo(other.getClass().getName());
8226 }
8227
8228 int lastComparison = 0;
8229 deleteSingle_result typedOther = (deleteSingle_result)other;
8230
8231 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
8232 if (lastComparison != 0) {
8233 return lastComparison;
8234 }
8235 if (isSetIo()) {
8236 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
8237 if (lastComparison != 0) {
8238 return lastComparison;
8239 }
8240 }
8241 return 0;
8242 }
8243
8244 public _Fields fieldForId(int fieldId) {
8245 return _Fields.findByThriftId(fieldId);
8246 }
8247
8248 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8249 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8250 }
8251
8252 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8253 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8254 }
8255
8256 @Override
8257 public String toString() {
8258 StringBuilder sb = new StringBuilder("deleteSingle_result(");
8259 boolean first = true;
8260
8261 sb.append("io:");
8262 if (this.io == null) {
8263 sb.append("null");
8264 } else {
8265 sb.append(this.io);
8266 }
8267 first = false;
8268 sb.append(")");
8269 return sb.toString();
8270 }
8271
8272 public void validate() throws org.apache.thrift.TException {
8273
8274 }
8275
8276 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8277 try {
8278 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8279 } catch (org.apache.thrift.TException te) {
8280 throw new java.io.IOException(te);
8281 }
8282 }
8283
8284 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8285 try {
8286 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8287 } catch (org.apache.thrift.TException te) {
8288 throw new java.io.IOException(te);
8289 }
8290 }
8291
8292 private static class deleteSingle_resultStandardSchemeFactory implements SchemeFactory {
8293 public deleteSingle_resultStandardScheme getScheme() {
8294 return new deleteSingle_resultStandardScheme();
8295 }
8296 }
8297
8298 private static class deleteSingle_resultStandardScheme extends StandardScheme<deleteSingle_result> {
8299
8300 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8301 org.apache.thrift.protocol.TField schemeField;
8302 iprot.readStructBegin();
8303 while (true)
8304 {
8305 schemeField = iprot.readFieldBegin();
8306 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
8307 break;
8308 }
8309 switch (schemeField.id) {
8310 case 1:
8311 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
8312 struct.io = new TIOError();
8313 struct.io.read(iprot);
8314 struct.setIoIsSet(true);
8315 } else {
8316 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8317 }
8318 break;
8319 default:
8320 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8321 }
8322 iprot.readFieldEnd();
8323 }
8324 iprot.readStructEnd();
8325
8326
8327 struct.validate();
8328 }
8329
8330 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8331 struct.validate();
8332
8333 oprot.writeStructBegin(STRUCT_DESC);
8334 if (struct.io != null) {
8335 oprot.writeFieldBegin(IO_FIELD_DESC);
8336 struct.io.write(oprot);
8337 oprot.writeFieldEnd();
8338 }
8339 oprot.writeFieldStop();
8340 oprot.writeStructEnd();
8341 }
8342
8343 }
8344
8345 private static class deleteSingle_resultTupleSchemeFactory implements SchemeFactory {
8346 public deleteSingle_resultTupleScheme getScheme() {
8347 return new deleteSingle_resultTupleScheme();
8348 }
8349 }
8350
8351 private static class deleteSingle_resultTupleScheme extends TupleScheme<deleteSingle_result> {
8352
8353 @Override
8354 public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8355 TTupleProtocol oprot = (TTupleProtocol) prot;
8356 BitSet optionals = new BitSet();
8357 if (struct.isSetIo()) {
8358 optionals.set(0);
8359 }
8360 oprot.writeBitSet(optionals, 1);
8361 if (struct.isSetIo()) {
8362 struct.io.write(oprot);
8363 }
8364 }
8365
8366 @Override
8367 public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8368 TTupleProtocol iprot = (TTupleProtocol) prot;
8369 BitSet incoming = iprot.readBitSet(1);
8370 if (incoming.get(0)) {
8371 struct.io = new TIOError();
8372 struct.io.read(iprot);
8373 struct.setIoIsSet(true);
8374 }
8375 }
8376 }
8377
8378 }
8379
8380 public static class deleteMultiple_args implements org.apache.thrift.TBase<deleteMultiple_args, deleteMultiple_args._Fields>, java.io.Serializable, Cloneable {
8381 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_args");
8382
8383 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);
8384 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);
8385
8386 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8387 static {
8388 schemes.put(StandardScheme.class, new deleteMultiple_argsStandardSchemeFactory());
8389 schemes.put(TupleScheme.class, new deleteMultiple_argsTupleSchemeFactory());
8390 }
8391
8392
8393
8394
8395 public ByteBuffer table;
8396
8397
8398
8399 public List<TDelete> deletes;
8400
8401
8402 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8403
8404
8405
8406 TABLE((short)1, "table"),
8407
8408
8409
8410 DELETES((short)2, "deletes");
8411
8412 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8413
8414 static {
8415 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8416 byName.put(field.getFieldName(), field);
8417 }
8418 }
8419
8420
8421
8422
8423 public static _Fields findByThriftId(int fieldId) {
8424 switch(fieldId) {
8425 case 1:
8426 return TABLE;
8427 case 2:
8428 return DELETES;
8429 default:
8430 return null;
8431 }
8432 }
8433
8434
8435
8436
8437
8438 public static _Fields findByThriftIdOrThrow(int fieldId) {
8439 _Fields fields = findByThriftId(fieldId);
8440 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8441 return fields;
8442 }
8443
8444
8445
8446
8447 public static _Fields findByName(String name) {
8448 return byName.get(name);
8449 }
8450
8451 private final short _thriftId;
8452 private final String _fieldName;
8453
8454 _Fields(short thriftId, String fieldName) {
8455 _thriftId = thriftId;
8456 _fieldName = fieldName;
8457 }
8458
8459 public short getThriftFieldId() {
8460 return _thriftId;
8461 }
8462
8463 public String getFieldName() {
8464 return _fieldName;
8465 }
8466 }
8467
8468
8469 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8470 static {
8471 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8472 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
8473 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
8474 tmpMap.put(_Fields.DELETES, new org.apache.thrift.meta_data.FieldMetaData("deletes", org.apache.thrift.TFieldRequirementType.REQUIRED,
8475 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
8476 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
8477 metaDataMap = Collections.unmodifiableMap(tmpMap);
8478 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_args.class, metaDataMap);
8479 }
8480
8481 public deleteMultiple_args() {
8482 }
8483
8484 public deleteMultiple_args(
8485 ByteBuffer table,
8486 List<TDelete> deletes)
8487 {
8488 this();
8489 this.table = table;
8490 this.deletes = deletes;
8491 }
8492
8493
8494
8495
8496 public deleteMultiple_args(deleteMultiple_args other) {
8497 if (other.isSetTable()) {
8498 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
8499 ;
8500 }
8501 if (other.isSetDeletes()) {
8502 List<TDelete> __this__deletes = new ArrayList<TDelete>();
8503 for (TDelete other_element : other.deletes) {
8504 __this__deletes.add(new TDelete(other_element));
8505 }
8506 this.deletes = __this__deletes;
8507 }
8508 }
8509
8510 public deleteMultiple_args deepCopy() {
8511 return new deleteMultiple_args(this);
8512 }
8513
8514 @Override
8515 public void clear() {
8516 this.table = null;
8517 this.deletes = null;
8518 }
8519
8520
8521
8522
8523 public byte[] getTable() {
8524 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
8525 return table == null ? null : table.array();
8526 }
8527
8528 public ByteBuffer bufferForTable() {
8529 return table;
8530 }
8531
8532
8533
8534
8535 public deleteMultiple_args setTable(byte[] table) {
8536 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
8537 return this;
8538 }
8539
8540 public deleteMultiple_args setTable(ByteBuffer table) {
8541 this.table = table;
8542 return this;
8543 }
8544
8545 public void unsetTable() {
8546 this.table = null;
8547 }
8548
8549
8550 public boolean isSetTable() {
8551 return this.table != null;
8552 }
8553
8554 public void setTableIsSet(boolean value) {
8555 if (!value) {
8556 this.table = null;
8557 }
8558 }
8559
8560 public int getDeletesSize() {
8561 return (this.deletes == null) ? 0 : this.deletes.size();
8562 }
8563
8564 public java.util.Iterator<TDelete> getDeletesIterator() {
8565 return (this.deletes == null) ? null : this.deletes.iterator();
8566 }
8567
8568 public void addToDeletes(TDelete elem) {
8569 if (this.deletes == null) {
8570 this.deletes = new ArrayList<TDelete>();
8571 }
8572 this.deletes.add(elem);
8573 }
8574
8575
8576
8577
8578 public List<TDelete> getDeletes() {
8579 return this.deletes;
8580 }
8581
8582
8583
8584
8585 public deleteMultiple_args setDeletes(List<TDelete> deletes) {
8586 this.deletes = deletes;
8587 return this;
8588 }
8589
8590 public void unsetDeletes() {
8591 this.deletes = null;
8592 }
8593
8594
8595 public boolean isSetDeletes() {
8596 return this.deletes != null;
8597 }
8598
8599 public void setDeletesIsSet(boolean value) {
8600 if (!value) {
8601 this.deletes = null;
8602 }
8603 }
8604
8605 public void setFieldValue(_Fields field, Object value) {
8606 switch (field) {
8607 case TABLE:
8608 if (value == null) {
8609 unsetTable();
8610 } else {
8611 setTable((ByteBuffer)value);
8612 }
8613 break;
8614
8615 case DELETES:
8616 if (value == null) {
8617 unsetDeletes();
8618 } else {
8619 setDeletes((List<TDelete>)value);
8620 }
8621 break;
8622
8623 }
8624 }
8625
8626 public Object getFieldValue(_Fields field) {
8627 switch (field) {
8628 case TABLE:
8629 return getTable();
8630
8631 case DELETES:
8632 return getDeletes();
8633
8634 }
8635 throw new IllegalStateException();
8636 }
8637
8638
8639 public boolean isSet(_Fields field) {
8640 if (field == null) {
8641 throw new IllegalArgumentException();
8642 }
8643
8644 switch (field) {
8645 case TABLE:
8646 return isSetTable();
8647 case DELETES:
8648 return isSetDeletes();
8649 }
8650 throw new IllegalStateException();
8651 }
8652
8653 @Override
8654 public boolean equals(Object that) {
8655 if (that == null)
8656 return false;
8657 if (that instanceof deleteMultiple_args)
8658 return this.equals((deleteMultiple_args)that);
8659 return false;
8660 }
8661
8662 public boolean equals(deleteMultiple_args that) {
8663 if (that == null)
8664 return false;
8665
8666 boolean this_present_table = true && this.isSetTable();
8667 boolean that_present_table = true && that.isSetTable();
8668 if (this_present_table || that_present_table) {
8669 if (!(this_present_table && that_present_table))
8670 return false;
8671 if (!this.table.equals(that.table))
8672 return false;
8673 }
8674
8675 boolean this_present_deletes = true && this.isSetDeletes();
8676 boolean that_present_deletes = true && that.isSetDeletes();
8677 if (this_present_deletes || that_present_deletes) {
8678 if (!(this_present_deletes && that_present_deletes))
8679 return false;
8680 if (!this.deletes.equals(that.deletes))
8681 return false;
8682 }
8683
8684 return true;
8685 }
8686
8687 @Override
8688 public int hashCode() {
8689 return 0;
8690 }
8691
8692 public int compareTo(deleteMultiple_args other) {
8693 if (!getClass().equals(other.getClass())) {
8694 return getClass().getName().compareTo(other.getClass().getName());
8695 }
8696
8697 int lastComparison = 0;
8698 deleteMultiple_args typedOther = (deleteMultiple_args)other;
8699
8700 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
8701 if (lastComparison != 0) {
8702 return lastComparison;
8703 }
8704 if (isSetTable()) {
8705 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
8706 if (lastComparison != 0) {
8707 return lastComparison;
8708 }
8709 }
8710 lastComparison = Boolean.valueOf(isSetDeletes()).compareTo(typedOther.isSetDeletes());
8711 if (lastComparison != 0) {
8712 return lastComparison;
8713 }
8714 if (isSetDeletes()) {
8715 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deletes, typedOther.deletes);
8716 if (lastComparison != 0) {
8717 return lastComparison;
8718 }
8719 }
8720 return 0;
8721 }
8722
8723 public _Fields fieldForId(int fieldId) {
8724 return _Fields.findByThriftId(fieldId);
8725 }
8726
8727 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8728 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8729 }
8730
8731 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8732 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8733 }
8734
8735 @Override
8736 public String toString() {
8737 StringBuilder sb = new StringBuilder("deleteMultiple_args(");
8738 boolean first = true;
8739
8740 sb.append("table:");
8741 if (this.table == null) {
8742 sb.append("null");
8743 } else {
8744 org.apache.thrift.TBaseHelper.toString(this.table, sb);
8745 }
8746 first = false;
8747 if (!first) sb.append(", ");
8748 sb.append("deletes:");
8749 if (this.deletes == null) {
8750 sb.append("null");
8751 } else {
8752 sb.append(this.deletes);
8753 }
8754 first = false;
8755 sb.append(")");
8756 return sb.toString();
8757 }
8758
8759 public void validate() throws org.apache.thrift.TException {
8760
8761 if (table == null) {
8762 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
8763 }
8764 if (deletes == null) {
8765 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deletes' was not present! Struct: " + toString());
8766 }
8767 }
8768
8769 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8770 try {
8771 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8772 } catch (org.apache.thrift.TException te) {
8773 throw new java.io.IOException(te);
8774 }
8775 }
8776
8777 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8778 try {
8779 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8780 } catch (org.apache.thrift.TException te) {
8781 throw new java.io.IOException(te);
8782 }
8783 }
8784
8785 private static class deleteMultiple_argsStandardSchemeFactory implements SchemeFactory {
8786 public deleteMultiple_argsStandardScheme getScheme() {
8787 return new deleteMultiple_argsStandardScheme();
8788 }
8789 }
8790
8791 private static class deleteMultiple_argsStandardScheme extends StandardScheme<deleteMultiple_args> {
8792
8793 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8794 org.apache.thrift.protocol.TField schemeField;
8795 iprot.readStructBegin();
8796 while (true)
8797 {
8798 schemeField = iprot.readFieldBegin();
8799 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
8800 break;
8801 }
8802 switch (schemeField.id) {
8803 case 1:
8804 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
8805 struct.table = iprot.readBinary();
8806 struct.setTableIsSet(true);
8807 } else {
8808 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8809 }
8810 break;
8811 case 2:
8812 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
8813 {
8814 org.apache.thrift.protocol.TList _list130 = iprot.readListBegin();
8815 struct.deletes = new ArrayList<TDelete>(_list130.size);
8816 for (int _i131 = 0; _i131 < _list130.size; ++_i131)
8817 {
8818 TDelete _elem132;
8819 _elem132 = new TDelete();
8820 _elem132.read(iprot);
8821 struct.deletes.add(_elem132);
8822 }
8823 iprot.readListEnd();
8824 }
8825 struct.setDeletesIsSet(true);
8826 } else {
8827 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8828 }
8829 break;
8830 default:
8831 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8832 }
8833 iprot.readFieldEnd();
8834 }
8835 iprot.readStructEnd();
8836
8837
8838 struct.validate();
8839 }
8840
8841 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8842 struct.validate();
8843
8844 oprot.writeStructBegin(STRUCT_DESC);
8845 if (struct.table != null) {
8846 oprot.writeFieldBegin(TABLE_FIELD_DESC);
8847 oprot.writeBinary(struct.table);
8848 oprot.writeFieldEnd();
8849 }
8850 if (struct.deletes != null) {
8851 oprot.writeFieldBegin(DELETES_FIELD_DESC);
8852 {
8853 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.deletes.size()));
8854 for (TDelete _iter133 : struct.deletes)
8855 {
8856 _iter133.write(oprot);
8857 }
8858 oprot.writeListEnd();
8859 }
8860 oprot.writeFieldEnd();
8861 }
8862 oprot.writeFieldStop();
8863 oprot.writeStructEnd();
8864 }
8865
8866 }
8867
8868 private static class deleteMultiple_argsTupleSchemeFactory implements SchemeFactory {
8869 public deleteMultiple_argsTupleScheme getScheme() {
8870 return new deleteMultiple_argsTupleScheme();
8871 }
8872 }
8873
8874 private static class deleteMultiple_argsTupleScheme extends TupleScheme<deleteMultiple_args> {
8875
8876 @Override
8877 public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8878 TTupleProtocol oprot = (TTupleProtocol) prot;
8879 oprot.writeBinary(struct.table);
8880 {
8881 oprot.writeI32(struct.deletes.size());
8882 for (TDelete _iter134 : struct.deletes)
8883 {
8884 _iter134.write(oprot);
8885 }
8886 }
8887 }
8888
8889 @Override
8890 public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8891 TTupleProtocol iprot = (TTupleProtocol) prot;
8892 struct.table = iprot.readBinary();
8893 struct.setTableIsSet(true);
8894 {
8895 org.apache.thrift.protocol.TList _list135 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
8896 struct.deletes = new ArrayList<TDelete>(_list135.size);
8897 for (int _i136 = 0; _i136 < _list135.size; ++_i136)
8898 {
8899 TDelete _elem137;
8900 _elem137 = new TDelete();
8901 _elem137.read(iprot);
8902 struct.deletes.add(_elem137);
8903 }
8904 }
8905 struct.setDeletesIsSet(true);
8906 }
8907 }
8908
8909 }
8910
8911 public static class deleteMultiple_result implements org.apache.thrift.TBase<deleteMultiple_result, deleteMultiple_result._Fields>, java.io.Serializable, Cloneable {
8912 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_result");
8913
8914 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);
8915 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);
8916
8917 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8918 static {
8919 schemes.put(StandardScheme.class, new deleteMultiple_resultStandardSchemeFactory());
8920 schemes.put(TupleScheme.class, new deleteMultiple_resultTupleSchemeFactory());
8921 }
8922
8923 public List<TDelete> success;
8924 public TIOError io;
8925
8926
8927 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8928 SUCCESS((short)0, "success"),
8929 IO((short)1, "io");
8930
8931 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8932
8933 static {
8934 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8935 byName.put(field.getFieldName(), field);
8936 }
8937 }
8938
8939
8940
8941
8942 public static _Fields findByThriftId(int fieldId) {
8943 switch(fieldId) {
8944 case 0:
8945 return SUCCESS;
8946 case 1:
8947 return IO;
8948 default:
8949 return null;
8950 }
8951 }
8952
8953
8954
8955
8956
8957 public static _Fields findByThriftIdOrThrow(int fieldId) {
8958 _Fields fields = findByThriftId(fieldId);
8959 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8960 return fields;
8961 }
8962
8963
8964
8965
8966 public static _Fields findByName(String name) {
8967 return byName.get(name);
8968 }
8969
8970 private final short _thriftId;
8971 private final String _fieldName;
8972
8973 _Fields(short thriftId, String fieldName) {
8974 _thriftId = thriftId;
8975 _fieldName = fieldName;
8976 }
8977
8978 public short getThriftFieldId() {
8979 return _thriftId;
8980 }
8981
8982 public String getFieldName() {
8983 return _fieldName;
8984 }
8985 }
8986
8987
8988 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8989 static {
8990 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8991 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
8992 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
8993 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
8994 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
8995 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
8996 metaDataMap = Collections.unmodifiableMap(tmpMap);
8997 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_result.class, metaDataMap);
8998 }
8999
9000 public deleteMultiple_result() {
9001 }
9002
9003 public deleteMultiple_result(
9004 List<TDelete> success,
9005 TIOError io)
9006 {
9007 this();
9008 this.success = success;
9009 this.io = io;
9010 }
9011
9012
9013
9014
9015 public deleteMultiple_result(deleteMultiple_result other) {
9016 if (other.isSetSuccess()) {
9017 List<TDelete> __this__success = new ArrayList<TDelete>();
9018 for (TDelete other_element : other.success) {
9019 __this__success.add(new TDelete(other_element));
9020 }
9021 this.success = __this__success;
9022 }
9023 if (other.isSetIo()) {
9024 this.io = new TIOError(other.io);
9025 }
9026 }
9027
9028 public deleteMultiple_result deepCopy() {
9029 return new deleteMultiple_result(this);
9030 }
9031
9032 @Override
9033 public void clear() {
9034 this.success = null;
9035 this.io = null;
9036 }
9037
9038 public int getSuccessSize() {
9039 return (this.success == null) ? 0 : this.success.size();
9040 }
9041
9042 public java.util.Iterator<TDelete> getSuccessIterator() {
9043 return (this.success == null) ? null : this.success.iterator();
9044 }
9045
9046 public void addToSuccess(TDelete elem) {
9047 if (this.success == null) {
9048 this.success = new ArrayList<TDelete>();
9049 }
9050 this.success.add(elem);
9051 }
9052
9053 public List<TDelete> getSuccess() {
9054 return this.success;
9055 }
9056
9057 public deleteMultiple_result setSuccess(List<TDelete> success) {
9058 this.success = success;
9059 return this;
9060 }
9061
9062 public void unsetSuccess() {
9063 this.success = null;
9064 }
9065
9066
9067 public boolean isSetSuccess() {
9068 return this.success != null;
9069 }
9070
9071 public void setSuccessIsSet(boolean value) {
9072 if (!value) {
9073 this.success = null;
9074 }
9075 }
9076
9077 public TIOError getIo() {
9078 return this.io;
9079 }
9080
9081 public deleteMultiple_result setIo(TIOError io) {
9082 this.io = io;
9083 return this;
9084 }
9085
9086 public void unsetIo() {
9087 this.io = null;
9088 }
9089
9090
9091 public boolean isSetIo() {
9092 return this.io != null;
9093 }
9094
9095 public void setIoIsSet(boolean value) {
9096 if (!value) {
9097 this.io = null;
9098 }
9099 }
9100
9101 public void setFieldValue(_Fields field, Object value) {
9102 switch (field) {
9103 case SUCCESS:
9104 if (value == null) {
9105 unsetSuccess();
9106 } else {
9107 setSuccess((List<TDelete>)value);
9108 }
9109 break;
9110
9111 case IO:
9112 if (value == null) {
9113 unsetIo();
9114 } else {
9115 setIo((TIOError)value);
9116 }
9117 break;
9118
9119 }
9120 }
9121
9122 public Object getFieldValue(_Fields field) {
9123 switch (field) {
9124 case SUCCESS:
9125 return getSuccess();
9126
9127 case IO:
9128 return getIo();
9129
9130 }
9131 throw new IllegalStateException();
9132 }
9133
9134
9135 public boolean isSet(_Fields field) {
9136 if (field == null) {
9137 throw new IllegalArgumentException();
9138 }
9139
9140 switch (field) {
9141 case SUCCESS:
9142 return isSetSuccess();
9143 case IO:
9144 return isSetIo();
9145 }
9146 throw new IllegalStateException();
9147 }
9148
9149 @Override
9150 public boolean equals(Object that) {
9151 if (that == null)
9152 return false;
9153 if (that instanceof deleteMultiple_result)
9154 return this.equals((deleteMultiple_result)that);
9155 return false;
9156 }
9157
9158 public boolean equals(deleteMultiple_result that) {
9159 if (that == null)
9160 return false;
9161
9162 boolean this_present_success = true && this.isSetSuccess();
9163 boolean that_present_success = true && that.isSetSuccess();
9164 if (this_present_success || that_present_success) {
9165 if (!(this_present_success && that_present_success))
9166 return false;
9167 if (!this.success.equals(that.success))
9168 return false;
9169 }
9170
9171 boolean this_present_io = true && this.isSetIo();
9172 boolean that_present_io = true && that.isSetIo();
9173 if (this_present_io || that_present_io) {
9174 if (!(this_present_io && that_present_io))
9175 return false;
9176 if (!this.io.equals(that.io))
9177 return false;
9178 }
9179
9180 return true;
9181 }
9182
9183 @Override
9184 public int hashCode() {
9185 return 0;
9186 }
9187
9188 public int compareTo(deleteMultiple_result other) {
9189 if (!getClass().equals(other.getClass())) {
9190 return getClass().getName().compareTo(other.getClass().getName());
9191 }
9192
9193 int lastComparison = 0;
9194 deleteMultiple_result typedOther = (deleteMultiple_result)other;
9195
9196 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
9197 if (lastComparison != 0) {
9198 return lastComparison;
9199 }
9200 if (isSetSuccess()) {
9201 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
9202 if (lastComparison != 0) {
9203 return lastComparison;
9204 }
9205 }
9206 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
9207 if (lastComparison != 0) {
9208 return lastComparison;
9209 }
9210 if (isSetIo()) {
9211 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
9212 if (lastComparison != 0) {
9213 return lastComparison;
9214 }
9215 }
9216 return 0;
9217 }
9218
9219 public _Fields fieldForId(int fieldId) {
9220 return _Fields.findByThriftId(fieldId);
9221 }
9222
9223 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
9224 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
9225 }
9226
9227 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
9228 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
9229 }
9230
9231 @Override
9232 public String toString() {
9233 StringBuilder sb = new StringBuilder("deleteMultiple_result(");
9234 boolean first = true;
9235
9236 sb.append("success:");
9237 if (this.success == null) {
9238 sb.append("null");
9239 } else {
9240 sb.append(this.success);
9241 }
9242 first = false;
9243 if (!first) sb.append(", ");
9244 sb.append("io:");
9245 if (this.io == null) {
9246 sb.append("null");
9247 } else {
9248 sb.append(this.io);
9249 }
9250 first = false;
9251 sb.append(")");
9252 return sb.toString();
9253 }
9254
9255 public void validate() throws org.apache.thrift.TException {
9256
9257 }
9258
9259 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
9260 try {
9261 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
9262 } catch (org.apache.thrift.TException te) {
9263 throw new java.io.IOException(te);
9264 }
9265 }
9266
9267 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
9268 try {
9269 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
9270 } catch (org.apache.thrift.TException te) {
9271 throw new java.io.IOException(te);
9272 }
9273 }
9274
9275 private static class deleteMultiple_resultStandardSchemeFactory implements SchemeFactory {
9276 public deleteMultiple_resultStandardScheme getScheme() {
9277 return new deleteMultiple_resultStandardScheme();
9278 }
9279 }
9280
9281 private static class deleteMultiple_resultStandardScheme extends StandardScheme<deleteMultiple_result> {
9282
9283 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9284 org.apache.thrift.protocol.TField schemeField;
9285 iprot.readStructBegin();
9286 while (true)
9287 {
9288 schemeField = iprot.readFieldBegin();
9289 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
9290 break;
9291 }
9292 switch (schemeField.id) {
9293 case 0:
9294 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
9295 {
9296 org.apache.thrift.protocol.TList _list138 = iprot.readListBegin();
9297 struct.success = new ArrayList<TDelete>(_list138.size);
9298 for (int _i139 = 0; _i139 < _list138.size; ++_i139)
9299 {
9300 TDelete _elem140;
9301 _elem140 = new TDelete();
9302 _elem140.read(iprot);
9303 struct.success.add(_elem140);
9304 }
9305 iprot.readListEnd();
9306 }
9307 struct.setSuccessIsSet(true);
9308 } else {
9309 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9310 }
9311 break;
9312 case 1:
9313 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
9314 struct.io = new TIOError();
9315 struct.io.read(iprot);
9316 struct.setIoIsSet(true);
9317 } else {
9318 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9319 }
9320 break;
9321 default:
9322 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9323 }
9324 iprot.readFieldEnd();
9325 }
9326 iprot.readStructEnd();
9327
9328
9329 struct.validate();
9330 }
9331
9332 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9333 struct.validate();
9334
9335 oprot.writeStructBegin(STRUCT_DESC);
9336 if (struct.success != null) {
9337 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
9338 {
9339 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
9340 for (TDelete _iter141 : struct.success)
9341 {
9342 _iter141.write(oprot);
9343 }
9344 oprot.writeListEnd();
9345 }
9346 oprot.writeFieldEnd();
9347 }
9348 if (struct.io != null) {
9349 oprot.writeFieldBegin(IO_FIELD_DESC);
9350 struct.io.write(oprot);
9351 oprot.writeFieldEnd();
9352 }
9353 oprot.writeFieldStop();
9354 oprot.writeStructEnd();
9355 }
9356
9357 }
9358
9359 private static class deleteMultiple_resultTupleSchemeFactory implements SchemeFactory {
9360 public deleteMultiple_resultTupleScheme getScheme() {
9361 return new deleteMultiple_resultTupleScheme();
9362 }
9363 }
9364
9365 private static class deleteMultiple_resultTupleScheme extends TupleScheme<deleteMultiple_result> {
9366
9367 @Override
9368 public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9369 TTupleProtocol oprot = (TTupleProtocol) prot;
9370 BitSet optionals = new BitSet();
9371 if (struct.isSetSuccess()) {
9372 optionals.set(0);
9373 }
9374 if (struct.isSetIo()) {
9375 optionals.set(1);
9376 }
9377 oprot.writeBitSet(optionals, 2);
9378 if (struct.isSetSuccess()) {
9379 {
9380 oprot.writeI32(struct.success.size());
9381 for (TDelete _iter142 : struct.success)
9382 {
9383 _iter142.write(oprot);
9384 }
9385 }
9386 }
9387 if (struct.isSetIo()) {
9388 struct.io.write(oprot);
9389 }
9390 }
9391
9392 @Override
9393 public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9394 TTupleProtocol iprot = (TTupleProtocol) prot;
9395 BitSet incoming = iprot.readBitSet(2);
9396 if (incoming.get(0)) {
9397 {
9398 org.apache.thrift.protocol.TList _list143 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
9399 struct.success = new ArrayList<TDelete>(_list143.size);
9400 for (int _i144 = 0; _i144 < _list143.size; ++_i144)
9401 {
9402 TDelete _elem145;
9403 _elem145 = new TDelete();
9404 _elem145.read(iprot);
9405 struct.success.add(_elem145);
9406 }
9407 }
9408 struct.setSuccessIsSet(true);
9409 }
9410 if (incoming.get(1)) {
9411 struct.io = new TIOError();
9412 struct.io.read(iprot);
9413 struct.setIoIsSet(true);
9414 }
9415 }
9416 }
9417
9418 }
9419
9420 public static class checkAndDelete_args implements org.apache.thrift.TBase<checkAndDelete_args, checkAndDelete_args._Fields>, java.io.Serializable, Cloneable {
9421 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_args");
9422
9423 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);
9424 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);
9425 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);
9426 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);
9427 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);
9428 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);
9429
9430 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
9431 static {
9432 schemes.put(StandardScheme.class, new checkAndDelete_argsStandardSchemeFactory());
9433 schemes.put(TupleScheme.class, new checkAndDelete_argsTupleSchemeFactory());
9434 }
9435
9436
9437
9438
9439 public ByteBuffer table;
9440
9441
9442
9443 public ByteBuffer row;
9444
9445
9446
9447 public ByteBuffer family;
9448
9449
9450
9451 public ByteBuffer qualifier;
9452
9453
9454
9455
9456
9457 public ByteBuffer value;
9458
9459
9460
9461 public TDelete deleteSingle;
9462
9463
9464 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
9465
9466
9467
9468 TABLE((short)1, "table"),
9469
9470
9471
9472 ROW((short)2, "row"),
9473
9474
9475
9476 FAMILY((short)3, "family"),
9477
9478
9479
9480 QUALIFIER((short)4, "qualifier"),
9481
9482
9483
9484
9485
9486 VALUE((short)5, "value"),
9487
9488
9489
9490 DELETE_SINGLE((short)6, "deleteSingle");
9491
9492 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9493
9494 static {
9495 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9496 byName.put(field.getFieldName(), field);
9497 }
9498 }
9499
9500
9501
9502
9503 public static _Fields findByThriftId(int fieldId) {
9504 switch(fieldId) {
9505 case 1:
9506 return TABLE;
9507 case 2:
9508 return ROW;
9509 case 3:
9510 return FAMILY;
9511 case 4:
9512 return QUALIFIER;
9513 case 5:
9514 return VALUE;
9515 case 6:
9516 return DELETE_SINGLE;
9517 default:
9518 return null;
9519 }
9520 }
9521
9522
9523
9524
9525
9526 public static _Fields findByThriftIdOrThrow(int fieldId) {
9527 _Fields fields = findByThriftId(fieldId);
9528 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9529 return fields;
9530 }
9531
9532
9533
9534
9535 public static _Fields findByName(String name) {
9536 return byName.get(name);
9537 }
9538
9539 private final short _thriftId;
9540 private final String _fieldName;
9541
9542 _Fields(short thriftId, String fieldName) {
9543 _thriftId = thriftId;
9544 _fieldName = fieldName;
9545 }
9546
9547 public short getThriftFieldId() {
9548 return _thriftId;
9549 }
9550
9551 public String getFieldName() {
9552 return _fieldName;
9553 }
9554 }
9555
9556
9557 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
9558 static {
9559 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
9560 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
9561 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9562 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
9563 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9564 tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
9565 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9566 tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
9567 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9568 tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT,
9569 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9570 tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED,
9571 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
9572 metaDataMap = Collections.unmodifiableMap(tmpMap);
9573 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_args.class, metaDataMap);
9574 }
9575
9576 public checkAndDelete_args() {
9577 }
9578
9579 public checkAndDelete_args(
9580 ByteBuffer table,
9581 ByteBuffer row,
9582 ByteBuffer family,
9583 ByteBuffer qualifier,
9584 ByteBuffer value,
9585 TDelete deleteSingle)
9586 {
9587 this();
9588 this.table = table;
9589 this.row = row;
9590 this.family = family;
9591 this.qualifier = qualifier;
9592 this.value = value;
9593 this.deleteSingle = deleteSingle;
9594 }
9595
9596
9597
9598
9599 public checkAndDelete_args(checkAndDelete_args other) {
9600 if (other.isSetTable()) {
9601 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
9602 ;
9603 }
9604 if (other.isSetRow()) {
9605 this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
9606 ;
9607 }
9608 if (other.isSetFamily()) {
9609 this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
9610 ;
9611 }
9612 if (other.isSetQualifier()) {
9613 this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
9614 ;
9615 }
9616 if (other.isSetValue()) {
9617 this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
9618 ;
9619 }
9620 if (other.isSetDeleteSingle()) {
9621 this.deleteSingle = new TDelete(other.deleteSingle);
9622 }
9623 }
9624
9625 public checkAndDelete_args deepCopy() {
9626 return new checkAndDelete_args(this);
9627 }
9628
9629 @Override
9630 public void clear() {
9631 this.table = null;
9632 this.row = null;
9633 this.family = null;
9634 this.qualifier = null;
9635 this.value = null;
9636 this.deleteSingle = null;
9637 }
9638
9639
9640
9641
9642 public byte[] getTable() {
9643 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
9644 return table == null ? null : table.array();
9645 }
9646
9647 public ByteBuffer bufferForTable() {
9648 return table;
9649 }
9650
9651
9652
9653
9654 public checkAndDelete_args setTable(byte[] table) {
9655 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
9656 return this;
9657 }
9658
9659 public checkAndDelete_args setTable(ByteBuffer table) {
9660 this.table = table;
9661 return this;
9662 }
9663
9664 public void unsetTable() {
9665 this.table = null;
9666 }
9667
9668
9669 public boolean isSetTable() {
9670 return this.table != null;
9671 }
9672
9673 public void setTableIsSet(boolean value) {
9674 if (!value) {
9675 this.table = null;
9676 }
9677 }
9678
9679
9680
9681
9682 public byte[] getRow() {
9683 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
9684 return row == null ? null : row.array();
9685 }
9686
9687 public ByteBuffer bufferForRow() {
9688 return row;
9689 }
9690
9691
9692
9693
9694 public checkAndDelete_args setRow(byte[] row) {
9695 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
9696 return this;
9697 }
9698
9699 public checkAndDelete_args setRow(ByteBuffer row) {
9700 this.row = row;
9701 return this;
9702 }
9703
9704 public void unsetRow() {
9705 this.row = null;
9706 }
9707
9708
9709 public boolean isSetRow() {
9710 return this.row != null;
9711 }
9712
9713 public void setRowIsSet(boolean value) {
9714 if (!value) {
9715 this.row = null;
9716 }
9717 }
9718
9719
9720
9721
9722 public byte[] getFamily() {
9723 setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
9724 return family == null ? null : family.array();
9725 }
9726
9727 public ByteBuffer bufferForFamily() {
9728 return family;
9729 }
9730
9731
9732
9733
9734 public checkAndDelete_args setFamily(byte[] family) {
9735 setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
9736 return this;
9737 }
9738
9739 public checkAndDelete_args setFamily(ByteBuffer family) {
9740 this.family = family;
9741 return this;
9742 }
9743
9744 public void unsetFamily() {
9745 this.family = null;
9746 }
9747
9748
9749 public boolean isSetFamily() {
9750 return this.family != null;
9751 }
9752
9753 public void setFamilyIsSet(boolean value) {
9754 if (!value) {
9755 this.family = null;
9756 }
9757 }
9758
9759
9760
9761
9762 public byte[] getQualifier() {
9763 setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
9764 return qualifier == null ? null : qualifier.array();
9765 }
9766
9767 public ByteBuffer bufferForQualifier() {
9768 return qualifier;
9769 }
9770
9771
9772
9773
9774 public checkAndDelete_args setQualifier(byte[] qualifier) {
9775 setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
9776 return this;
9777 }
9778
9779 public checkAndDelete_args setQualifier(ByteBuffer qualifier) {
9780 this.qualifier = qualifier;
9781 return this;
9782 }
9783
9784 public void unsetQualifier() {
9785 this.qualifier = null;
9786 }
9787
9788
9789 public boolean isSetQualifier() {
9790 return this.qualifier != null;
9791 }
9792
9793 public void setQualifierIsSet(boolean value) {
9794 if (!value) {
9795 this.qualifier = null;
9796 }
9797 }
9798
9799
9800
9801
9802
9803
9804 public byte[] getValue() {
9805 setValue(org.apache.thrift.TBaseHelper.rightSize(value));
9806 return value == null ? null : value.array();
9807 }
9808
9809 public ByteBuffer bufferForValue() {
9810 return value;
9811 }
9812
9813
9814
9815
9816
9817
9818 public checkAndDelete_args setValue(byte[] value) {
9819 setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
9820 return this;
9821 }
9822
9823 public checkAndDelete_args setValue(ByteBuffer value) {
9824 this.value = value;
9825 return this;
9826 }
9827
9828 public void unsetValue() {
9829 this.value = null;
9830 }
9831
9832
9833 public boolean isSetValue() {
9834 return this.value != null;
9835 }
9836
9837 public void setValueIsSet(boolean value) {
9838 if (!value) {
9839 this.value = null;
9840 }
9841 }
9842
9843
9844
9845
9846 public TDelete getDeleteSingle() {
9847 return this.deleteSingle;
9848 }
9849
9850
9851
9852
9853 public checkAndDelete_args setDeleteSingle(TDelete deleteSingle) {
9854 this.deleteSingle = deleteSingle;
9855 return this;
9856 }
9857
9858 public void unsetDeleteSingle() {
9859 this.deleteSingle = null;
9860 }
9861
9862
9863 public boolean isSetDeleteSingle() {
9864 return this.deleteSingle != null;
9865 }
9866
9867 public void setDeleteSingleIsSet(boolean value) {
9868 if (!value) {
9869 this.deleteSingle = null;
9870 }
9871 }
9872
9873 public void setFieldValue(_Fields field, Object value) {
9874 switch (field) {
9875 case TABLE:
9876 if (value == null) {
9877 unsetTable();
9878 } else {
9879 setTable((ByteBuffer)value);
9880 }
9881 break;
9882
9883 case ROW:
9884 if (value == null) {
9885 unsetRow();
9886 } else {
9887 setRow((ByteBuffer)value);
9888 }
9889 break;
9890
9891 case FAMILY:
9892 if (value == null) {
9893 unsetFamily();
9894 } else {
9895 setFamily((ByteBuffer)value);
9896 }
9897 break;
9898
9899 case QUALIFIER:
9900 if (value == null) {
9901 unsetQualifier();
9902 } else {
9903 setQualifier((ByteBuffer)value);
9904 }
9905 break;
9906
9907 case VALUE:
9908 if (value == null) {
9909 unsetValue();
9910 } else {
9911 setValue((ByteBuffer)value);
9912 }
9913 break;
9914
9915 case DELETE_SINGLE:
9916 if (value == null) {
9917 unsetDeleteSingle();
9918 } else {
9919 setDeleteSingle((TDelete)value);
9920 }
9921 break;
9922
9923 }
9924 }
9925
9926 public Object getFieldValue(_Fields field) {
9927 switch (field) {
9928 case TABLE:
9929 return getTable();
9930
9931 case ROW:
9932 return getRow();
9933
9934 case FAMILY:
9935 return getFamily();
9936
9937 case QUALIFIER:
9938 return getQualifier();
9939
9940 case VALUE:
9941 return getValue();
9942
9943 case DELETE_SINGLE:
9944 return getDeleteSingle();
9945
9946 }
9947 throw new IllegalStateException();
9948 }
9949
9950
9951 public boolean isSet(_Fields field) {
9952 if (field == null) {
9953 throw new IllegalArgumentException();
9954 }
9955
9956 switch (field) {
9957 case TABLE:
9958 return isSetTable();
9959 case ROW:
9960 return isSetRow();
9961 case FAMILY:
9962 return isSetFamily();
9963 case QUALIFIER:
9964 return isSetQualifier();
9965 case VALUE:
9966 return isSetValue();
9967 case DELETE_SINGLE:
9968 return isSetDeleteSingle();
9969 }
9970 throw new IllegalStateException();
9971 }
9972
9973 @Override
9974 public boolean equals(Object that) {
9975 if (that == null)
9976 return false;
9977 if (that instanceof checkAndDelete_args)
9978 return this.equals((checkAndDelete_args)that);
9979 return false;
9980 }
9981
9982 public boolean equals(checkAndDelete_args that) {
9983 if (that == null)
9984 return false;
9985
9986 boolean this_present_table = true && this.isSetTable();
9987 boolean that_present_table = true && that.isSetTable();
9988 if (this_present_table || that_present_table) {
9989 if (!(this_present_table && that_present_table))
9990 return false;
9991 if (!this.table.equals(that.table))
9992 return false;
9993 }
9994
9995 boolean this_present_row = true && this.isSetRow();
9996 boolean that_present_row = true && that.isSetRow();
9997 if (this_present_row || that_present_row) {
9998 if (!(this_present_row && that_present_row))
9999 return false;
10000 if (!this.row.equals(that.row))
10001 return false;
10002 }
10003
10004 boolean this_present_family = true && this.isSetFamily();
10005 boolean that_present_family = true && that.isSetFamily();
10006 if (this_present_family || that_present_family) {
10007 if (!(this_present_family && that_present_family))
10008 return false;
10009 if (!this.family.equals(that.family))
10010 return false;
10011 }
10012
10013 boolean this_present_qualifier = true && this.isSetQualifier();
10014 boolean that_present_qualifier = true && that.isSetQualifier();
10015 if (this_present_qualifier || that_present_qualifier) {
10016 if (!(this_present_qualifier && that_present_qualifier))
10017 return false;
10018 if (!this.qualifier.equals(that.qualifier))
10019 return false;
10020 }
10021
10022 boolean this_present_value = true && this.isSetValue();
10023 boolean that_present_value = true && that.isSetValue();
10024 if (this_present_value || that_present_value) {
10025 if (!(this_present_value && that_present_value))
10026 return false;
10027 if (!this.value.equals(that.value))
10028 return false;
10029 }
10030
10031 boolean this_present_deleteSingle = true && this.isSetDeleteSingle();
10032 boolean that_present_deleteSingle = true && that.isSetDeleteSingle();
10033 if (this_present_deleteSingle || that_present_deleteSingle) {
10034 if (!(this_present_deleteSingle && that_present_deleteSingle))
10035 return false;
10036 if (!this.deleteSingle.equals(that.deleteSingle))
10037 return false;
10038 }
10039
10040 return true;
10041 }
10042
10043 @Override
10044 public int hashCode() {
10045 return 0;
10046 }
10047
10048 public int compareTo(checkAndDelete_args other) {
10049 if (!getClass().equals(other.getClass())) {
10050 return getClass().getName().compareTo(other.getClass().getName());
10051 }
10052
10053 int lastComparison = 0;
10054 checkAndDelete_args typedOther = (checkAndDelete_args)other;
10055
10056 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
10057 if (lastComparison != 0) {
10058 return lastComparison;
10059 }
10060 if (isSetTable()) {
10061 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
10062 if (lastComparison != 0) {
10063 return lastComparison;
10064 }
10065 }
10066 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
10067 if (lastComparison != 0) {
10068 return lastComparison;
10069 }
10070 if (isSetRow()) {
10071 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
10072 if (lastComparison != 0) {
10073 return lastComparison;
10074 }
10075 }
10076 lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
10077 if (lastComparison != 0) {
10078 return lastComparison;
10079 }
10080 if (isSetFamily()) {
10081 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
10082 if (lastComparison != 0) {
10083 return lastComparison;
10084 }
10085 }
10086 lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
10087 if (lastComparison != 0) {
10088 return lastComparison;
10089 }
10090 if (isSetQualifier()) {
10091 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
10092 if (lastComparison != 0) {
10093 return lastComparison;
10094 }
10095 }
10096 lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
10097 if (lastComparison != 0) {
10098 return lastComparison;
10099 }
10100 if (isSetValue()) {
10101 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
10102 if (lastComparison != 0) {
10103 return lastComparison;
10104 }
10105 }
10106 lastComparison = Boolean.valueOf(isSetDeleteSingle()).compareTo(typedOther.isSetDeleteSingle());
10107 if (lastComparison != 0) {
10108 return lastComparison;
10109 }
10110 if (isSetDeleteSingle()) {
10111 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteSingle, typedOther.deleteSingle);
10112 if (lastComparison != 0) {
10113 return lastComparison;
10114 }
10115 }
10116 return 0;
10117 }
10118
10119 public _Fields fieldForId(int fieldId) {
10120 return _Fields.findByThriftId(fieldId);
10121 }
10122
10123 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
10124 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
10125 }
10126
10127 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
10128 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
10129 }
10130
10131 @Override
10132 public String toString() {
10133 StringBuilder sb = new StringBuilder("checkAndDelete_args(");
10134 boolean first = true;
10135
10136 sb.append("table:");
10137 if (this.table == null) {
10138 sb.append("null");
10139 } else {
10140 org.apache.thrift.TBaseHelper.toString(this.table, sb);
10141 }
10142 first = false;
10143 if (!first) sb.append(", ");
10144 sb.append("row:");
10145 if (this.row == null) {
10146 sb.append("null");
10147 } else {
10148 org.apache.thrift.TBaseHelper.toString(this.row, sb);
10149 }
10150 first = false;
10151 if (!first) sb.append(", ");
10152 sb.append("family:");
10153 if (this.family == null) {
10154 sb.append("null");
10155 } else {
10156 org.apache.thrift.TBaseHelper.toString(this.family, sb);
10157 }
10158 first = false;
10159 if (!first) sb.append(", ");
10160 sb.append("qualifier:");
10161 if (this.qualifier == null) {
10162 sb.append("null");
10163 } else {
10164 org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
10165 }
10166 first = false;
10167 if (!first) sb.append(", ");
10168 sb.append("value:");
10169 if (this.value == null) {
10170 sb.append("null");
10171 } else {
10172 org.apache.thrift.TBaseHelper.toString(this.value, sb);
10173 }
10174 first = false;
10175 if (!first) sb.append(", ");
10176 sb.append("deleteSingle:");
10177 if (this.deleteSingle == null) {
10178 sb.append("null");
10179 } else {
10180 sb.append(this.deleteSingle);
10181 }
10182 first = false;
10183 sb.append(")");
10184 return sb.toString();
10185 }
10186
10187 public void validate() throws org.apache.thrift.TException {
10188
10189 if (table == null) {
10190 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
10191 }
10192 if (row == null) {
10193 throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
10194 }
10195 if (family == null) {
10196 throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
10197 }
10198 if (qualifier == null) {
10199 throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
10200 }
10201 if (deleteSingle == null) {
10202 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deleteSingle' was not present! Struct: " + toString());
10203 }
10204 }
10205
10206 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
10207 try {
10208 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
10209 } catch (org.apache.thrift.TException te) {
10210 throw new java.io.IOException(te);
10211 }
10212 }
10213
10214 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
10215 try {
10216 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
10217 } catch (org.apache.thrift.TException te) {
10218 throw new java.io.IOException(te);
10219 }
10220 }
10221
10222 private static class checkAndDelete_argsStandardSchemeFactory implements SchemeFactory {
10223 public checkAndDelete_argsStandardScheme getScheme() {
10224 return new checkAndDelete_argsStandardScheme();
10225 }
10226 }
10227
10228 private static class checkAndDelete_argsStandardScheme extends StandardScheme<checkAndDelete_args> {
10229
10230 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10231 org.apache.thrift.protocol.TField schemeField;
10232 iprot.readStructBegin();
10233 while (true)
10234 {
10235 schemeField = iprot.readFieldBegin();
10236 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
10237 break;
10238 }
10239 switch (schemeField.id) {
10240 case 1:
10241 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10242 struct.table = iprot.readBinary();
10243 struct.setTableIsSet(true);
10244 } else {
10245 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10246 }
10247 break;
10248 case 2:
10249 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10250 struct.row = iprot.readBinary();
10251 struct.setRowIsSet(true);
10252 } else {
10253 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10254 }
10255 break;
10256 case 3:
10257 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10258 struct.family = iprot.readBinary();
10259 struct.setFamilyIsSet(true);
10260 } else {
10261 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10262 }
10263 break;
10264 case 4:
10265 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10266 struct.qualifier = iprot.readBinary();
10267 struct.setQualifierIsSet(true);
10268 } else {
10269 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10270 }
10271 break;
10272 case 5:
10273 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10274 struct.value = iprot.readBinary();
10275 struct.setValueIsSet(true);
10276 } else {
10277 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10278 }
10279 break;
10280 case 6:
10281 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
10282 struct.deleteSingle = new TDelete();
10283 struct.deleteSingle.read(iprot);
10284 struct.setDeleteSingleIsSet(true);
10285 } else {
10286 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10287 }
10288 break;
10289 default:
10290 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10291 }
10292 iprot.readFieldEnd();
10293 }
10294 iprot.readStructEnd();
10295
10296
10297 struct.validate();
10298 }
10299
10300 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10301 struct.validate();
10302
10303 oprot.writeStructBegin(STRUCT_DESC);
10304 if (struct.table != null) {
10305 oprot.writeFieldBegin(TABLE_FIELD_DESC);
10306 oprot.writeBinary(struct.table);
10307 oprot.writeFieldEnd();
10308 }
10309 if (struct.row != null) {
10310 oprot.writeFieldBegin(ROW_FIELD_DESC);
10311 oprot.writeBinary(struct.row);
10312 oprot.writeFieldEnd();
10313 }
10314 if (struct.family != null) {
10315 oprot.writeFieldBegin(FAMILY_FIELD_DESC);
10316 oprot.writeBinary(struct.family);
10317 oprot.writeFieldEnd();
10318 }
10319 if (struct.qualifier != null) {
10320 oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
10321 oprot.writeBinary(struct.qualifier);
10322 oprot.writeFieldEnd();
10323 }
10324 if (struct.value != null) {
10325 oprot.writeFieldBegin(VALUE_FIELD_DESC);
10326 oprot.writeBinary(struct.value);
10327 oprot.writeFieldEnd();
10328 }
10329 if (struct.deleteSingle != null) {
10330 oprot.writeFieldBegin(DELETE_SINGLE_FIELD_DESC);
10331 struct.deleteSingle.write(oprot);
10332 oprot.writeFieldEnd();
10333 }
10334 oprot.writeFieldStop();
10335 oprot.writeStructEnd();
10336 }
10337
10338 }
10339
10340 private static class checkAndDelete_argsTupleSchemeFactory implements SchemeFactory {
10341 public checkAndDelete_argsTupleScheme getScheme() {
10342 return new checkAndDelete_argsTupleScheme();
10343 }
10344 }
10345
10346 private static class checkAndDelete_argsTupleScheme extends TupleScheme<checkAndDelete_args> {
10347
10348 @Override
10349 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10350 TTupleProtocol oprot = (TTupleProtocol) prot;
10351 oprot.writeBinary(struct.table);
10352 oprot.writeBinary(struct.row);
10353 oprot.writeBinary(struct.family);
10354 oprot.writeBinary(struct.qualifier);
10355 struct.deleteSingle.write(oprot);
10356 BitSet optionals = new BitSet();
10357 if (struct.isSetValue()) {
10358 optionals.set(0);
10359 }
10360 oprot.writeBitSet(optionals, 1);
10361 if (struct.isSetValue()) {
10362 oprot.writeBinary(struct.value);
10363 }
10364 }
10365
10366 @Override
10367 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10368 TTupleProtocol iprot = (TTupleProtocol) prot;
10369 struct.table = iprot.readBinary();
10370 struct.setTableIsSet(true);
10371 struct.row = iprot.readBinary();
10372 struct.setRowIsSet(true);
10373 struct.family = iprot.readBinary();
10374 struct.setFamilyIsSet(true);
10375 struct.qualifier = iprot.readBinary();
10376 struct.setQualifierIsSet(true);
10377 struct.deleteSingle = new TDelete();
10378 struct.deleteSingle.read(iprot);
10379 struct.setDeleteSingleIsSet(true);
10380 BitSet incoming = iprot.readBitSet(1);
10381 if (incoming.get(0)) {
10382 struct.value = iprot.readBinary();
10383 struct.setValueIsSet(true);
10384 }
10385 }
10386 }
10387
10388 }
10389
10390 public static class checkAndDelete_result implements org.apache.thrift.TBase<checkAndDelete_result, checkAndDelete_result._Fields>, java.io.Serializable, Cloneable {
10391 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_result");
10392
10393 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);
10394 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);
10395
10396 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
10397 static {
10398 schemes.put(StandardScheme.class, new checkAndDelete_resultStandardSchemeFactory());
10399 schemes.put(TupleScheme.class, new checkAndDelete_resultTupleSchemeFactory());
10400 }
10401
10402 public boolean success;
10403 public TIOError io;
10404
10405
10406 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
10407 SUCCESS((short)0, "success"),
10408 IO((short)1, "io");
10409
10410 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10411
10412 static {
10413 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10414 byName.put(field.getFieldName(), field);
10415 }
10416 }
10417
10418
10419
10420
10421 public static _Fields findByThriftId(int fieldId) {
10422 switch(fieldId) {
10423 case 0:
10424 return SUCCESS;
10425 case 1:
10426 return IO;
10427 default:
10428 return null;
10429 }
10430 }
10431
10432
10433
10434
10435
10436 public static _Fields findByThriftIdOrThrow(int fieldId) {
10437 _Fields fields = findByThriftId(fieldId);
10438 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10439 return fields;
10440 }
10441
10442
10443
10444
10445 public static _Fields findByName(String name) {
10446 return byName.get(name);
10447 }
10448
10449 private final short _thriftId;
10450 private final String _fieldName;
10451
10452 _Fields(short thriftId, String fieldName) {
10453 _thriftId = thriftId;
10454 _fieldName = fieldName;
10455 }
10456
10457 public short getThriftFieldId() {
10458 return _thriftId;
10459 }
10460
10461 public String getFieldName() {
10462 return _fieldName;
10463 }
10464 }
10465
10466
10467 private static final int __SUCCESS_ISSET_ID = 0;
10468 private BitSet __isset_bit_vector = new BitSet(1);
10469 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
10470 static {
10471 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
10472 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
10473 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
10474 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
10475 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
10476 metaDataMap = Collections.unmodifiableMap(tmpMap);
10477 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_result.class, metaDataMap);
10478 }
10479
10480 public checkAndDelete_result() {
10481 }
10482
10483 public checkAndDelete_result(
10484 boolean success,
10485 TIOError io)
10486 {
10487 this();
10488 this.success = success;
10489 setSuccessIsSet(true);
10490 this.io = io;
10491 }
10492
10493
10494
10495
10496 public checkAndDelete_result(checkAndDelete_result other) {
10497 __isset_bit_vector.clear();
10498 __isset_bit_vector.or(other.__isset_bit_vector);
10499 this.success = other.success;
10500 if (other.isSetIo()) {
10501 this.io = new TIOError(other.io);
10502 }
10503 }
10504
10505 public checkAndDelete_result deepCopy() {
10506 return new checkAndDelete_result(this);
10507 }
10508
10509 @Override
10510 public void clear() {
10511 setSuccessIsSet(false);
10512 this.success = false;
10513 this.io = null;
10514 }
10515
10516 public boolean isSuccess() {
10517 return this.success;
10518 }
10519
10520 public checkAndDelete_result setSuccess(boolean success) {
10521 this.success = success;
10522 setSuccessIsSet(true);
10523 return this;
10524 }
10525
10526 public void unsetSuccess() {
10527 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
10528 }
10529
10530
10531 public boolean isSetSuccess() {
10532 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
10533 }
10534
10535 public void setSuccessIsSet(boolean value) {
10536 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
10537 }
10538
10539 public TIOError getIo() {
10540 return this.io;
10541 }
10542
10543 public checkAndDelete_result setIo(TIOError io) {
10544 this.io = io;
10545 return this;
10546 }
10547
10548 public void unsetIo() {
10549 this.io = null;
10550 }
10551
10552
10553 public boolean isSetIo() {
10554 return this.io != null;
10555 }
10556
10557 public void setIoIsSet(boolean value) {
10558 if (!value) {
10559 this.io = null;
10560 }
10561 }
10562
10563 public void setFieldValue(_Fields field, Object value) {
10564 switch (field) {
10565 case SUCCESS:
10566 if (value == null) {
10567 unsetSuccess();
10568 } else {
10569 setSuccess((Boolean)value);
10570 }
10571 break;
10572
10573 case IO:
10574 if (value == null) {
10575 unsetIo();
10576 } else {
10577 setIo((TIOError)value);
10578 }
10579 break;
10580
10581 }
10582 }
10583
10584 public Object getFieldValue(_Fields field) {
10585 switch (field) {
10586 case SUCCESS:
10587 return Boolean.valueOf(isSuccess());
10588
10589 case IO:
10590 return getIo();
10591
10592 }
10593 throw new IllegalStateException();
10594 }
10595
10596
10597 public boolean isSet(_Fields field) {
10598 if (field == null) {
10599 throw new IllegalArgumentException();
10600 }
10601
10602 switch (field) {
10603 case SUCCESS:
10604 return isSetSuccess();
10605 case IO:
10606 return isSetIo();
10607 }
10608 throw new IllegalStateException();
10609 }
10610
10611 @Override
10612 public boolean equals(Object that) {
10613 if (that == null)
10614 return false;
10615 if (that instanceof checkAndDelete_result)
10616 return this.equals((checkAndDelete_result)that);
10617 return false;
10618 }
10619
10620 public boolean equals(checkAndDelete_result that) {
10621 if (that == null)
10622 return false;
10623
10624 boolean this_present_success = true;
10625 boolean that_present_success = true;
10626 if (this_present_success || that_present_success) {
10627 if (!(this_present_success && that_present_success))
10628 return false;
10629 if (this.success != that.success)
10630 return false;
10631 }
10632
10633 boolean this_present_io = true && this.isSetIo();
10634 boolean that_present_io = true && that.isSetIo();
10635 if (this_present_io || that_present_io) {
10636 if (!(this_present_io && that_present_io))
10637 return false;
10638 if (!this.io.equals(that.io))
10639 return false;
10640 }
10641
10642 return true;
10643 }
10644
10645 @Override
10646 public int hashCode() {
10647 return 0;
10648 }
10649
10650 public int compareTo(checkAndDelete_result other) {
10651 if (!getClass().equals(other.getClass())) {
10652 return getClass().getName().compareTo(other.getClass().getName());
10653 }
10654
10655 int lastComparison = 0;
10656 checkAndDelete_result typedOther = (checkAndDelete_result)other;
10657
10658 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
10659 if (lastComparison != 0) {
10660 return lastComparison;
10661 }
10662 if (isSetSuccess()) {
10663 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
10664 if (lastComparison != 0) {
10665 return lastComparison;
10666 }
10667 }
10668 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
10669 if (lastComparison != 0) {
10670 return lastComparison;
10671 }
10672 if (isSetIo()) {
10673 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
10674 if (lastComparison != 0) {
10675 return lastComparison;
10676 }
10677 }
10678 return 0;
10679 }
10680
10681 public _Fields fieldForId(int fieldId) {
10682 return _Fields.findByThriftId(fieldId);
10683 }
10684
10685 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
10686 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
10687 }
10688
10689 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
10690 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
10691 }
10692
10693 @Override
10694 public String toString() {
10695 StringBuilder sb = new StringBuilder("checkAndDelete_result(");
10696 boolean first = true;
10697
10698 sb.append("success:");
10699 sb.append(this.success);
10700 first = false;
10701 if (!first) sb.append(", ");
10702 sb.append("io:");
10703 if (this.io == null) {
10704 sb.append("null");
10705 } else {
10706 sb.append(this.io);
10707 }
10708 first = false;
10709 sb.append(")");
10710 return sb.toString();
10711 }
10712
10713 public void validate() throws org.apache.thrift.TException {
10714
10715 }
10716
10717 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
10718 try {
10719 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
10720 } catch (org.apache.thrift.TException te) {
10721 throw new java.io.IOException(te);
10722 }
10723 }
10724
10725 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
10726 try {
10727
10728 __isset_bit_vector = new BitSet(1);
10729 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
10730 } catch (org.apache.thrift.TException te) {
10731 throw new java.io.IOException(te);
10732 }
10733 }
10734
10735 private static class checkAndDelete_resultStandardSchemeFactory implements SchemeFactory {
10736 public checkAndDelete_resultStandardScheme getScheme() {
10737 return new checkAndDelete_resultStandardScheme();
10738 }
10739 }
10740
10741 private static class checkAndDelete_resultStandardScheme extends StandardScheme<checkAndDelete_result> {
10742
10743 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10744 org.apache.thrift.protocol.TField schemeField;
10745 iprot.readStructBegin();
10746 while (true)
10747 {
10748 schemeField = iprot.readFieldBegin();
10749 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
10750 break;
10751 }
10752 switch (schemeField.id) {
10753 case 0:
10754 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
10755 struct.success = iprot.readBool();
10756 struct.setSuccessIsSet(true);
10757 } else {
10758 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10759 }
10760 break;
10761 case 1:
10762 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
10763 struct.io = new TIOError();
10764 struct.io.read(iprot);
10765 struct.setIoIsSet(true);
10766 } else {
10767 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10768 }
10769 break;
10770 default:
10771 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10772 }
10773 iprot.readFieldEnd();
10774 }
10775 iprot.readStructEnd();
10776
10777
10778 struct.validate();
10779 }
10780
10781 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10782 struct.validate();
10783
10784 oprot.writeStructBegin(STRUCT_DESC);
10785 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
10786 oprot.writeBool(struct.success);
10787 oprot.writeFieldEnd();
10788 if (struct.io != null) {
10789 oprot.writeFieldBegin(IO_FIELD_DESC);
10790 struct.io.write(oprot);
10791 oprot.writeFieldEnd();
10792 }
10793 oprot.writeFieldStop();
10794 oprot.writeStructEnd();
10795 }
10796
10797 }
10798
10799 private static class checkAndDelete_resultTupleSchemeFactory implements SchemeFactory {
10800 public checkAndDelete_resultTupleScheme getScheme() {
10801 return new checkAndDelete_resultTupleScheme();
10802 }
10803 }
10804
10805 private static class checkAndDelete_resultTupleScheme extends TupleScheme<checkAndDelete_result> {
10806
10807 @Override
10808 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10809 TTupleProtocol oprot = (TTupleProtocol) prot;
10810 BitSet optionals = new BitSet();
10811 if (struct.isSetSuccess()) {
10812 optionals.set(0);
10813 }
10814 if (struct.isSetIo()) {
10815 optionals.set(1);
10816 }
10817 oprot.writeBitSet(optionals, 2);
10818 if (struct.isSetSuccess()) {
10819 oprot.writeBool(struct.success);
10820 }
10821 if (struct.isSetIo()) {
10822 struct.io.write(oprot);
10823 }
10824 }
10825
10826 @Override
10827 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10828 TTupleProtocol iprot = (TTupleProtocol) prot;
10829 BitSet incoming = iprot.readBitSet(2);
10830 if (incoming.get(0)) {
10831 struct.success = iprot.readBool();
10832 struct.setSuccessIsSet(true);
10833 }
10834 if (incoming.get(1)) {
10835 struct.io = new TIOError();
10836 struct.io.read(iprot);
10837 struct.setIoIsSet(true);
10838 }
10839 }
10840 }
10841
10842 }
10843
10844 public static class increment_args implements org.apache.thrift.TBase<increment_args, increment_args._Fields>, java.io.Serializable, Cloneable {
10845 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_args");
10846
10847 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);
10848 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);
10849
10850 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
10851 static {
10852 schemes.put(StandardScheme.class, new increment_argsStandardSchemeFactory());
10853 schemes.put(TupleScheme.class, new increment_argsTupleSchemeFactory());
10854 }
10855
10856
10857
10858
10859 public ByteBuffer table;
10860
10861
10862
10863 public TIncrement increment;
10864
10865
10866 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
10867
10868
10869
10870 TABLE((short)1, "table"),
10871
10872
10873
10874 INCREMENT((short)2, "increment");
10875
10876 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10877
10878 static {
10879 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10880 byName.put(field.getFieldName(), field);
10881 }
10882 }
10883
10884
10885
10886
10887 public static _Fields findByThriftId(int fieldId) {
10888 switch(fieldId) {
10889 case 1:
10890 return TABLE;
10891 case 2:
10892 return INCREMENT;
10893 default:
10894 return null;
10895 }
10896 }
10897
10898
10899
10900
10901
10902 public static _Fields findByThriftIdOrThrow(int fieldId) {
10903 _Fields fields = findByThriftId(fieldId);
10904 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10905 return fields;
10906 }
10907
10908
10909
10910
10911 public static _Fields findByName(String name) {
10912 return byName.get(name);
10913 }
10914
10915 private final short _thriftId;
10916 private final String _fieldName;
10917
10918 _Fields(short thriftId, String fieldName) {
10919 _thriftId = thriftId;
10920 _fieldName = fieldName;
10921 }
10922
10923 public short getThriftFieldId() {
10924 return _thriftId;
10925 }
10926
10927 public String getFieldName() {
10928 return _fieldName;
10929 }
10930 }
10931
10932
10933 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
10934 static {
10935 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
10936 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
10937 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
10938 tmpMap.put(_Fields.INCREMENT, new org.apache.thrift.meta_data.FieldMetaData("increment", org.apache.thrift.TFieldRequirementType.REQUIRED,
10939 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIncrement.class)));
10940 metaDataMap = Collections.unmodifiableMap(tmpMap);
10941 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_args.class, metaDataMap);
10942 }
10943
10944 public increment_args() {
10945 }
10946
10947 public increment_args(
10948 ByteBuffer table,
10949 TIncrement increment)
10950 {
10951 this();
10952 this.table = table;
10953 this.increment = increment;
10954 }
10955
10956
10957
10958
10959 public increment_args(increment_args other) {
10960 if (other.isSetTable()) {
10961 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
10962 ;
10963 }
10964 if (other.isSetIncrement()) {
10965 this.increment = new TIncrement(other.increment);
10966 }
10967 }
10968
10969 public increment_args deepCopy() {
10970 return new increment_args(this);
10971 }
10972
10973 @Override
10974 public void clear() {
10975 this.table = null;
10976 this.increment = null;
10977 }
10978
10979
10980
10981
10982 public byte[] getTable() {
10983 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
10984 return table == null ? null : table.array();
10985 }
10986
10987 public ByteBuffer bufferForTable() {
10988 return table;
10989 }
10990
10991
10992
10993
10994 public increment_args setTable(byte[] table) {
10995 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
10996 return this;
10997 }
10998
10999 public increment_args setTable(ByteBuffer table) {
11000 this.table = table;
11001 return this;
11002 }
11003
11004 public void unsetTable() {
11005 this.table = null;
11006 }
11007
11008
11009 public boolean isSetTable() {
11010 return this.table != null;
11011 }
11012
11013 public void setTableIsSet(boolean value) {
11014 if (!value) {
11015 this.table = null;
11016 }
11017 }
11018
11019
11020
11021
11022 public TIncrement getIncrement() {
11023 return this.increment;
11024 }
11025
11026
11027
11028
11029 public increment_args setIncrement(TIncrement increment) {
11030 this.increment = increment;
11031 return this;
11032 }
11033
11034 public void unsetIncrement() {
11035 this.increment = null;
11036 }
11037
11038
11039 public boolean isSetIncrement() {
11040 return this.increment != null;
11041 }
11042
11043 public void setIncrementIsSet(boolean value) {
11044 if (!value) {
11045 this.increment = null;
11046 }
11047 }
11048
11049 public void setFieldValue(_Fields field, Object value) {
11050 switch (field) {
11051 case TABLE:
11052 if (value == null) {
11053 unsetTable();
11054 } else {
11055 setTable((ByteBuffer)value);
11056 }
11057 break;
11058
11059 case INCREMENT:
11060 if (value == null) {
11061 unsetIncrement();
11062 } else {
11063 setIncrement((TIncrement)value);
11064 }
11065 break;
11066
11067 }
11068 }
11069
11070 public Object getFieldValue(_Fields field) {
11071 switch (field) {
11072 case TABLE:
11073 return getTable();
11074
11075 case INCREMENT:
11076 return getIncrement();
11077
11078 }
11079 throw new IllegalStateException();
11080 }
11081
11082
11083 public boolean isSet(_Fields field) {
11084 if (field == null) {
11085 throw new IllegalArgumentException();
11086 }
11087
11088 switch (field) {
11089 case TABLE:
11090 return isSetTable();
11091 case INCREMENT:
11092 return isSetIncrement();
11093 }
11094 throw new IllegalStateException();
11095 }
11096
11097 @Override
11098 public boolean equals(Object that) {
11099 if (that == null)
11100 return false;
11101 if (that instanceof increment_args)
11102 return this.equals((increment_args)that);
11103 return false;
11104 }
11105
11106 public boolean equals(increment_args that) {
11107 if (that == null)
11108 return false;
11109
11110 boolean this_present_table = true && this.isSetTable();
11111 boolean that_present_table = true && that.isSetTable();
11112 if (this_present_table || that_present_table) {
11113 if (!(this_present_table && that_present_table))
11114 return false;
11115 if (!this.table.equals(that.table))
11116 return false;
11117 }
11118
11119 boolean this_present_increment = true && this.isSetIncrement();
11120 boolean that_present_increment = true && that.isSetIncrement();
11121 if (this_present_increment || that_present_increment) {
11122 if (!(this_present_increment && that_present_increment))
11123 return false;
11124 if (!this.increment.equals(that.increment))
11125 return false;
11126 }
11127
11128 return true;
11129 }
11130
11131 @Override
11132 public int hashCode() {
11133 return 0;
11134 }
11135
11136 public int compareTo(increment_args other) {
11137 if (!getClass().equals(other.getClass())) {
11138 return getClass().getName().compareTo(other.getClass().getName());
11139 }
11140
11141 int lastComparison = 0;
11142 increment_args typedOther = (increment_args)other;
11143
11144 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
11145 if (lastComparison != 0) {
11146 return lastComparison;
11147 }
11148 if (isSetTable()) {
11149 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
11150 if (lastComparison != 0) {
11151 return lastComparison;
11152 }
11153 }
11154 lastComparison = Boolean.valueOf(isSetIncrement()).compareTo(typedOther.isSetIncrement());
11155 if (lastComparison != 0) {
11156 return lastComparison;
11157 }
11158 if (isSetIncrement()) {
11159 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.increment, typedOther.increment);
11160 if (lastComparison != 0) {
11161 return lastComparison;
11162 }
11163 }
11164 return 0;
11165 }
11166
11167 public _Fields fieldForId(int fieldId) {
11168 return _Fields.findByThriftId(fieldId);
11169 }
11170
11171 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
11172 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
11173 }
11174
11175 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
11176 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
11177 }
11178
11179 @Override
11180 public String toString() {
11181 StringBuilder sb = new StringBuilder("increment_args(");
11182 boolean first = true;
11183
11184 sb.append("table:");
11185 if (this.table == null) {
11186 sb.append("null");
11187 } else {
11188 org.apache.thrift.TBaseHelper.toString(this.table, sb);
11189 }
11190 first = false;
11191 if (!first) sb.append(", ");
11192 sb.append("increment:");
11193 if (this.increment == null) {
11194 sb.append("null");
11195 } else {
11196 sb.append(this.increment);
11197 }
11198 first = false;
11199 sb.append(")");
11200 return sb.toString();
11201 }
11202
11203 public void validate() throws org.apache.thrift.TException {
11204
11205 if (table == null) {
11206 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
11207 }
11208 if (increment == null) {
11209 throw new org.apache.thrift.protocol.TProtocolException("Required field 'increment' was not present! Struct: " + toString());
11210 }
11211 }
11212
11213 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
11214 try {
11215 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
11216 } catch (org.apache.thrift.TException te) {
11217 throw new java.io.IOException(te);
11218 }
11219 }
11220
11221 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
11222 try {
11223 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
11224 } catch (org.apache.thrift.TException te) {
11225 throw new java.io.IOException(te);
11226 }
11227 }
11228
11229 private static class increment_argsStandardSchemeFactory implements SchemeFactory {
11230 public increment_argsStandardScheme getScheme() {
11231 return new increment_argsStandardScheme();
11232 }
11233 }
11234
11235 private static class increment_argsStandardScheme extends StandardScheme<increment_args> {
11236
11237 public void read(org.apache.thrift.protocol.TProtocol iprot, increment_args struct) throws org.apache.thrift.TException {
11238 org.apache.thrift.protocol.TField schemeField;
11239 iprot.readStructBegin();
11240 while (true)
11241 {
11242 schemeField = iprot.readFieldBegin();
11243 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
11244 break;
11245 }
11246 switch (schemeField.id) {
11247 case 1:
11248 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
11249 struct.table = iprot.readBinary();
11250 struct.setTableIsSet(true);
11251 } else {
11252 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11253 }
11254 break;
11255 case 2:
11256 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11257 struct.increment = new TIncrement();
11258 struct.increment.read(iprot);
11259 struct.setIncrementIsSet(true);
11260 } else {
11261 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11262 }
11263 break;
11264 default:
11265 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11266 }
11267 iprot.readFieldEnd();
11268 }
11269 iprot.readStructEnd();
11270
11271
11272 struct.validate();
11273 }
11274
11275 public void write(org.apache.thrift.protocol.TProtocol oprot, increment_args struct) throws org.apache.thrift.TException {
11276 struct.validate();
11277
11278 oprot.writeStructBegin(STRUCT_DESC);
11279 if (struct.table != null) {
11280 oprot.writeFieldBegin(TABLE_FIELD_DESC);
11281 oprot.writeBinary(struct.table);
11282 oprot.writeFieldEnd();
11283 }
11284 if (struct.increment != null) {
11285 oprot.writeFieldBegin(INCREMENT_FIELD_DESC);
11286 struct.increment.write(oprot);
11287 oprot.writeFieldEnd();
11288 }
11289 oprot.writeFieldStop();
11290 oprot.writeStructEnd();
11291 }
11292
11293 }
11294
11295 private static class increment_argsTupleSchemeFactory implements SchemeFactory {
11296 public increment_argsTupleScheme getScheme() {
11297 return new increment_argsTupleScheme();
11298 }
11299 }
11300
11301 private static class increment_argsTupleScheme extends TupleScheme<increment_args> {
11302
11303 @Override
11304 public void write(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
11305 TTupleProtocol oprot = (TTupleProtocol) prot;
11306 oprot.writeBinary(struct.table);
11307 struct.increment.write(oprot);
11308 }
11309
11310 @Override
11311 public void read(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
11312 TTupleProtocol iprot = (TTupleProtocol) prot;
11313 struct.table = iprot.readBinary();
11314 struct.setTableIsSet(true);
11315 struct.increment = new TIncrement();
11316 struct.increment.read(iprot);
11317 struct.setIncrementIsSet(true);
11318 }
11319 }
11320
11321 }
11322
11323 public static class increment_result implements org.apache.thrift.TBase<increment_result, increment_result._Fields>, java.io.Serializable, Cloneable {
11324 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_result");
11325
11326 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);
11327 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);
11328
11329 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
11330 static {
11331 schemes.put(StandardScheme.class, new increment_resultStandardSchemeFactory());
11332 schemes.put(TupleScheme.class, new increment_resultTupleSchemeFactory());
11333 }
11334
11335 public TResult success;
11336 public TIOError io;
11337
11338
11339 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
11340 SUCCESS((short)0, "success"),
11341 IO((short)1, "io");
11342
11343 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11344
11345 static {
11346 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11347 byName.put(field.getFieldName(), field);
11348 }
11349 }
11350
11351
11352
11353
11354 public static _Fields findByThriftId(int fieldId) {
11355 switch(fieldId) {
11356 case 0:
11357 return SUCCESS;
11358 case 1:
11359 return IO;
11360 default:
11361 return null;
11362 }
11363 }
11364
11365
11366
11367
11368
11369 public static _Fields findByThriftIdOrThrow(int fieldId) {
11370 _Fields fields = findByThriftId(fieldId);
11371 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11372 return fields;
11373 }
11374
11375
11376
11377
11378 public static _Fields findByName(String name) {
11379 return byName.get(name);
11380 }
11381
11382 private final short _thriftId;
11383 private final String _fieldName;
11384
11385 _Fields(short thriftId, String fieldName) {
11386 _thriftId = thriftId;
11387 _fieldName = fieldName;
11388 }
11389
11390 public short getThriftFieldId() {
11391 return _thriftId;
11392 }
11393
11394 public String getFieldName() {
11395 return _fieldName;
11396 }
11397 }
11398
11399
11400 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
11401 static {
11402 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
11403 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
11404 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
11405 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
11406 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
11407 metaDataMap = Collections.unmodifiableMap(tmpMap);
11408 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_result.class, metaDataMap);
11409 }
11410
11411 public increment_result() {
11412 }
11413
11414 public increment_result(
11415 TResult success,
11416 TIOError io)
11417 {
11418 this();
11419 this.success = success;
11420 this.io = io;
11421 }
11422
11423
11424
11425
11426 public increment_result(increment_result other) {
11427 if (other.isSetSuccess()) {
11428 this.success = new TResult(other.success);
11429 }
11430 if (other.isSetIo()) {
11431 this.io = new TIOError(other.io);
11432 }
11433 }
11434
11435 public increment_result deepCopy() {
11436 return new increment_result(this);
11437 }
11438
11439 @Override
11440 public void clear() {
11441 this.success = null;
11442 this.io = null;
11443 }
11444
11445 public TResult getSuccess() {
11446 return this.success;
11447 }
11448
11449 public increment_result setSuccess(TResult success) {
11450 this.success = success;
11451 return this;
11452 }
11453
11454 public void unsetSuccess() {
11455 this.success = null;
11456 }
11457
11458
11459 public boolean isSetSuccess() {
11460 return this.success != null;
11461 }
11462
11463 public void setSuccessIsSet(boolean value) {
11464 if (!value) {
11465 this.success = null;
11466 }
11467 }
11468
11469 public TIOError getIo() {
11470 return this.io;
11471 }
11472
11473 public increment_result setIo(TIOError io) {
11474 this.io = io;
11475 return this;
11476 }
11477
11478 public void unsetIo() {
11479 this.io = null;
11480 }
11481
11482
11483 public boolean isSetIo() {
11484 return this.io != null;
11485 }
11486
11487 public void setIoIsSet(boolean value) {
11488 if (!value) {
11489 this.io = null;
11490 }
11491 }
11492
11493 public void setFieldValue(_Fields field, Object value) {
11494 switch (field) {
11495 case SUCCESS:
11496 if (value == null) {
11497 unsetSuccess();
11498 } else {
11499 setSuccess((TResult)value);
11500 }
11501 break;
11502
11503 case IO:
11504 if (value == null) {
11505 unsetIo();
11506 } else {
11507 setIo((TIOError)value);
11508 }
11509 break;
11510
11511 }
11512 }
11513
11514 public Object getFieldValue(_Fields field) {
11515 switch (field) {
11516 case SUCCESS:
11517 return getSuccess();
11518
11519 case IO:
11520 return getIo();
11521
11522 }
11523 throw new IllegalStateException();
11524 }
11525
11526
11527 public boolean isSet(_Fields field) {
11528 if (field == null) {
11529 throw new IllegalArgumentException();
11530 }
11531
11532 switch (field) {
11533 case SUCCESS:
11534 return isSetSuccess();
11535 case IO:
11536 return isSetIo();
11537 }
11538 throw new IllegalStateException();
11539 }
11540
11541 @Override
11542 public boolean equals(Object that) {
11543 if (that == null)
11544 return false;
11545 if (that instanceof increment_result)
11546 return this.equals((increment_result)that);
11547 return false;
11548 }
11549
11550 public boolean equals(increment_result that) {
11551 if (that == null)
11552 return false;
11553
11554 boolean this_present_success = true && this.isSetSuccess();
11555 boolean that_present_success = true && that.isSetSuccess();
11556 if (this_present_success || that_present_success) {
11557 if (!(this_present_success && that_present_success))
11558 return false;
11559 if (!this.success.equals(that.success))
11560 return false;
11561 }
11562
11563 boolean this_present_io = true && this.isSetIo();
11564 boolean that_present_io = true && that.isSetIo();
11565 if (this_present_io || that_present_io) {
11566 if (!(this_present_io && that_present_io))
11567 return false;
11568 if (!this.io.equals(that.io))
11569 return false;
11570 }
11571
11572 return true;
11573 }
11574
11575 @Override
11576 public int hashCode() {
11577 return 0;
11578 }
11579
11580 public int compareTo(increment_result other) {
11581 if (!getClass().equals(other.getClass())) {
11582 return getClass().getName().compareTo(other.getClass().getName());
11583 }
11584
11585 int lastComparison = 0;
11586 increment_result typedOther = (increment_result)other;
11587
11588 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
11589 if (lastComparison != 0) {
11590 return lastComparison;
11591 }
11592 if (isSetSuccess()) {
11593 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
11594 if (lastComparison != 0) {
11595 return lastComparison;
11596 }
11597 }
11598 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
11599 if (lastComparison != 0) {
11600 return lastComparison;
11601 }
11602 if (isSetIo()) {
11603 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
11604 if (lastComparison != 0) {
11605 return lastComparison;
11606 }
11607 }
11608 return 0;
11609 }
11610
11611 public _Fields fieldForId(int fieldId) {
11612 return _Fields.findByThriftId(fieldId);
11613 }
11614
11615 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
11616 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
11617 }
11618
11619 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
11620 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
11621 }
11622
11623 @Override
11624 public String toString() {
11625 StringBuilder sb = new StringBuilder("increment_result(");
11626 boolean first = true;
11627
11628 sb.append("success:");
11629 if (this.success == null) {
11630 sb.append("null");
11631 } else {
11632 sb.append(this.success);
11633 }
11634 first = false;
11635 if (!first) sb.append(", ");
11636 sb.append("io:");
11637 if (this.io == null) {
11638 sb.append("null");
11639 } else {
11640 sb.append(this.io);
11641 }
11642 first = false;
11643 sb.append(")");
11644 return sb.toString();
11645 }
11646
11647 public void validate() throws org.apache.thrift.TException {
11648
11649 }
11650
11651 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
11652 try {
11653 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
11654 } catch (org.apache.thrift.TException te) {
11655 throw new java.io.IOException(te);
11656 }
11657 }
11658
11659 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
11660 try {
11661 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
11662 } catch (org.apache.thrift.TException te) {
11663 throw new java.io.IOException(te);
11664 }
11665 }
11666
11667 private static class increment_resultStandardSchemeFactory implements SchemeFactory {
11668 public increment_resultStandardScheme getScheme() {
11669 return new increment_resultStandardScheme();
11670 }
11671 }
11672
11673 private static class increment_resultStandardScheme extends StandardScheme<increment_result> {
11674
11675 public void read(org.apache.thrift.protocol.TProtocol iprot, increment_result struct) throws org.apache.thrift.TException {
11676 org.apache.thrift.protocol.TField schemeField;
11677 iprot.readStructBegin();
11678 while (true)
11679 {
11680 schemeField = iprot.readFieldBegin();
11681 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
11682 break;
11683 }
11684 switch (schemeField.id) {
11685 case 0:
11686 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11687 struct.success = new TResult();
11688 struct.success.read(iprot);
11689 struct.setSuccessIsSet(true);
11690 } else {
11691 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11692 }
11693 break;
11694 case 1:
11695 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11696 struct.io = new TIOError();
11697 struct.io.read(iprot);
11698 struct.setIoIsSet(true);
11699 } else {
11700 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11701 }
11702 break;
11703 default:
11704 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11705 }
11706 iprot.readFieldEnd();
11707 }
11708 iprot.readStructEnd();
11709
11710
11711 struct.validate();
11712 }
11713
11714 public void write(org.apache.thrift.protocol.TProtocol oprot, increment_result struct) throws org.apache.thrift.TException {
11715 struct.validate();
11716
11717 oprot.writeStructBegin(STRUCT_DESC);
11718 if (struct.success != null) {
11719 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11720 struct.success.write(oprot);
11721 oprot.writeFieldEnd();
11722 }
11723 if (struct.io != null) {
11724 oprot.writeFieldBegin(IO_FIELD_DESC);
11725 struct.io.write(oprot);
11726 oprot.writeFieldEnd();
11727 }
11728 oprot.writeFieldStop();
11729 oprot.writeStructEnd();
11730 }
11731
11732 }
11733
11734 private static class increment_resultTupleSchemeFactory implements SchemeFactory {
11735 public increment_resultTupleScheme getScheme() {
11736 return new increment_resultTupleScheme();
11737 }
11738 }
11739
11740 private static class increment_resultTupleScheme extends TupleScheme<increment_result> {
11741
11742 @Override
11743 public void write(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
11744 TTupleProtocol oprot = (TTupleProtocol) prot;
11745 BitSet optionals = new BitSet();
11746 if (struct.isSetSuccess()) {
11747 optionals.set(0);
11748 }
11749 if (struct.isSetIo()) {
11750 optionals.set(1);
11751 }
11752 oprot.writeBitSet(optionals, 2);
11753 if (struct.isSetSuccess()) {
11754 struct.success.write(oprot);
11755 }
11756 if (struct.isSetIo()) {
11757 struct.io.write(oprot);
11758 }
11759 }
11760
11761 @Override
11762 public void read(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
11763 TTupleProtocol iprot = (TTupleProtocol) prot;
11764 BitSet incoming = iprot.readBitSet(2);
11765 if (incoming.get(0)) {
11766 struct.success = new TResult();
11767 struct.success.read(iprot);
11768 struct.setSuccessIsSet(true);
11769 }
11770 if (incoming.get(1)) {
11771 struct.io = new TIOError();
11772 struct.io.read(iprot);
11773 struct.setIoIsSet(true);
11774 }
11775 }
11776 }
11777
11778 }
11779
11780 public static class openScanner_args implements org.apache.thrift.TBase<openScanner_args, openScanner_args._Fields>, java.io.Serializable, Cloneable {
11781 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_args");
11782
11783 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);
11784 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);
11785
11786 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
11787 static {
11788 schemes.put(StandardScheme.class, new openScanner_argsStandardSchemeFactory());
11789 schemes.put(TupleScheme.class, new openScanner_argsTupleSchemeFactory());
11790 }
11791
11792
11793
11794
11795 public ByteBuffer table;
11796
11797
11798
11799 public TScan scan;
11800
11801
11802 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
11803
11804
11805
11806 TABLE((short)1, "table"),
11807
11808
11809
11810 SCAN((short)2, "scan");
11811
11812 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11813
11814 static {
11815 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11816 byName.put(field.getFieldName(), field);
11817 }
11818 }
11819
11820
11821
11822
11823 public static _Fields findByThriftId(int fieldId) {
11824 switch(fieldId) {
11825 case 1:
11826 return TABLE;
11827 case 2:
11828 return SCAN;
11829 default:
11830 return null;
11831 }
11832 }
11833
11834
11835
11836
11837
11838 public static _Fields findByThriftIdOrThrow(int fieldId) {
11839 _Fields fields = findByThriftId(fieldId);
11840 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11841 return fields;
11842 }
11843
11844
11845
11846
11847 public static _Fields findByName(String name) {
11848 return byName.get(name);
11849 }
11850
11851 private final short _thriftId;
11852 private final String _fieldName;
11853
11854 _Fields(short thriftId, String fieldName) {
11855 _thriftId = thriftId;
11856 _fieldName = fieldName;
11857 }
11858
11859 public short getThriftFieldId() {
11860 return _thriftId;
11861 }
11862
11863 public String getFieldName() {
11864 return _fieldName;
11865 }
11866 }
11867
11868
11869 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
11870 static {
11871 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
11872 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
11873 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
11874 tmpMap.put(_Fields.SCAN, new org.apache.thrift.meta_data.FieldMetaData("scan", org.apache.thrift.TFieldRequirementType.REQUIRED,
11875 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TScan.class)));
11876 metaDataMap = Collections.unmodifiableMap(tmpMap);
11877 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_args.class, metaDataMap);
11878 }
11879
11880 public openScanner_args() {
11881 }
11882
11883 public openScanner_args(
11884 ByteBuffer table,
11885 TScan scan)
11886 {
11887 this();
11888 this.table = table;
11889 this.scan = scan;
11890 }
11891
11892
11893
11894
11895 public openScanner_args(openScanner_args other) {
11896 if (other.isSetTable()) {
11897 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
11898 ;
11899 }
11900 if (other.isSetScan()) {
11901 this.scan = new TScan(other.scan);
11902 }
11903 }
11904
11905 public openScanner_args deepCopy() {
11906 return new openScanner_args(this);
11907 }
11908
11909 @Override
11910 public void clear() {
11911 this.table = null;
11912 this.scan = null;
11913 }
11914
11915
11916
11917
11918 public byte[] getTable() {
11919 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
11920 return table == null ? null : table.array();
11921 }
11922
11923 public ByteBuffer bufferForTable() {
11924 return table;
11925 }
11926
11927
11928
11929
11930 public openScanner_args setTable(byte[] table) {
11931 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
11932 return this;
11933 }
11934
11935 public openScanner_args setTable(ByteBuffer table) {
11936 this.table = table;
11937 return this;
11938 }
11939
11940 public void unsetTable() {
11941 this.table = null;
11942 }
11943
11944
11945 public boolean isSetTable() {
11946 return this.table != null;
11947 }
11948
11949 public void setTableIsSet(boolean value) {
11950 if (!value) {
11951 this.table = null;
11952 }
11953 }
11954
11955
11956
11957
11958 public TScan getScan() {
11959 return this.scan;
11960 }
11961
11962
11963
11964
11965 public openScanner_args setScan(TScan scan) {
11966 this.scan = scan;
11967 return this;
11968 }
11969
11970 public void unsetScan() {
11971 this.scan = null;
11972 }
11973
11974
11975 public boolean isSetScan() {
11976 return this.scan != null;
11977 }
11978
11979 public void setScanIsSet(boolean value) {
11980 if (!value) {
11981 this.scan = null;
11982 }
11983 }
11984
11985 public void setFieldValue(_Fields field, Object value) {
11986 switch (field) {
11987 case TABLE:
11988 if (value == null) {
11989 unsetTable();
11990 } else {
11991 setTable((ByteBuffer)value);
11992 }
11993 break;
11994
11995 case SCAN:
11996 if (value == null) {
11997 unsetScan();
11998 } else {
11999 setScan((TScan)value);
12000 }
12001 break;
12002
12003 }
12004 }
12005
12006 public Object getFieldValue(_Fields field) {
12007 switch (field) {
12008 case TABLE:
12009 return getTable();
12010
12011 case SCAN:
12012 return getScan();
12013
12014 }
12015 throw new IllegalStateException();
12016 }
12017
12018
12019 public boolean isSet(_Fields field) {
12020 if (field == null) {
12021 throw new IllegalArgumentException();
12022 }
12023
12024 switch (field) {
12025 case TABLE:
12026 return isSetTable();
12027 case SCAN:
12028 return isSetScan();
12029 }
12030 throw new IllegalStateException();
12031 }
12032
12033 @Override
12034 public boolean equals(Object that) {
12035 if (that == null)
12036 return false;
12037 if (that instanceof openScanner_args)
12038 return this.equals((openScanner_args)that);
12039 return false;
12040 }
12041
12042 public boolean equals(openScanner_args that) {
12043 if (that == null)
12044 return false;
12045
12046 boolean this_present_table = true && this.isSetTable();
12047 boolean that_present_table = true && that.isSetTable();
12048 if (this_present_table || that_present_table) {
12049 if (!(this_present_table && that_present_table))
12050 return false;
12051 if (!this.table.equals(that.table))
12052 return false;
12053 }
12054
12055 boolean this_present_scan = true && this.isSetScan();
12056 boolean that_present_scan = true && that.isSetScan();
12057 if (this_present_scan || that_present_scan) {
12058 if (!(this_present_scan && that_present_scan))
12059 return false;
12060 if (!this.scan.equals(that.scan))
12061 return false;
12062 }
12063
12064 return true;
12065 }
12066
12067 @Override
12068 public int hashCode() {
12069 return 0;
12070 }
12071
12072 public int compareTo(openScanner_args other) {
12073 if (!getClass().equals(other.getClass())) {
12074 return getClass().getName().compareTo(other.getClass().getName());
12075 }
12076
12077 int lastComparison = 0;
12078 openScanner_args typedOther = (openScanner_args)other;
12079
12080 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
12081 if (lastComparison != 0) {
12082 return lastComparison;
12083 }
12084 if (isSetTable()) {
12085 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
12086 if (lastComparison != 0) {
12087 return lastComparison;
12088 }
12089 }
12090 lastComparison = Boolean.valueOf(isSetScan()).compareTo(typedOther.isSetScan());
12091 if (lastComparison != 0) {
12092 return lastComparison;
12093 }
12094 if (isSetScan()) {
12095 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scan, typedOther.scan);
12096 if (lastComparison != 0) {
12097 return lastComparison;
12098 }
12099 }
12100 return 0;
12101 }
12102
12103 public _Fields fieldForId(int fieldId) {
12104 return _Fields.findByThriftId(fieldId);
12105 }
12106
12107 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
12108 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
12109 }
12110
12111 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
12112 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
12113 }
12114
12115 @Override
12116 public String toString() {
12117 StringBuilder sb = new StringBuilder("openScanner_args(");
12118 boolean first = true;
12119
12120 sb.append("table:");
12121 if (this.table == null) {
12122 sb.append("null");
12123 } else {
12124 org.apache.thrift.TBaseHelper.toString(this.table, sb);
12125 }
12126 first = false;
12127 if (!first) sb.append(", ");
12128 sb.append("scan:");
12129 if (this.scan == null) {
12130 sb.append("null");
12131 } else {
12132 sb.append(this.scan);
12133 }
12134 first = false;
12135 sb.append(")");
12136 return sb.toString();
12137 }
12138
12139 public void validate() throws org.apache.thrift.TException {
12140
12141 if (table == null) {
12142 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
12143 }
12144 if (scan == null) {
12145 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scan' was not present! Struct: " + toString());
12146 }
12147 }
12148
12149 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12150 try {
12151 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12152 } catch (org.apache.thrift.TException te) {
12153 throw new java.io.IOException(te);
12154 }
12155 }
12156
12157 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12158 try {
12159 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12160 } catch (org.apache.thrift.TException te) {
12161 throw new java.io.IOException(te);
12162 }
12163 }
12164
12165 private static class openScanner_argsStandardSchemeFactory implements SchemeFactory {
12166 public openScanner_argsStandardScheme getScheme() {
12167 return new openScanner_argsStandardScheme();
12168 }
12169 }
12170
12171 private static class openScanner_argsStandardScheme extends StandardScheme<openScanner_args> {
12172
12173 public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_args struct) throws org.apache.thrift.TException {
12174 org.apache.thrift.protocol.TField schemeField;
12175 iprot.readStructBegin();
12176 while (true)
12177 {
12178 schemeField = iprot.readFieldBegin();
12179 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
12180 break;
12181 }
12182 switch (schemeField.id) {
12183 case 1:
12184 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
12185 struct.table = iprot.readBinary();
12186 struct.setTableIsSet(true);
12187 } else {
12188 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12189 }
12190 break;
12191 case 2:
12192 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
12193 struct.scan = new TScan();
12194 struct.scan.read(iprot);
12195 struct.setScanIsSet(true);
12196 } else {
12197 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12198 }
12199 break;
12200 default:
12201 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12202 }
12203 iprot.readFieldEnd();
12204 }
12205 iprot.readStructEnd();
12206
12207
12208 struct.validate();
12209 }
12210
12211 public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_args struct) throws org.apache.thrift.TException {
12212 struct.validate();
12213
12214 oprot.writeStructBegin(STRUCT_DESC);
12215 if (struct.table != null) {
12216 oprot.writeFieldBegin(TABLE_FIELD_DESC);
12217 oprot.writeBinary(struct.table);
12218 oprot.writeFieldEnd();
12219 }
12220 if (struct.scan != null) {
12221 oprot.writeFieldBegin(SCAN_FIELD_DESC);
12222 struct.scan.write(oprot);
12223 oprot.writeFieldEnd();
12224 }
12225 oprot.writeFieldStop();
12226 oprot.writeStructEnd();
12227 }
12228
12229 }
12230
12231 private static class openScanner_argsTupleSchemeFactory implements SchemeFactory {
12232 public openScanner_argsTupleScheme getScheme() {
12233 return new openScanner_argsTupleScheme();
12234 }
12235 }
12236
12237 private static class openScanner_argsTupleScheme extends TupleScheme<openScanner_args> {
12238
12239 @Override
12240 public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
12241 TTupleProtocol oprot = (TTupleProtocol) prot;
12242 oprot.writeBinary(struct.table);
12243 struct.scan.write(oprot);
12244 }
12245
12246 @Override
12247 public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
12248 TTupleProtocol iprot = (TTupleProtocol) prot;
12249 struct.table = iprot.readBinary();
12250 struct.setTableIsSet(true);
12251 struct.scan = new TScan();
12252 struct.scan.read(iprot);
12253 struct.setScanIsSet(true);
12254 }
12255 }
12256
12257 }
12258
12259 public static class openScanner_result implements org.apache.thrift.TBase<openScanner_result, openScanner_result._Fields>, java.io.Serializable, Cloneable {
12260 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_result");
12261
12262 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);
12263 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);
12264
12265 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
12266 static {
12267 schemes.put(StandardScheme.class, new openScanner_resultStandardSchemeFactory());
12268 schemes.put(TupleScheme.class, new openScanner_resultTupleSchemeFactory());
12269 }
12270
12271 public int success;
12272 public TIOError io;
12273
12274
12275 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
12276 SUCCESS((short)0, "success"),
12277 IO((short)1, "io");
12278
12279 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12280
12281 static {
12282 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12283 byName.put(field.getFieldName(), field);
12284 }
12285 }
12286
12287
12288
12289
12290 public static _Fields findByThriftId(int fieldId) {
12291 switch(fieldId) {
12292 case 0:
12293 return SUCCESS;
12294 case 1:
12295 return IO;
12296 default:
12297 return null;
12298 }
12299 }
12300
12301
12302
12303
12304
12305 public static _Fields findByThriftIdOrThrow(int fieldId) {
12306 _Fields fields = findByThriftId(fieldId);
12307 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12308 return fields;
12309 }
12310
12311
12312
12313
12314 public static _Fields findByName(String name) {
12315 return byName.get(name);
12316 }
12317
12318 private final short _thriftId;
12319 private final String _fieldName;
12320
12321 _Fields(short thriftId, String fieldName) {
12322 _thriftId = thriftId;
12323 _fieldName = fieldName;
12324 }
12325
12326 public short getThriftFieldId() {
12327 return _thriftId;
12328 }
12329
12330 public String getFieldName() {
12331 return _fieldName;
12332 }
12333 }
12334
12335
12336 private static final int __SUCCESS_ISSET_ID = 0;
12337 private BitSet __isset_bit_vector = new BitSet(1);
12338 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
12339 static {
12340 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
12341 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
12342 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12343 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
12344 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
12345 metaDataMap = Collections.unmodifiableMap(tmpMap);
12346 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_result.class, metaDataMap);
12347 }
12348
12349 public openScanner_result() {
12350 }
12351
12352 public openScanner_result(
12353 int success,
12354 TIOError io)
12355 {
12356 this();
12357 this.success = success;
12358 setSuccessIsSet(true);
12359 this.io = io;
12360 }
12361
12362
12363
12364
12365 public openScanner_result(openScanner_result other) {
12366 __isset_bit_vector.clear();
12367 __isset_bit_vector.or(other.__isset_bit_vector);
12368 this.success = other.success;
12369 if (other.isSetIo()) {
12370 this.io = new TIOError(other.io);
12371 }
12372 }
12373
12374 public openScanner_result deepCopy() {
12375 return new openScanner_result(this);
12376 }
12377
12378 @Override
12379 public void clear() {
12380 setSuccessIsSet(false);
12381 this.success = 0;
12382 this.io = null;
12383 }
12384
12385 public int getSuccess() {
12386 return this.success;
12387 }
12388
12389 public openScanner_result setSuccess(int success) {
12390 this.success = success;
12391 setSuccessIsSet(true);
12392 return this;
12393 }
12394
12395 public void unsetSuccess() {
12396 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
12397 }
12398
12399
12400 public boolean isSetSuccess() {
12401 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
12402 }
12403
12404 public void setSuccessIsSet(boolean value) {
12405 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
12406 }
12407
12408 public TIOError getIo() {
12409 return this.io;
12410 }
12411
12412 public openScanner_result setIo(TIOError io) {
12413 this.io = io;
12414 return this;
12415 }
12416
12417 public void unsetIo() {
12418 this.io = null;
12419 }
12420
12421
12422 public boolean isSetIo() {
12423 return this.io != null;
12424 }
12425
12426 public void setIoIsSet(boolean value) {
12427 if (!value) {
12428 this.io = null;
12429 }
12430 }
12431
12432 public void setFieldValue(_Fields field, Object value) {
12433 switch (field) {
12434 case SUCCESS:
12435 if (value == null) {
12436 unsetSuccess();
12437 } else {
12438 setSuccess((Integer)value);
12439 }
12440 break;
12441
12442 case IO:
12443 if (value == null) {
12444 unsetIo();
12445 } else {
12446 setIo((TIOError)value);
12447 }
12448 break;
12449
12450 }
12451 }
12452
12453 public Object getFieldValue(_Fields field) {
12454 switch (field) {
12455 case SUCCESS:
12456 return Integer.valueOf(getSuccess());
12457
12458 case IO:
12459 return getIo();
12460
12461 }
12462 throw new IllegalStateException();
12463 }
12464
12465
12466 public boolean isSet(_Fields field) {
12467 if (field == null) {
12468 throw new IllegalArgumentException();
12469 }
12470
12471 switch (field) {
12472 case SUCCESS:
12473 return isSetSuccess();
12474 case IO:
12475 return isSetIo();
12476 }
12477 throw new IllegalStateException();
12478 }
12479
12480 @Override
12481 public boolean equals(Object that) {
12482 if (that == null)
12483 return false;
12484 if (that instanceof openScanner_result)
12485 return this.equals((openScanner_result)that);
12486 return false;
12487 }
12488
12489 public boolean equals(openScanner_result that) {
12490 if (that == null)
12491 return false;
12492
12493 boolean this_present_success = true;
12494 boolean that_present_success = true;
12495 if (this_present_success || that_present_success) {
12496 if (!(this_present_success && that_present_success))
12497 return false;
12498 if (this.success != that.success)
12499 return false;
12500 }
12501
12502 boolean this_present_io = true && this.isSetIo();
12503 boolean that_present_io = true && that.isSetIo();
12504 if (this_present_io || that_present_io) {
12505 if (!(this_present_io && that_present_io))
12506 return false;
12507 if (!this.io.equals(that.io))
12508 return false;
12509 }
12510
12511 return true;
12512 }
12513
12514 @Override
12515 public int hashCode() {
12516 return 0;
12517 }
12518
12519 public int compareTo(openScanner_result other) {
12520 if (!getClass().equals(other.getClass())) {
12521 return getClass().getName().compareTo(other.getClass().getName());
12522 }
12523
12524 int lastComparison = 0;
12525 openScanner_result typedOther = (openScanner_result)other;
12526
12527 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
12528 if (lastComparison != 0) {
12529 return lastComparison;
12530 }
12531 if (isSetSuccess()) {
12532 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
12533 if (lastComparison != 0) {
12534 return lastComparison;
12535 }
12536 }
12537 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
12538 if (lastComparison != 0) {
12539 return lastComparison;
12540 }
12541 if (isSetIo()) {
12542 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
12543 if (lastComparison != 0) {
12544 return lastComparison;
12545 }
12546 }
12547 return 0;
12548 }
12549
12550 public _Fields fieldForId(int fieldId) {
12551 return _Fields.findByThriftId(fieldId);
12552 }
12553
12554 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
12555 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
12556 }
12557
12558 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
12559 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
12560 }
12561
12562 @Override
12563 public String toString() {
12564 StringBuilder sb = new StringBuilder("openScanner_result(");
12565 boolean first = true;
12566
12567 sb.append("success:");
12568 sb.append(this.success);
12569 first = false;
12570 if (!first) sb.append(", ");
12571 sb.append("io:");
12572 if (this.io == null) {
12573 sb.append("null");
12574 } else {
12575 sb.append(this.io);
12576 }
12577 first = false;
12578 sb.append(")");
12579 return sb.toString();
12580 }
12581
12582 public void validate() throws org.apache.thrift.TException {
12583
12584 }
12585
12586 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12587 try {
12588 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12589 } catch (org.apache.thrift.TException te) {
12590 throw new java.io.IOException(te);
12591 }
12592 }
12593
12594 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12595 try {
12596
12597 __isset_bit_vector = new BitSet(1);
12598 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12599 } catch (org.apache.thrift.TException te) {
12600 throw new java.io.IOException(te);
12601 }
12602 }
12603
12604 private static class openScanner_resultStandardSchemeFactory implements SchemeFactory {
12605 public openScanner_resultStandardScheme getScheme() {
12606 return new openScanner_resultStandardScheme();
12607 }
12608 }
12609
12610 private static class openScanner_resultStandardScheme extends StandardScheme<openScanner_result> {
12611
12612 public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_result struct) throws org.apache.thrift.TException {
12613 org.apache.thrift.protocol.TField schemeField;
12614 iprot.readStructBegin();
12615 while (true)
12616 {
12617 schemeField = iprot.readFieldBegin();
12618 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
12619 break;
12620 }
12621 switch (schemeField.id) {
12622 case 0:
12623 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
12624 struct.success = iprot.readI32();
12625 struct.setSuccessIsSet(true);
12626 } else {
12627 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12628 }
12629 break;
12630 case 1:
12631 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
12632 struct.io = new TIOError();
12633 struct.io.read(iprot);
12634 struct.setIoIsSet(true);
12635 } else {
12636 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12637 }
12638 break;
12639 default:
12640 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12641 }
12642 iprot.readFieldEnd();
12643 }
12644 iprot.readStructEnd();
12645
12646
12647 struct.validate();
12648 }
12649
12650 public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_result struct) throws org.apache.thrift.TException {
12651 struct.validate();
12652
12653 oprot.writeStructBegin(STRUCT_DESC);
12654 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12655 oprot.writeI32(struct.success);
12656 oprot.writeFieldEnd();
12657 if (struct.io != null) {
12658 oprot.writeFieldBegin(IO_FIELD_DESC);
12659 struct.io.write(oprot);
12660 oprot.writeFieldEnd();
12661 }
12662 oprot.writeFieldStop();
12663 oprot.writeStructEnd();
12664 }
12665
12666 }
12667
12668 private static class openScanner_resultTupleSchemeFactory implements SchemeFactory {
12669 public openScanner_resultTupleScheme getScheme() {
12670 return new openScanner_resultTupleScheme();
12671 }
12672 }
12673
12674 private static class openScanner_resultTupleScheme extends TupleScheme<openScanner_result> {
12675
12676 @Override
12677 public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
12678 TTupleProtocol oprot = (TTupleProtocol) prot;
12679 BitSet optionals = new BitSet();
12680 if (struct.isSetSuccess()) {
12681 optionals.set(0);
12682 }
12683 if (struct.isSetIo()) {
12684 optionals.set(1);
12685 }
12686 oprot.writeBitSet(optionals, 2);
12687 if (struct.isSetSuccess()) {
12688 oprot.writeI32(struct.success);
12689 }
12690 if (struct.isSetIo()) {
12691 struct.io.write(oprot);
12692 }
12693 }
12694
12695 @Override
12696 public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
12697 TTupleProtocol iprot = (TTupleProtocol) prot;
12698 BitSet incoming = iprot.readBitSet(2);
12699 if (incoming.get(0)) {
12700 struct.success = iprot.readI32();
12701 struct.setSuccessIsSet(true);
12702 }
12703 if (incoming.get(1)) {
12704 struct.io = new TIOError();
12705 struct.io.read(iprot);
12706 struct.setIoIsSet(true);
12707 }
12708 }
12709 }
12710
12711 }
12712
12713 public static class getScannerRows_args implements org.apache.thrift.TBase<getScannerRows_args, getScannerRows_args._Fields>, java.io.Serializable, Cloneable {
12714 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_args");
12715
12716 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);
12717 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);
12718
12719 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
12720 static {
12721 schemes.put(StandardScheme.class, new getScannerRows_argsStandardSchemeFactory());
12722 schemes.put(TupleScheme.class, new getScannerRows_argsTupleSchemeFactory());
12723 }
12724
12725
12726
12727
12728 public int scannerId;
12729
12730
12731
12732 public int numRows;
12733
12734
12735 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
12736
12737
12738
12739 SCANNER_ID((short)1, "scannerId"),
12740
12741
12742
12743 NUM_ROWS((short)2, "numRows");
12744
12745 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12746
12747 static {
12748 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12749 byName.put(field.getFieldName(), field);
12750 }
12751 }
12752
12753
12754
12755
12756 public static _Fields findByThriftId(int fieldId) {
12757 switch(fieldId) {
12758 case 1:
12759 return SCANNER_ID;
12760 case 2:
12761 return NUM_ROWS;
12762 default:
12763 return null;
12764 }
12765 }
12766
12767
12768
12769
12770
12771 public static _Fields findByThriftIdOrThrow(int fieldId) {
12772 _Fields fields = findByThriftId(fieldId);
12773 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12774 return fields;
12775 }
12776
12777
12778
12779
12780 public static _Fields findByName(String name) {
12781 return byName.get(name);
12782 }
12783
12784 private final short _thriftId;
12785 private final String _fieldName;
12786
12787 _Fields(short thriftId, String fieldName) {
12788 _thriftId = thriftId;
12789 _fieldName = fieldName;
12790 }
12791
12792 public short getThriftFieldId() {
12793 return _thriftId;
12794 }
12795
12796 public String getFieldName() {
12797 return _fieldName;
12798 }
12799 }
12800
12801
12802 private static final int __SCANNERID_ISSET_ID = 0;
12803 private static final int __NUMROWS_ISSET_ID = 1;
12804 private BitSet __isset_bit_vector = new BitSet(2);
12805 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
12806 static {
12807 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
12808 tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
12809 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12810 tmpMap.put(_Fields.NUM_ROWS, new org.apache.thrift.meta_data.FieldMetaData("numRows", org.apache.thrift.TFieldRequirementType.DEFAULT,
12811 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12812 metaDataMap = Collections.unmodifiableMap(tmpMap);
12813 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_args.class, metaDataMap);
12814 }
12815
12816 public getScannerRows_args() {
12817 this.numRows = 1;
12818
12819 }
12820
12821 public getScannerRows_args(
12822 int scannerId,
12823 int numRows)
12824 {
12825 this();
12826 this.scannerId = scannerId;
12827 setScannerIdIsSet(true);
12828 this.numRows = numRows;
12829 setNumRowsIsSet(true);
12830 }
12831
12832
12833
12834
12835 public getScannerRows_args(getScannerRows_args other) {
12836 __isset_bit_vector.clear();
12837 __isset_bit_vector.or(other.__isset_bit_vector);
12838 this.scannerId = other.scannerId;
12839 this.numRows = other.numRows;
12840 }
12841
12842 public getScannerRows_args deepCopy() {
12843 return new getScannerRows_args(this);
12844 }
12845
12846 @Override
12847 public void clear() {
12848 setScannerIdIsSet(false);
12849 this.scannerId = 0;
12850 this.numRows = 1;
12851
12852 }
12853
12854
12855
12856
12857 public int getScannerId() {
12858 return this.scannerId;
12859 }
12860
12861
12862
12863
12864 public getScannerRows_args setScannerId(int scannerId) {
12865 this.scannerId = scannerId;
12866 setScannerIdIsSet(true);
12867 return this;
12868 }
12869
12870 public void unsetScannerId() {
12871 __isset_bit_vector.clear(__SCANNERID_ISSET_ID);
12872 }
12873
12874
12875 public boolean isSetScannerId() {
12876 return __isset_bit_vector.get(__SCANNERID_ISSET_ID);
12877 }
12878
12879 public void setScannerIdIsSet(boolean value) {
12880 __isset_bit_vector.set(__SCANNERID_ISSET_ID, value);
12881 }
12882
12883
12884
12885
12886 public int getNumRows() {
12887 return this.numRows;
12888 }
12889
12890
12891
12892
12893 public getScannerRows_args setNumRows(int numRows) {
12894 this.numRows = numRows;
12895 setNumRowsIsSet(true);
12896 return this;
12897 }
12898
12899 public void unsetNumRows() {
12900 __isset_bit_vector.clear(__NUMROWS_ISSET_ID);
12901 }
12902
12903
12904 public boolean isSetNumRows() {
12905 return __isset_bit_vector.get(__NUMROWS_ISSET_ID);
12906 }
12907
12908 public void setNumRowsIsSet(boolean value) {
12909 __isset_bit_vector.set(__NUMROWS_ISSET_ID, value);
12910 }
12911
12912 public void setFieldValue(_Fields field, Object value) {
12913 switch (field) {
12914 case SCANNER_ID:
12915 if (value == null) {
12916 unsetScannerId();
12917 } else {
12918 setScannerId((Integer)value);
12919 }
12920 break;
12921
12922 case NUM_ROWS:
12923 if (value == null) {
12924 unsetNumRows();
12925 } else {
12926 setNumRows((Integer)value);
12927 }
12928 break;
12929
12930 }
12931 }
12932
12933 public Object getFieldValue(_Fields field) {
12934 switch (field) {
12935 case SCANNER_ID:
12936 return Integer.valueOf(getScannerId());
12937
12938 case NUM_ROWS:
12939 return Integer.valueOf(getNumRows());
12940
12941 }
12942 throw new IllegalStateException();
12943 }
12944
12945
12946 public boolean isSet(_Fields field) {
12947 if (field == null) {
12948 throw new IllegalArgumentException();
12949 }
12950
12951 switch (field) {
12952 case SCANNER_ID:
12953 return isSetScannerId();
12954 case NUM_ROWS:
12955 return isSetNumRows();
12956 }
12957 throw new IllegalStateException();
12958 }
12959
12960 @Override
12961 public boolean equals(Object that) {
12962 if (that == null)
12963 return false;
12964 if (that instanceof getScannerRows_args)
12965 return this.equals((getScannerRows_args)that);
12966 return false;
12967 }
12968
12969 public boolean equals(getScannerRows_args that) {
12970 if (that == null)
12971 return false;
12972
12973 boolean this_present_scannerId = true;
12974 boolean that_present_scannerId = true;
12975 if (this_present_scannerId || that_present_scannerId) {
12976 if (!(this_present_scannerId && that_present_scannerId))
12977 return false;
12978 if (this.scannerId != that.scannerId)
12979 return false;
12980 }
12981
12982 boolean this_present_numRows = true;
12983 boolean that_present_numRows = true;
12984 if (this_present_numRows || that_present_numRows) {
12985 if (!(this_present_numRows && that_present_numRows))
12986 return false;
12987 if (this.numRows != that.numRows)
12988 return false;
12989 }
12990
12991 return true;
12992 }
12993
12994 @Override
12995 public int hashCode() {
12996 return 0;
12997 }
12998
12999 public int compareTo(getScannerRows_args other) {
13000 if (!getClass().equals(other.getClass())) {
13001 return getClass().getName().compareTo(other.getClass().getName());
13002 }
13003
13004 int lastComparison = 0;
13005 getScannerRows_args typedOther = (getScannerRows_args)other;
13006
13007 lastComparison = Boolean.valueOf(isSetScannerId()).compareTo(typedOther.isSetScannerId());
13008 if (lastComparison != 0) {
13009 return lastComparison;
13010 }
13011 if (isSetScannerId()) {
13012 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, typedOther.scannerId);
13013 if (lastComparison != 0) {
13014 return lastComparison;
13015 }
13016 }
13017 lastComparison = Boolean.valueOf(isSetNumRows()).compareTo(typedOther.isSetNumRows());
13018 if (lastComparison != 0) {
13019 return lastComparison;
13020 }
13021 if (isSetNumRows()) {
13022 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numRows, typedOther.numRows);
13023 if (lastComparison != 0) {
13024 return lastComparison;
13025 }
13026 }
13027 return 0;
13028 }
13029
13030 public _Fields fieldForId(int fieldId) {
13031 return _Fields.findByThriftId(fieldId);
13032 }
13033
13034 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
13035 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
13036 }
13037
13038 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
13039 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
13040 }
13041
13042 @Override
13043 public String toString() {
13044 StringBuilder sb = new StringBuilder("getScannerRows_args(");
13045 boolean first = true;
13046
13047 sb.append("scannerId:");
13048 sb.append(this.scannerId);
13049 first = false;
13050 if (!first) sb.append(", ");
13051 sb.append("numRows:");
13052 sb.append(this.numRows);
13053 first = false;
13054 sb.append(")");
13055 return sb.toString();
13056 }
13057
13058 public void validate() throws org.apache.thrift.TException {
13059
13060
13061 }
13062
13063 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
13064 try {
13065 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
13066 } catch (org.apache.thrift.TException te) {
13067 throw new java.io.IOException(te);
13068 }
13069 }
13070
13071 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
13072 try {
13073
13074 __isset_bit_vector = new BitSet(1);
13075 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
13076 } catch (org.apache.thrift.TException te) {
13077 throw new java.io.IOException(te);
13078 }
13079 }
13080
13081 private static class getScannerRows_argsStandardSchemeFactory implements SchemeFactory {
13082 public getScannerRows_argsStandardScheme getScheme() {
13083 return new getScannerRows_argsStandardScheme();
13084 }
13085 }
13086
13087 private static class getScannerRows_argsStandardScheme extends StandardScheme<getScannerRows_args> {
13088
13089 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_args struct) throws org.apache.thrift.TException {
13090 org.apache.thrift.protocol.TField schemeField;
13091 iprot.readStructBegin();
13092 while (true)
13093 {
13094 schemeField = iprot.readFieldBegin();
13095 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
13096 break;
13097 }
13098 switch (schemeField.id) {
13099 case 1:
13100 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
13101 struct.scannerId = iprot.readI32();
13102 struct.setScannerIdIsSet(true);
13103 } else {
13104 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13105 }
13106 break;
13107 case 2:
13108 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
13109 struct.numRows = iprot.readI32();
13110 struct.setNumRowsIsSet(true);
13111 } else {
13112 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13113 }
13114 break;
13115 default:
13116 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13117 }
13118 iprot.readFieldEnd();
13119 }
13120 iprot.readStructEnd();
13121
13122
13123 if (!struct.isSetScannerId()) {
13124 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
13125 }
13126 struct.validate();
13127 }
13128
13129 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_args struct) throws org.apache.thrift.TException {
13130 struct.validate();
13131
13132 oprot.writeStructBegin(STRUCT_DESC);
13133 oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
13134 oprot.writeI32(struct.scannerId);
13135 oprot.writeFieldEnd();
13136 oprot.writeFieldBegin(NUM_ROWS_FIELD_DESC);
13137 oprot.writeI32(struct.numRows);
13138 oprot.writeFieldEnd();
13139 oprot.writeFieldStop();
13140 oprot.writeStructEnd();
13141 }
13142
13143 }
13144
13145 private static class getScannerRows_argsTupleSchemeFactory implements SchemeFactory {
13146 public getScannerRows_argsTupleScheme getScheme() {
13147 return new getScannerRows_argsTupleScheme();
13148 }
13149 }
13150
13151 private static class getScannerRows_argsTupleScheme extends TupleScheme<getScannerRows_args> {
13152
13153 @Override
13154 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
13155 TTupleProtocol oprot = (TTupleProtocol) prot;
13156 oprot.writeI32(struct.scannerId);
13157 BitSet optionals = new BitSet();
13158 if (struct.isSetNumRows()) {
13159 optionals.set(0);
13160 }
13161 oprot.writeBitSet(optionals, 1);
13162 if (struct.isSetNumRows()) {
13163 oprot.writeI32(struct.numRows);
13164 }
13165 }
13166
13167 @Override
13168 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
13169 TTupleProtocol iprot = (TTupleProtocol) prot;
13170 struct.scannerId = iprot.readI32();
13171 struct.setScannerIdIsSet(true);
13172 BitSet incoming = iprot.readBitSet(1);
13173 if (incoming.get(0)) {
13174 struct.numRows = iprot.readI32();
13175 struct.setNumRowsIsSet(true);
13176 }
13177 }
13178 }
13179
13180 }
13181
13182 public static class getScannerRows_result implements org.apache.thrift.TBase<getScannerRows_result, getScannerRows_result._Fields>, java.io.Serializable, Cloneable {
13183 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_result");
13184
13185 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);
13186 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);
13187 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);
13188
13189 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
13190 static {
13191 schemes.put(StandardScheme.class, new getScannerRows_resultStandardSchemeFactory());
13192 schemes.put(TupleScheme.class, new getScannerRows_resultTupleSchemeFactory());
13193 }
13194
13195 public List<TResult> success;
13196 public TIOError io;
13197
13198
13199
13200 public TIllegalArgument ia;
13201
13202
13203 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
13204 SUCCESS((short)0, "success"),
13205 IO((short)1, "io"),
13206
13207
13208
13209 IA((short)2, "ia");
13210
13211 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13212
13213 static {
13214 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13215 byName.put(field.getFieldName(), field);
13216 }
13217 }
13218
13219
13220
13221
13222 public static _Fields findByThriftId(int fieldId) {
13223 switch(fieldId) {
13224 case 0:
13225 return SUCCESS;
13226 case 1:
13227 return IO;
13228 case 2:
13229 return IA;
13230 default:
13231 return null;
13232 }
13233 }
13234
13235
13236
13237
13238
13239 public static _Fields findByThriftIdOrThrow(int fieldId) {
13240 _Fields fields = findByThriftId(fieldId);
13241 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13242 return fields;
13243 }
13244
13245
13246
13247
13248 public static _Fields findByName(String name) {
13249 return byName.get(name);
13250 }
13251
13252 private final short _thriftId;
13253 private final String _fieldName;
13254
13255 _Fields(short thriftId, String fieldName) {
13256 _thriftId = thriftId;
13257 _fieldName = fieldName;
13258 }
13259
13260 public short getThriftFieldId() {
13261 return _thriftId;
13262 }
13263
13264 public String getFieldName() {
13265 return _fieldName;
13266 }
13267 }
13268
13269
13270 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
13271 static {
13272 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
13273 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
13274 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
13275 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
13276 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
13277 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
13278 tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
13279 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
13280 metaDataMap = Collections.unmodifiableMap(tmpMap);
13281 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_result.class, metaDataMap);
13282 }
13283
13284 public getScannerRows_result() {
13285 }
13286
13287 public getScannerRows_result(
13288 List<TResult> success,
13289 TIOError io,
13290 TIllegalArgument ia)
13291 {
13292 this();
13293 this.success = success;
13294 this.io = io;
13295 this.ia = ia;
13296 }
13297
13298
13299
13300
13301 public getScannerRows_result(getScannerRows_result other) {
13302 if (other.isSetSuccess()) {
13303 List<TResult> __this__success = new ArrayList<TResult>();
13304 for (TResult other_element : other.success) {
13305 __this__success.add(new TResult(other_element));
13306 }
13307 this.success = __this__success;
13308 }
13309 if (other.isSetIo()) {
13310 this.io = new TIOError(other.io);
13311 }
13312 if (other.isSetIa()) {
13313 this.ia = new TIllegalArgument(other.ia);
13314 }
13315 }
13316
13317 public getScannerRows_result deepCopy() {
13318 return new getScannerRows_result(this);
13319 }
13320
13321 @Override
13322 public void clear() {
13323 this.success = null;
13324 this.io = null;
13325 this.ia = null;
13326 }
13327
13328 public int getSuccessSize() {
13329 return (this.success == null) ? 0 : this.success.size();
13330 }
13331
13332 public java.util.Iterator<TResult> getSuccessIterator() {
13333 return (this.success == null) ? null : this.success.iterator();
13334 }
13335
13336 public void addToSuccess(TResult elem) {
13337 if (this.success == null) {
13338 this.success = new ArrayList<TResult>();
13339 }
13340 this.success.add(elem);
13341 }
13342
13343 public List<TResult> getSuccess() {
13344 return this.success;
13345 }
13346
13347 public getScannerRows_result setSuccess(List<TResult> success) {
13348 this.success = success;
13349 return this;
13350 }
13351
13352 public void unsetSuccess() {
13353 this.success = null;
13354 }
13355
13356
13357 public boolean isSetSuccess() {
13358 return this.success != null;
13359 }
13360
13361 public void setSuccessIsSet(boolean value) {
13362 if (!value) {
13363 this.success = null;
13364 }
13365 }
13366
13367 public TIOError getIo() {
13368 return this.io;
13369 }
13370
13371 public getScannerRows_result setIo(TIOError io) {
13372 this.io = io;
13373 return this;
13374 }
13375
13376 public void unsetIo() {
13377 this.io = null;
13378 }
13379
13380
13381 public boolean isSetIo() {
13382 return this.io != null;
13383 }
13384
13385 public void setIoIsSet(boolean value) {
13386 if (!value) {
13387 this.io = null;
13388 }
13389 }
13390
13391
13392
13393
13394 public TIllegalArgument getIa() {
13395 return this.ia;
13396 }
13397
13398
13399
13400
13401 public getScannerRows_result setIa(TIllegalArgument ia) {
13402 this.ia = ia;
13403 return this;
13404 }
13405
13406 public void unsetIa() {
13407 this.ia = null;
13408 }
13409
13410
13411 public boolean isSetIa() {
13412 return this.ia != null;
13413 }
13414
13415 public void setIaIsSet(boolean value) {
13416 if (!value) {
13417 this.ia = null;
13418 }
13419 }
13420
13421 public void setFieldValue(_Fields field, Object value) {
13422 switch (field) {
13423 case SUCCESS:
13424 if (value == null) {
13425 unsetSuccess();
13426 } else {
13427 setSuccess((List<TResult>)value);
13428 }
13429 break;
13430
13431 case IO:
13432 if (value == null) {
13433 unsetIo();
13434 } else {
13435 setIo((TIOError)value);
13436 }
13437 break;
13438
13439 case IA:
13440 if (value == null) {
13441 unsetIa();
13442 } else {
13443 setIa((TIllegalArgument)value);
13444 }
13445 break;
13446
13447 }
13448 }
13449
13450 public Object getFieldValue(_Fields field) {
13451 switch (field) {
13452 case SUCCESS:
13453 return getSuccess();
13454
13455 case IO:
13456 return getIo();
13457
13458 case IA:
13459 return getIa();
13460
13461 }
13462 throw new IllegalStateException();
13463 }
13464
13465
13466 public boolean isSet(_Fields field) {
13467 if (field == null) {
13468 throw new IllegalArgumentException();
13469 }
13470
13471 switch (field) {
13472 case SUCCESS:
13473 return isSetSuccess();
13474 case IO:
13475 return isSetIo();
13476 case IA:
13477 return isSetIa();
13478 }
13479 throw new IllegalStateException();
13480 }
13481
13482 @Override
13483 public boolean equals(Object that) {
13484 if (that == null)
13485 return false;
13486 if (that instanceof getScannerRows_result)
13487 return this.equals((getScannerRows_result)that);
13488 return false;
13489 }
13490
13491 public boolean equals(getScannerRows_result that) {
13492 if (that == null)
13493 return false;
13494
13495 boolean this_present_success = true && this.isSetSuccess();
13496 boolean that_present_success = true && that.isSetSuccess();
13497 if (this_present_success || that_present_success) {
13498 if (!(this_present_success && that_present_success))
13499 return false;
13500 if (!this.success.equals(that.success))
13501 return false;
13502 }
13503
13504 boolean this_present_io = true && this.isSetIo();
13505 boolean that_present_io = true && that.isSetIo();
13506 if (this_present_io || that_present_io) {
13507 if (!(this_present_io && that_present_io))
13508 return false;
13509 if (!this.io.equals(that.io))
13510 return false;
13511 }
13512
13513 boolean this_present_ia = true && this.isSetIa();
13514 boolean that_present_ia = true && that.isSetIa();
13515 if (this_present_ia || that_present_ia) {
13516 if (!(this_present_ia && that_present_ia))
13517 return false;
13518 if (!this.ia.equals(that.ia))
13519 return false;
13520 }
13521
13522 return true;
13523 }
13524
13525 @Override
13526 public int hashCode() {
13527 return 0;
13528 }
13529
13530 public int compareTo(getScannerRows_result other) {
13531 if (!getClass().equals(other.getClass())) {
13532 return getClass().getName().compareTo(other.getClass().getName());
13533 }
13534
13535 int lastComparison = 0;
13536 getScannerRows_result typedOther = (getScannerRows_result)other;
13537
13538 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
13539 if (lastComparison != 0) {
13540 return lastComparison;
13541 }
13542 if (isSetSuccess()) {
13543 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
13544 if (lastComparison != 0) {
13545 return lastComparison;
13546 }
13547 }
13548 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
13549 if (lastComparison != 0) {
13550 return lastComparison;
13551 }
13552 if (isSetIo()) {
13553 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
13554 if (lastComparison != 0) {
13555 return lastComparison;
13556 }
13557 }
13558 lastComparison = Boolean.valueOf(isSetIa()).compareTo(typedOther.isSetIa());
13559 if (lastComparison != 0) {
13560 return lastComparison;
13561 }
13562 if (isSetIa()) {
13563 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia);
13564 if (lastComparison != 0) {
13565 return lastComparison;
13566 }
13567 }
13568 return 0;
13569 }
13570
13571 public _Fields fieldForId(int fieldId) {
13572 return _Fields.findByThriftId(fieldId);
13573 }
13574
13575 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
13576 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
13577 }
13578
13579 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
13580 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
13581 }
13582
13583 @Override
13584 public String toString() {
13585 StringBuilder sb = new StringBuilder("getScannerRows_result(");
13586 boolean first = true;
13587
13588 sb.append("success:");
13589 if (this.success == null) {
13590 sb.append("null");
13591 } else {
13592 sb.append(this.success);
13593 }
13594 first = false;
13595 if (!first) sb.append(", ");
13596 sb.append("io:");
13597 if (this.io == null) {
13598 sb.append("null");
13599 } else {
13600 sb.append(this.io);
13601 }
13602 first = false;
13603 if (!first) sb.append(", ");
13604 sb.append("ia:");
13605 if (this.ia == null) {
13606 sb.append("null");
13607 } else {
13608 sb.append(this.ia);
13609 }
13610 first = false;
13611 sb.append(")");
13612 return sb.toString();
13613 }
13614
13615 public void validate() throws org.apache.thrift.TException {
13616
13617 }
13618
13619 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
13620 try {
13621 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
13622 } catch (org.apache.thrift.TException te) {
13623 throw new java.io.IOException(te);
13624 }
13625 }
13626
13627 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
13628 try {
13629 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
13630 } catch (org.apache.thrift.TException te) {
13631 throw new java.io.IOException(te);
13632 }
13633 }
13634
13635 private static class getScannerRows_resultStandardSchemeFactory implements SchemeFactory {
13636 public getScannerRows_resultStandardScheme getScheme() {
13637 return new getScannerRows_resultStandardScheme();
13638 }
13639 }
13640
13641 private static class getScannerRows_resultStandardScheme extends StandardScheme<getScannerRows_result> {
13642
13643 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_result struct) throws org.apache.thrift.TException {
13644 org.apache.thrift.protocol.TField schemeField;
13645 iprot.readStructBegin();
13646 while (true)
13647 {
13648 schemeField = iprot.readFieldBegin();
13649 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
13650 break;
13651 }
13652 switch (schemeField.id) {
13653 case 0:
13654 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
13655 {
13656 org.apache.thrift.protocol.TList _list146 = iprot.readListBegin();
13657 struct.success = new ArrayList<TResult>(_list146.size);
13658 for (int _i147 = 0; _i147 < _list146.size; ++_i147)
13659 {
13660 TResult _elem148;
13661 _elem148 = new TResult();
13662 _elem148.read(iprot);
13663 struct.success.add(_elem148);
13664 }
13665 iprot.readListEnd();
13666 }
13667 struct.setSuccessIsSet(true);
13668 } else {
13669 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13670 }
13671 break;
13672 case 1:
13673 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
13674 struct.io = new TIOError();
13675 struct.io.read(iprot);
13676 struct.setIoIsSet(true);
13677 } else {
13678 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13679 }
13680 break;
13681 case 2:
13682 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
13683 struct.ia = new TIllegalArgument();
13684 struct.ia.read(iprot);
13685 struct.setIaIsSet(true);
13686 } else {
13687 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13688 }
13689 break;
13690 default:
13691 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13692 }
13693 iprot.readFieldEnd();
13694 }
13695 iprot.readStructEnd();
13696
13697
13698 struct.validate();
13699 }
13700
13701 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_result struct) throws org.apache.thrift.TException {
13702 struct.validate();
13703
13704 oprot.writeStructBegin(STRUCT_DESC);
13705 if (struct.success != null) {
13706 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13707 {
13708 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
13709 for (TResult _iter149 : struct.success)
13710 {
13711 _iter149.write(oprot);
13712 }
13713 oprot.writeListEnd();
13714 }
13715 oprot.writeFieldEnd();
13716 }
13717 if (struct.io != null) {
13718 oprot.writeFieldBegin(IO_FIELD_DESC);
13719 struct.io.write(oprot);
13720 oprot.writeFieldEnd();
13721 }
13722 if (struct.ia != null) {
13723 oprot.writeFieldBegin(IA_FIELD_DESC);
13724 struct.ia.write(oprot);
13725 oprot.writeFieldEnd();
13726 }
13727 oprot.writeFieldStop();
13728 oprot.writeStructEnd();
13729 }
13730
13731 }
13732
13733 private static class getScannerRows_resultTupleSchemeFactory implements SchemeFactory {
13734 public getScannerRows_resultTupleScheme getScheme() {
13735 return new getScannerRows_resultTupleScheme();
13736 }
13737 }
13738
13739 private static class getScannerRows_resultTupleScheme extends TupleScheme<getScannerRows_result> {
13740
13741 @Override
13742 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
13743 TTupleProtocol oprot = (TTupleProtocol) prot;
13744 BitSet optionals = new BitSet();
13745 if (struct.isSetSuccess()) {
13746 optionals.set(0);
13747 }
13748 if (struct.isSetIo()) {
13749 optionals.set(1);
13750 }
13751 if (struct.isSetIa()) {
13752 optionals.set(2);
13753 }
13754 oprot.writeBitSet(optionals, 3);
13755 if (struct.isSetSuccess()) {
13756 {
13757 oprot.writeI32(struct.success.size());
13758 for (TResult _iter150 : struct.success)
13759 {
13760 _iter150.write(oprot);
13761 }
13762 }
13763 }
13764 if (struct.isSetIo()) {
13765 struct.io.write(oprot);
13766 }
13767 if (struct.isSetIa()) {
13768 struct.ia.write(oprot);
13769 }
13770 }
13771
13772 @Override
13773 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
13774 TTupleProtocol iprot = (TTupleProtocol) prot;
13775 BitSet incoming = iprot.readBitSet(3);
13776 if (incoming.get(0)) {
13777 {
13778 org.apache.thrift.protocol.TList _list151 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
13779 struct.success = new ArrayList<TResult>(_list151.size);
13780 for (int _i152 = 0; _i152 < _list151.size; ++_i152)
13781 {
13782 TResult _elem153;
13783 _elem153 = new TResult();
13784 _elem153.read(iprot);
13785 struct.success.add(_elem153);
13786 }
13787 }
13788 struct.setSuccessIsSet(true);
13789 }
13790 if (incoming.get(1)) {
13791 struct.io = new TIOError();
13792 struct.io.read(iprot);
13793 struct.setIoIsSet(true);
13794 }
13795 if (incoming.get(2)) {
13796 struct.ia = new TIllegalArgument();
13797 struct.ia.read(iprot);
13798 struct.setIaIsSet(true);
13799 }
13800 }
13801 }
13802
13803 }
13804
13805 public static class closeScanner_args implements org.apache.thrift.TBase<closeScanner_args, closeScanner_args._Fields>, java.io.Serializable, Cloneable {
13806 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_args");
13807
13808 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);
13809
13810 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
13811 static {
13812 schemes.put(StandardScheme.class, new closeScanner_argsStandardSchemeFactory());
13813 schemes.put(TupleScheme.class, new closeScanner_argsTupleSchemeFactory());
13814 }
13815
13816
13817
13818
13819 public int scannerId;
13820
13821
13822 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
13823
13824
13825
13826 SCANNER_ID((short)1, "scannerId");
13827
13828 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13829
13830 static {
13831 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13832 byName.put(field.getFieldName(), field);
13833 }
13834 }
13835
13836
13837
13838
13839 public static _Fields findByThriftId(int fieldId) {
13840 switch(fieldId) {
13841 case 1:
13842 return SCANNER_ID;
13843 default:
13844 return null;
13845 }
13846 }
13847
13848
13849
13850
13851
13852 public static _Fields findByThriftIdOrThrow(int fieldId) {
13853 _Fields fields = findByThriftId(fieldId);
13854 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13855 return fields;
13856 }
13857
13858
13859
13860
13861 public static _Fields findByName(String name) {
13862 return byName.get(name);
13863 }
13864
13865 private final short _thriftId;
13866 private final String _fieldName;
13867
13868 _Fields(short thriftId, String fieldName) {
13869 _thriftId = thriftId;
13870 _fieldName = fieldName;
13871 }
13872
13873 public short getThriftFieldId() {
13874 return _thriftId;
13875 }
13876
13877 public String getFieldName() {
13878 return _fieldName;
13879 }
13880 }
13881
13882
13883 private static final int __SCANNERID_ISSET_ID = 0;
13884 private BitSet __isset_bit_vector = new BitSet(1);
13885 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
13886 static {
13887 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
13888 tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
13889 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
13890 metaDataMap = Collections.unmodifiableMap(tmpMap);
13891 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_args.class, metaDataMap);
13892 }
13893
13894 public closeScanner_args() {
13895 }
13896
13897 public closeScanner_args(
13898 int scannerId)
13899 {
13900 this();
13901 this.scannerId = scannerId;
13902 setScannerIdIsSet(true);
13903 }
13904
13905
13906
13907
13908 public closeScanner_args(closeScanner_args other) {
13909 __isset_bit_vector.clear();
13910 __isset_bit_vector.or(other.__isset_bit_vector);
13911 this.scannerId = other.scannerId;
13912 }
13913
13914 public closeScanner_args deepCopy() {
13915 return new closeScanner_args(this);
13916 }
13917
13918 @Override
13919 public void clear() {
13920 setScannerIdIsSet(false);
13921 this.scannerId = 0;
13922 }
13923
13924
13925
13926
13927 public int getScannerId() {
13928 return this.scannerId;
13929 }
13930
13931
13932
13933
13934 public closeScanner_args setScannerId(int scannerId) {
13935 this.scannerId = scannerId;
13936 setScannerIdIsSet(true);
13937 return this;
13938 }
13939
13940 public void unsetScannerId() {
13941 __isset_bit_vector.clear(__SCANNERID_ISSET_ID);
13942 }
13943
13944
13945 public boolean isSetScannerId() {
13946 return __isset_bit_vector.get(__SCANNERID_ISSET_ID);
13947 }
13948
13949 public void setScannerIdIsSet(boolean value) {
13950 __isset_bit_vector.set(__SCANNERID_ISSET_ID, value);
13951 }
13952
13953 public void setFieldValue(_Fields field, Object value) {
13954 switch (field) {
13955 case SCANNER_ID:
13956 if (value == null) {
13957 unsetScannerId();
13958 } else {
13959 setScannerId((Integer)value);
13960 }
13961 break;
13962
13963 }
13964 }
13965
13966 public Object getFieldValue(_Fields field) {
13967 switch (field) {
13968 case SCANNER_ID:
13969 return Integer.valueOf(getScannerId());
13970
13971 }
13972 throw new IllegalStateException();
13973 }
13974
13975
13976 public boolean isSet(_Fields field) {
13977 if (field == null) {
13978 throw new IllegalArgumentException();
13979 }
13980
13981 switch (field) {
13982 case SCANNER_ID:
13983 return isSetScannerId();
13984 }
13985 throw new IllegalStateException();
13986 }
13987
13988 @Override
13989 public boolean equals(Object that) {
13990 if (that == null)
13991 return false;
13992 if (that instanceof closeScanner_args)
13993 return this.equals((closeScanner_args)that);
13994 return false;
13995 }
13996
13997 public boolean equals(closeScanner_args that) {
13998 if (that == null)
13999 return false;
14000
14001 boolean this_present_scannerId = true;
14002 boolean that_present_scannerId = true;
14003 if (this_present_scannerId || that_present_scannerId) {
14004 if (!(this_present_scannerId && that_present_scannerId))
14005 return false;
14006 if (this.scannerId != that.scannerId)
14007 return false;
14008 }
14009
14010 return true;
14011 }
14012
14013 @Override
14014 public int hashCode() {
14015 return 0;
14016 }
14017
14018 public int compareTo(closeScanner_args other) {
14019 if (!getClass().equals(other.getClass())) {
14020 return getClass().getName().compareTo(other.getClass().getName());
14021 }
14022
14023 int lastComparison = 0;
14024 closeScanner_args typedOther = (closeScanner_args)other;
14025
14026 lastComparison = Boolean.valueOf(isSetScannerId()).compareTo(typedOther.isSetScannerId());
14027 if (lastComparison != 0) {
14028 return lastComparison;
14029 }
14030 if (isSetScannerId()) {
14031 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, typedOther.scannerId);
14032 if (lastComparison != 0) {
14033 return lastComparison;
14034 }
14035 }
14036 return 0;
14037 }
14038
14039 public _Fields fieldForId(int fieldId) {
14040 return _Fields.findByThriftId(fieldId);
14041 }
14042
14043 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
14044 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
14045 }
14046
14047 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
14048 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
14049 }
14050
14051 @Override
14052 public String toString() {
14053 StringBuilder sb = new StringBuilder("closeScanner_args(");
14054 boolean first = true;
14055
14056 sb.append("scannerId:");
14057 sb.append(this.scannerId);
14058 first = false;
14059 sb.append(")");
14060 return sb.toString();
14061 }
14062
14063 public void validate() throws org.apache.thrift.TException {
14064
14065
14066 }
14067
14068 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
14069 try {
14070 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
14071 } catch (org.apache.thrift.TException te) {
14072 throw new java.io.IOException(te);
14073 }
14074 }
14075
14076 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
14077 try {
14078
14079 __isset_bit_vector = new BitSet(1);
14080 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
14081 } catch (org.apache.thrift.TException te) {
14082 throw new java.io.IOException(te);
14083 }
14084 }
14085
14086 private static class closeScanner_argsStandardSchemeFactory implements SchemeFactory {
14087 public closeScanner_argsStandardScheme getScheme() {
14088 return new closeScanner_argsStandardScheme();
14089 }
14090 }
14091
14092 private static class closeScanner_argsStandardScheme extends StandardScheme<closeScanner_args> {
14093
14094 public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_args struct) throws org.apache.thrift.TException {
14095 org.apache.thrift.protocol.TField schemeField;
14096 iprot.readStructBegin();
14097 while (true)
14098 {
14099 schemeField = iprot.readFieldBegin();
14100 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
14101 break;
14102 }
14103 switch (schemeField.id) {
14104 case 1:
14105 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
14106 struct.scannerId = iprot.readI32();
14107 struct.setScannerIdIsSet(true);
14108 } else {
14109 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14110 }
14111 break;
14112 default:
14113 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14114 }
14115 iprot.readFieldEnd();
14116 }
14117 iprot.readStructEnd();
14118
14119
14120 if (!struct.isSetScannerId()) {
14121 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
14122 }
14123 struct.validate();
14124 }
14125
14126 public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_args struct) throws org.apache.thrift.TException {
14127 struct.validate();
14128
14129 oprot.writeStructBegin(STRUCT_DESC);
14130 oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
14131 oprot.writeI32(struct.scannerId);
14132 oprot.writeFieldEnd();
14133 oprot.writeFieldStop();
14134 oprot.writeStructEnd();
14135 }
14136
14137 }
14138
14139 private static class closeScanner_argsTupleSchemeFactory implements SchemeFactory {
14140 public closeScanner_argsTupleScheme getScheme() {
14141 return new closeScanner_argsTupleScheme();
14142 }
14143 }
14144
14145 private static class closeScanner_argsTupleScheme extends TupleScheme<closeScanner_args> {
14146
14147 @Override
14148 public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
14149 TTupleProtocol oprot = (TTupleProtocol) prot;
14150 oprot.writeI32(struct.scannerId);
14151 }
14152
14153 @Override
14154 public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
14155 TTupleProtocol iprot = (TTupleProtocol) prot;
14156 struct.scannerId = iprot.readI32();
14157 struct.setScannerIdIsSet(true);
14158 }
14159 }
14160
14161 }
14162
14163 public static class closeScanner_result implements org.apache.thrift.TBase<closeScanner_result, closeScanner_result._Fields>, java.io.Serializable, Cloneable {
14164 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_result");
14165
14166 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);
14167 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);
14168
14169 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
14170 static {
14171 schemes.put(StandardScheme.class, new closeScanner_resultStandardSchemeFactory());
14172 schemes.put(TupleScheme.class, new closeScanner_resultTupleSchemeFactory());
14173 }
14174
14175 public TIOError io;
14176
14177
14178
14179 public TIllegalArgument ia;
14180
14181
14182 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
14183 IO((short)1, "io"),
14184
14185
14186
14187 IA((short)2, "ia");
14188
14189 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14190
14191 static {
14192 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14193 byName.put(field.getFieldName(), field);
14194 }
14195 }
14196
14197
14198
14199
14200 public static _Fields findByThriftId(int fieldId) {
14201 switch(fieldId) {
14202 case 1:
14203 return IO;
14204 case 2:
14205 return IA;
14206 default:
14207 return null;
14208 }
14209 }
14210
14211
14212
14213
14214
14215 public static _Fields findByThriftIdOrThrow(int fieldId) {
14216 _Fields fields = findByThriftId(fieldId);
14217 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14218 return fields;
14219 }
14220
14221
14222
14223
14224 public static _Fields findByName(String name) {
14225 return byName.get(name);
14226 }
14227
14228 private final short _thriftId;
14229 private final String _fieldName;
14230
14231 _Fields(short thriftId, String fieldName) {
14232 _thriftId = thriftId;
14233 _fieldName = fieldName;
14234 }
14235
14236 public short getThriftFieldId() {
14237 return _thriftId;
14238 }
14239
14240 public String getFieldName() {
14241 return _fieldName;
14242 }
14243 }
14244
14245
14246 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
14247 static {
14248 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
14249 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
14250 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
14251 tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
14252 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
14253 metaDataMap = Collections.unmodifiableMap(tmpMap);
14254 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_result.class, metaDataMap);
14255 }
14256
14257 public closeScanner_result() {
14258 }
14259
14260 public closeScanner_result(
14261 TIOError io,
14262 TIllegalArgument ia)
14263 {
14264 this();
14265 this.io = io;
14266 this.ia = ia;
14267 }
14268
14269
14270
14271
14272 public closeScanner_result(closeScanner_result other) {
14273 if (other.isSetIo()) {
14274 this.io = new TIOError(other.io);
14275 }
14276 if (other.isSetIa()) {
14277 this.ia = new TIllegalArgument(other.ia);
14278 }
14279 }
14280
14281 public closeScanner_result deepCopy() {
14282 return new closeScanner_result(this);
14283 }
14284
14285 @Override
14286 public void clear() {
14287 this.io = null;
14288 this.ia = null;
14289 }
14290
14291 public TIOError getIo() {
14292 return this.io;
14293 }
14294
14295 public closeScanner_result setIo(TIOError io) {
14296 this.io = io;
14297 return this;
14298 }
14299
14300 public void unsetIo() {
14301 this.io = null;
14302 }
14303
14304
14305 public boolean isSetIo() {
14306 return this.io != null;
14307 }
14308
14309 public void setIoIsSet(boolean value) {
14310 if (!value) {
14311 this.io = null;
14312 }
14313 }
14314
14315
14316
14317
14318 public TIllegalArgument getIa() {
14319 return this.ia;
14320 }
14321
14322
14323
14324
14325 public closeScanner_result setIa(TIllegalArgument ia) {
14326 this.ia = ia;
14327 return this;
14328 }
14329
14330 public void unsetIa() {
14331 this.ia = null;
14332 }
14333
14334
14335 public boolean isSetIa() {
14336 return this.ia != null;
14337 }
14338
14339 public void setIaIsSet(boolean value) {
14340 if (!value) {
14341 this.ia = null;
14342 }
14343 }
14344
14345 public void setFieldValue(_Fields field, Object value) {
14346 switch (field) {
14347 case IO:
14348 if (value == null) {
14349 unsetIo();
14350 } else {
14351 setIo((TIOError)value);
14352 }
14353 break;
14354
14355 case IA:
14356 if (value == null) {
14357 unsetIa();
14358 } else {
14359 setIa((TIllegalArgument)value);
14360 }
14361 break;
14362
14363 }
14364 }
14365
14366 public Object getFieldValue(_Fields field) {
14367 switch (field) {
14368 case IO:
14369 return getIo();
14370
14371 case IA:
14372 return getIa();
14373
14374 }
14375 throw new IllegalStateException();
14376 }
14377
14378
14379 public boolean isSet(_Fields field) {
14380 if (field == null) {
14381 throw new IllegalArgumentException();
14382 }
14383
14384 switch (field) {
14385 case IO:
14386 return isSetIo();
14387 case IA:
14388 return isSetIa();
14389 }
14390 throw new IllegalStateException();
14391 }
14392
14393 @Override
14394 public boolean equals(Object that) {
14395 if (that == null)
14396 return false;
14397 if (that instanceof closeScanner_result)
14398 return this.equals((closeScanner_result)that);
14399 return false;
14400 }
14401
14402 public boolean equals(closeScanner_result that) {
14403 if (that == null)
14404 return false;
14405
14406 boolean this_present_io = true && this.isSetIo();
14407 boolean that_present_io = true && that.isSetIo();
14408 if (this_present_io || that_present_io) {
14409 if (!(this_present_io && that_present_io))
14410 return false;
14411 if (!this.io.equals(that.io))
14412 return false;
14413 }
14414
14415 boolean this_present_ia = true && this.isSetIa();
14416 boolean that_present_ia = true && that.isSetIa();
14417 if (this_present_ia || that_present_ia) {
14418 if (!(this_present_ia && that_present_ia))
14419 return false;
14420 if (!this.ia.equals(that.ia))
14421 return false;
14422 }
14423
14424 return true;
14425 }
14426
14427 @Override
14428 public int hashCode() {
14429 return 0;
14430 }
14431
14432 public int compareTo(closeScanner_result other) {
14433 if (!getClass().equals(other.getClass())) {
14434 return getClass().getName().compareTo(other.getClass().getName());
14435 }
14436
14437 int lastComparison = 0;
14438 closeScanner_result typedOther = (closeScanner_result)other;
14439
14440 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
14441 if (lastComparison != 0) {
14442 return lastComparison;
14443 }
14444 if (isSetIo()) {
14445 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
14446 if (lastComparison != 0) {
14447 return lastComparison;
14448 }
14449 }
14450 lastComparison = Boolean.valueOf(isSetIa()).compareTo(typedOther.isSetIa());
14451 if (lastComparison != 0) {
14452 return lastComparison;
14453 }
14454 if (isSetIa()) {
14455 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia);
14456 if (lastComparison != 0) {
14457 return lastComparison;
14458 }
14459 }
14460 return 0;
14461 }
14462
14463 public _Fields fieldForId(int fieldId) {
14464 return _Fields.findByThriftId(fieldId);
14465 }
14466
14467 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
14468 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
14469 }
14470
14471 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
14472 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
14473 }
14474
14475 @Override
14476 public String toString() {
14477 StringBuilder sb = new StringBuilder("closeScanner_result(");
14478 boolean first = true;
14479
14480 sb.append("io:");
14481 if (this.io == null) {
14482 sb.append("null");
14483 } else {
14484 sb.append(this.io);
14485 }
14486 first = false;
14487 if (!first) sb.append(", ");
14488 sb.append("ia:");
14489 if (this.ia == null) {
14490 sb.append("null");
14491 } else {
14492 sb.append(this.ia);
14493 }
14494 first = false;
14495 sb.append(")");
14496 return sb.toString();
14497 }
14498
14499 public void validate() throws org.apache.thrift.TException {
14500
14501 }
14502
14503 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
14504 try {
14505 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
14506 } catch (org.apache.thrift.TException te) {
14507 throw new java.io.IOException(te);
14508 }
14509 }
14510
14511 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
14512 try {
14513 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
14514 } catch (org.apache.thrift.TException te) {
14515 throw new java.io.IOException(te);
14516 }
14517 }
14518
14519 private static class closeScanner_resultStandardSchemeFactory implements SchemeFactory {
14520 public closeScanner_resultStandardScheme getScheme() {
14521 return new closeScanner_resultStandardScheme();
14522 }
14523 }
14524
14525 private static class closeScanner_resultStandardScheme extends StandardScheme<closeScanner_result> {
14526
14527 public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_result struct) throws org.apache.thrift.TException {
14528 org.apache.thrift.protocol.TField schemeField;
14529 iprot.readStructBegin();
14530 while (true)
14531 {
14532 schemeField = iprot.readFieldBegin();
14533 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
14534 break;
14535 }
14536 switch (schemeField.id) {
14537 case 1:
14538 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14539 struct.io = new TIOError();
14540 struct.io.read(iprot);
14541 struct.setIoIsSet(true);
14542 } else {
14543 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14544 }
14545 break;
14546 case 2:
14547 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14548 struct.ia = new TIllegalArgument();
14549 struct.ia.read(iprot);
14550 struct.setIaIsSet(true);
14551 } else {
14552 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14553 }
14554 break;
14555 default:
14556 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14557 }
14558 iprot.readFieldEnd();
14559 }
14560 iprot.readStructEnd();
14561
14562
14563 struct.validate();
14564 }
14565
14566 public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_result struct) throws org.apache.thrift.TException {
14567 struct.validate();
14568
14569 oprot.writeStructBegin(STRUCT_DESC);
14570 if (struct.io != null) {
14571 oprot.writeFieldBegin(IO_FIELD_DESC);
14572 struct.io.write(oprot);
14573 oprot.writeFieldEnd();
14574 }
14575 if (struct.ia != null) {
14576 oprot.writeFieldBegin(IA_FIELD_DESC);
14577 struct.ia.write(oprot);
14578 oprot.writeFieldEnd();
14579 }
14580 oprot.writeFieldStop();
14581 oprot.writeStructEnd();
14582 }
14583
14584 }
14585
14586 private static class closeScanner_resultTupleSchemeFactory implements SchemeFactory {
14587 public closeScanner_resultTupleScheme getScheme() {
14588 return new closeScanner_resultTupleScheme();
14589 }
14590 }
14591
14592 private static class closeScanner_resultTupleScheme extends TupleScheme<closeScanner_result> {
14593
14594 @Override
14595 public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
14596 TTupleProtocol oprot = (TTupleProtocol) prot;
14597 BitSet optionals = new BitSet();
14598 if (struct.isSetIo()) {
14599 optionals.set(0);
14600 }
14601 if (struct.isSetIa()) {
14602 optionals.set(1);
14603 }
14604 oprot.writeBitSet(optionals, 2);
14605 if (struct.isSetIo()) {
14606 struct.io.write(oprot);
14607 }
14608 if (struct.isSetIa()) {
14609 struct.ia.write(oprot);
14610 }
14611 }
14612
14613 @Override
14614 public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
14615 TTupleProtocol iprot = (TTupleProtocol) prot;
14616 BitSet incoming = iprot.readBitSet(2);
14617 if (incoming.get(0)) {
14618 struct.io = new TIOError();
14619 struct.io.read(iprot);
14620 struct.setIoIsSet(true);
14621 }
14622 if (incoming.get(1)) {
14623 struct.ia = new TIllegalArgument();
14624 struct.ia.read(iprot);
14625 struct.setIaIsSet(true);
14626 }
14627 }
14628 }
14629
14630 }
14631
14632 public static class mutateRow_args implements org.apache.thrift.TBase<mutateRow_args, mutateRow_args._Fields>, java.io.Serializable, Cloneable {
14633 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRow_args");
14634
14635 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);
14636 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);
14637
14638 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
14639 static {
14640 schemes.put(StandardScheme.class, new mutateRow_argsStandardSchemeFactory());
14641 schemes.put(TupleScheme.class, new mutateRow_argsTupleSchemeFactory());
14642 }
14643
14644
14645
14646
14647 public ByteBuffer table;
14648
14649
14650
14651 public TRowMutations rowMutations;
14652
14653
14654 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
14655
14656
14657
14658 TABLE((short)1, "table"),
14659
14660
14661
14662 ROW_MUTATIONS((short)2, "rowMutations");
14663
14664 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14665
14666 static {
14667 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14668 byName.put(field.getFieldName(), field);
14669 }
14670 }
14671
14672
14673
14674
14675 public static _Fields findByThriftId(int fieldId) {
14676 switch(fieldId) {
14677 case 1:
14678 return TABLE;
14679 case 2:
14680 return ROW_MUTATIONS;
14681 default:
14682 return null;
14683 }
14684 }
14685
14686
14687
14688
14689
14690 public static _Fields findByThriftIdOrThrow(int fieldId) {
14691 _Fields fields = findByThriftId(fieldId);
14692 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14693 return fields;
14694 }
14695
14696
14697
14698
14699 public static _Fields findByName(String name) {
14700 return byName.get(name);
14701 }
14702
14703 private final short _thriftId;
14704 private final String _fieldName;
14705
14706 _Fields(short thriftId, String fieldName) {
14707 _thriftId = thriftId;
14708 _fieldName = fieldName;
14709 }
14710
14711 public short getThriftFieldId() {
14712 return _thriftId;
14713 }
14714
14715 public String getFieldName() {
14716 return _fieldName;
14717 }
14718 }
14719
14720
14721 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
14722 static {
14723 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
14724 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
14725 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
14726 tmpMap.put(_Fields.ROW_MUTATIONS, new org.apache.thrift.meta_data.FieldMetaData("rowMutations", org.apache.thrift.TFieldRequirementType.REQUIRED,
14727 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowMutations.class)));
14728 metaDataMap = Collections.unmodifiableMap(tmpMap);
14729 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
14730 }
14731
14732 public mutateRow_args() {
14733 }
14734
14735 public mutateRow_args(
14736 ByteBuffer table,
14737 TRowMutations rowMutations)
14738 {
14739 this();
14740 this.table = table;
14741 this.rowMutations = rowMutations;
14742 }
14743
14744
14745
14746
14747 public mutateRow_args(mutateRow_args other) {
14748 if (other.isSetTable()) {
14749 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
14750 ;
14751 }
14752 if (other.isSetRowMutations()) {
14753 this.rowMutations = new TRowMutations(other.rowMutations);
14754 }
14755 }
14756
14757 public mutateRow_args deepCopy() {
14758 return new mutateRow_args(this);
14759 }
14760
14761 @Override
14762 public void clear() {
14763 this.table = null;
14764 this.rowMutations = null;
14765 }
14766
14767
14768
14769
14770 public byte[] getTable() {
14771 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
14772 return table == null ? null : table.array();
14773 }
14774
14775 public ByteBuffer bufferForTable() {
14776 return table;
14777 }
14778
14779
14780
14781
14782 public mutateRow_args setTable(byte[] table) {
14783 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
14784 return this;
14785 }
14786
14787 public mutateRow_args setTable(ByteBuffer table) {
14788 this.table = table;
14789 return this;
14790 }
14791
14792 public void unsetTable() {
14793 this.table = null;
14794 }
14795
14796
14797 public boolean isSetTable() {
14798 return this.table != null;
14799 }
14800
14801 public void setTableIsSet(boolean value) {
14802 if (!value) {
14803 this.table = null;
14804 }
14805 }
14806
14807
14808
14809
14810 public TRowMutations getRowMutations() {
14811 return this.rowMutations;
14812 }
14813
14814
14815
14816
14817 public mutateRow_args setRowMutations(TRowMutations rowMutations) {
14818 this.rowMutations = rowMutations;
14819 return this;
14820 }
14821
14822 public void unsetRowMutations() {
14823 this.rowMutations = null;
14824 }
14825
14826
14827 public boolean isSetRowMutations() {
14828 return this.rowMutations != null;
14829 }
14830
14831 public void setRowMutationsIsSet(boolean value) {
14832 if (!value) {
14833 this.rowMutations = null;
14834 }
14835 }
14836
14837 public void setFieldValue(_Fields field, Object value) {
14838 switch (field) {
14839 case TABLE:
14840 if (value == null) {
14841 unsetTable();
14842 } else {
14843 setTable((ByteBuffer)value);
14844 }
14845 break;
14846
14847 case ROW_MUTATIONS:
14848 if (value == null) {
14849 unsetRowMutations();
14850 } else {
14851 setRowMutations((TRowMutations)value);
14852 }
14853 break;
14854
14855 }
14856 }
14857
14858 public Object getFieldValue(_Fields field) {
14859 switch (field) {
14860 case TABLE:
14861 return getTable();
14862
14863 case ROW_MUTATIONS:
14864 return getRowMutations();
14865
14866 }
14867 throw new IllegalStateException();
14868 }
14869
14870
14871 public boolean isSet(_Fields field) {
14872 if (field == null) {
14873 throw new IllegalArgumentException();
14874 }
14875
14876 switch (field) {
14877 case TABLE:
14878 return isSetTable();
14879 case ROW_MUTATIONS:
14880 return isSetRowMutations();
14881 }
14882 throw new IllegalStateException();
14883 }
14884
14885 @Override
14886 public boolean equals(Object that) {
14887 if (that == null)
14888 return false;
14889 if (that instanceof mutateRow_args)
14890 return this.equals((mutateRow_args)that);
14891 return false;
14892 }
14893
14894 public boolean equals(mutateRow_args that) {
14895 if (that == null)
14896 return false;
14897
14898 boolean this_present_table = true && this.isSetTable();
14899 boolean that_present_table = true && that.isSetTable();
14900 if (this_present_table || that_present_table) {
14901 if (!(this_present_table && that_present_table))
14902 return false;
14903 if (!this.table.equals(that.table))
14904 return false;
14905 }
14906
14907 boolean this_present_rowMutations = true && this.isSetRowMutations();
14908 boolean that_present_rowMutations = true && that.isSetRowMutations();
14909 if (this_present_rowMutations || that_present_rowMutations) {
14910 if (!(this_present_rowMutations && that_present_rowMutations))
14911 return false;
14912 if (!this.rowMutations.equals(that.rowMutations))
14913 return false;
14914 }
14915
14916 return true;
14917 }
14918
14919 @Override
14920 public int hashCode() {
14921 return 0;
14922 }
14923
14924 public int compareTo(mutateRow_args other) {
14925 if (!getClass().equals(other.getClass())) {
14926 return getClass().getName().compareTo(other.getClass().getName());
14927 }
14928
14929 int lastComparison = 0;
14930 mutateRow_args typedOther = (mutateRow_args)other;
14931
14932 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
14933 if (lastComparison != 0) {
14934 return lastComparison;
14935 }
14936 if (isSetTable()) {
14937 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
14938 if (lastComparison != 0) {
14939 return lastComparison;
14940 }
14941 }
14942 lastComparison = Boolean.valueOf(isSetRowMutations()).compareTo(typedOther.isSetRowMutations());
14943 if (lastComparison != 0) {
14944 return lastComparison;
14945 }
14946 if (isSetRowMutations()) {
14947 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rowMutations, typedOther.rowMutations);
14948 if (lastComparison != 0) {
14949 return lastComparison;
14950 }
14951 }
14952 return 0;
14953 }
14954
14955 public _Fields fieldForId(int fieldId) {
14956 return _Fields.findByThriftId(fieldId);
14957 }
14958
14959 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
14960 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
14961 }
14962
14963 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
14964 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
14965 }
14966
14967 @Override
14968 public String toString() {
14969 StringBuilder sb = new StringBuilder("mutateRow_args(");
14970 boolean first = true;
14971
14972 sb.append("table:");
14973 if (this.table == null) {
14974 sb.append("null");
14975 } else {
14976 org.apache.thrift.TBaseHelper.toString(this.table, sb);
14977 }
14978 first = false;
14979 if (!first) sb.append(", ");
14980 sb.append("rowMutations:");
14981 if (this.rowMutations == null) {
14982 sb.append("null");
14983 } else {
14984 sb.append(this.rowMutations);
14985 }
14986 first = false;
14987 sb.append(")");
14988 return sb.toString();
14989 }
14990
14991 public void validate() throws org.apache.thrift.TException {
14992
14993 if (table == null) {
14994 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
14995 }
14996 if (rowMutations == null) {
14997 throw new org.apache.thrift.protocol.TProtocolException("Required field 'rowMutations' was not present! Struct: " + toString());
14998 }
14999 }
15000
15001 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
15002 try {
15003 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
15004 } catch (org.apache.thrift.TException te) {
15005 throw new java.io.IOException(te);
15006 }
15007 }
15008
15009 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
15010 try {
15011 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
15012 } catch (org.apache.thrift.TException te) {
15013 throw new java.io.IOException(te);
15014 }
15015 }
15016
15017 private static class mutateRow_argsStandardSchemeFactory implements SchemeFactory {
15018 public mutateRow_argsStandardScheme getScheme() {
15019 return new mutateRow_argsStandardScheme();
15020 }
15021 }
15022
15023 private static class mutateRow_argsStandardScheme extends StandardScheme<mutateRow_args> {
15024
15025 public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_args struct) throws org.apache.thrift.TException {
15026 org.apache.thrift.protocol.TField schemeField;
15027 iprot.readStructBegin();
15028 while (true)
15029 {
15030 schemeField = iprot.readFieldBegin();
15031 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
15032 break;
15033 }
15034 switch (schemeField.id) {
15035 case 1:
15036 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
15037 struct.table = iprot.readBinary();
15038 struct.setTableIsSet(true);
15039 } else {
15040 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15041 }
15042 break;
15043 case 2:
15044 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
15045 struct.rowMutations = new TRowMutations();
15046 struct.rowMutations.read(iprot);
15047 struct.setRowMutationsIsSet(true);
15048 } else {
15049 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15050 }
15051 break;
15052 default:
15053 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15054 }
15055 iprot.readFieldEnd();
15056 }
15057 iprot.readStructEnd();
15058
15059
15060 struct.validate();
15061 }
15062
15063 public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_args struct) throws org.apache.thrift.TException {
15064 struct.validate();
15065
15066 oprot.writeStructBegin(STRUCT_DESC);
15067 if (struct.table != null) {
15068 oprot.writeFieldBegin(TABLE_FIELD_DESC);
15069 oprot.writeBinary(struct.table);
15070 oprot.writeFieldEnd();
15071 }
15072 if (struct.rowMutations != null) {
15073 oprot.writeFieldBegin(ROW_MUTATIONS_FIELD_DESC);
15074 struct.rowMutations.write(oprot);
15075 oprot.writeFieldEnd();
15076 }
15077 oprot.writeFieldStop();
15078 oprot.writeStructEnd();
15079 }
15080
15081 }
15082
15083 private static class mutateRow_argsTupleSchemeFactory implements SchemeFactory {
15084 public mutateRow_argsTupleScheme getScheme() {
15085 return new mutateRow_argsTupleScheme();
15086 }
15087 }
15088
15089 private static class mutateRow_argsTupleScheme extends TupleScheme<mutateRow_args> {
15090
15091 @Override
15092 public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
15093 TTupleProtocol oprot = (TTupleProtocol) prot;
15094 oprot.writeBinary(struct.table);
15095 struct.rowMutations.write(oprot);
15096 }
15097
15098 @Override
15099 public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_args struct) throws org.apache.thrift.TException {
15100 TTupleProtocol iprot = (TTupleProtocol) prot;
15101 struct.table = iprot.readBinary();
15102 struct.setTableIsSet(true);
15103 struct.rowMutations = new TRowMutations();
15104 struct.rowMutations.read(iprot);
15105 struct.setRowMutationsIsSet(true);
15106 }
15107 }
15108
15109 }
15110
15111 public static class mutateRow_result implements org.apache.thrift.TBase<mutateRow_result, mutateRow_result._Fields>, java.io.Serializable, Cloneable {
15112 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("mutateRow_result");
15113
15114 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);
15115
15116 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
15117 static {
15118 schemes.put(StandardScheme.class, new mutateRow_resultStandardSchemeFactory());
15119 schemes.put(TupleScheme.class, new mutateRow_resultTupleSchemeFactory());
15120 }
15121
15122 public TIOError io;
15123
15124
15125 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
15126 IO((short)1, "io");
15127
15128 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15129
15130 static {
15131 for (_Fields field : EnumSet.allOf(_Fields.class)) {
15132 byName.put(field.getFieldName(), field);
15133 }
15134 }
15135
15136
15137
15138
15139 public static _Fields findByThriftId(int fieldId) {
15140 switch(fieldId) {
15141 case 1:
15142 return IO;
15143 default:
15144 return null;
15145 }
15146 }
15147
15148
15149
15150
15151
15152 public static _Fields findByThriftIdOrThrow(int fieldId) {
15153 _Fields fields = findByThriftId(fieldId);
15154 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15155 return fields;
15156 }
15157
15158
15159
15160
15161 public static _Fields findByName(String name) {
15162 return byName.get(name);
15163 }
15164
15165 private final short _thriftId;
15166 private final String _fieldName;
15167
15168 _Fields(short thriftId, String fieldName) {
15169 _thriftId = thriftId;
15170 _fieldName = fieldName;
15171 }
15172
15173 public short getThriftFieldId() {
15174 return _thriftId;
15175 }
15176
15177 public String getFieldName() {
15178 return _fieldName;
15179 }
15180 }
15181
15182
15183 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
15184 static {
15185 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
15186 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
15187 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
15188 metaDataMap = Collections.unmodifiableMap(tmpMap);
15189 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap);
15190 }
15191
15192 public mutateRow_result() {
15193 }
15194
15195 public mutateRow_result(
15196 TIOError io)
15197 {
15198 this();
15199 this.io = io;
15200 }
15201
15202
15203
15204
15205 public mutateRow_result(mutateRow_result other) {
15206 if (other.isSetIo()) {
15207 this.io = new TIOError(other.io);
15208 }
15209 }
15210
15211 public mutateRow_result deepCopy() {
15212 return new mutateRow_result(this);
15213 }
15214
15215 @Override
15216 public void clear() {
15217 this.io = null;
15218 }
15219
15220 public TIOError getIo() {
15221 return this.io;
15222 }
15223
15224 public mutateRow_result setIo(TIOError io) {
15225 this.io = io;
15226 return this;
15227 }
15228
15229 public void unsetIo() {
15230 this.io = null;
15231 }
15232
15233
15234 public boolean isSetIo() {
15235 return this.io != null;
15236 }
15237
15238 public void setIoIsSet(boolean value) {
15239 if (!value) {
15240 this.io = null;
15241 }
15242 }
15243
15244 public void setFieldValue(_Fields field, Object value) {
15245 switch (field) {
15246 case IO:
15247 if (value == null) {
15248 unsetIo();
15249 } else {
15250 setIo((TIOError)value);
15251 }
15252 break;
15253
15254 }
15255 }
15256
15257 public Object getFieldValue(_Fields field) {
15258 switch (field) {
15259 case IO:
15260 return getIo();
15261
15262 }
15263 throw new IllegalStateException();
15264 }
15265
15266
15267 public boolean isSet(_Fields field) {
15268 if (field == null) {
15269 throw new IllegalArgumentException();
15270 }
15271
15272 switch (field) {
15273 case IO:
15274 return isSetIo();
15275 }
15276 throw new IllegalStateException();
15277 }
15278
15279 @Override
15280 public boolean equals(Object that) {
15281 if (that == null)
15282 return false;
15283 if (that instanceof mutateRow_result)
15284 return this.equals((mutateRow_result)that);
15285 return false;
15286 }
15287
15288 public boolean equals(mutateRow_result that) {
15289 if (that == null)
15290 return false;
15291
15292 boolean this_present_io = true && this.isSetIo();
15293 boolean that_present_io = true && that.isSetIo();
15294 if (this_present_io || that_present_io) {
15295 if (!(this_present_io && that_present_io))
15296 return false;
15297 if (!this.io.equals(that.io))
15298 return false;
15299 }
15300
15301 return true;
15302 }
15303
15304 @Override
15305 public int hashCode() {
15306 return 0;
15307 }
15308
15309 public int compareTo(mutateRow_result other) {
15310 if (!getClass().equals(other.getClass())) {
15311 return getClass().getName().compareTo(other.getClass().getName());
15312 }
15313
15314 int lastComparison = 0;
15315 mutateRow_result typedOther = (mutateRow_result)other;
15316
15317 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
15318 if (lastComparison != 0) {
15319 return lastComparison;
15320 }
15321 if (isSetIo()) {
15322 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
15323 if (lastComparison != 0) {
15324 return lastComparison;
15325 }
15326 }
15327 return 0;
15328 }
15329
15330 public _Fields fieldForId(int fieldId) {
15331 return _Fields.findByThriftId(fieldId);
15332 }
15333
15334 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
15335 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
15336 }
15337
15338 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
15339 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
15340 }
15341
15342 @Override
15343 public String toString() {
15344 StringBuilder sb = new StringBuilder("mutateRow_result(");
15345 boolean first = true;
15346
15347 sb.append("io:");
15348 if (this.io == null) {
15349 sb.append("null");
15350 } else {
15351 sb.append(this.io);
15352 }
15353 first = false;
15354 sb.append(")");
15355 return sb.toString();
15356 }
15357
15358 public void validate() throws org.apache.thrift.TException {
15359
15360 }
15361
15362 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
15363 try {
15364 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
15365 } catch (org.apache.thrift.TException te) {
15366 throw new java.io.IOException(te);
15367 }
15368 }
15369
15370 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
15371 try {
15372 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
15373 } catch (org.apache.thrift.TException te) {
15374 throw new java.io.IOException(te);
15375 }
15376 }
15377
15378 private static class mutateRow_resultStandardSchemeFactory implements SchemeFactory {
15379 public mutateRow_resultStandardScheme getScheme() {
15380 return new mutateRow_resultStandardScheme();
15381 }
15382 }
15383
15384 private static class mutateRow_resultStandardScheme extends StandardScheme<mutateRow_result> {
15385
15386 public void read(org.apache.thrift.protocol.TProtocol iprot, mutateRow_result struct) throws org.apache.thrift.TException {
15387 org.apache.thrift.protocol.TField schemeField;
15388 iprot.readStructBegin();
15389 while (true)
15390 {
15391 schemeField = iprot.readFieldBegin();
15392 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
15393 break;
15394 }
15395 switch (schemeField.id) {
15396 case 1:
15397 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
15398 struct.io = new TIOError();
15399 struct.io.read(iprot);
15400 struct.setIoIsSet(true);
15401 } else {
15402 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15403 }
15404 break;
15405 default:
15406 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
15407 }
15408 iprot.readFieldEnd();
15409 }
15410 iprot.readStructEnd();
15411
15412
15413 struct.validate();
15414 }
15415
15416 public void write(org.apache.thrift.protocol.TProtocol oprot, mutateRow_result struct) throws org.apache.thrift.TException {
15417 struct.validate();
15418
15419 oprot.writeStructBegin(STRUCT_DESC);
15420 if (struct.io != null) {
15421 oprot.writeFieldBegin(IO_FIELD_DESC);
15422 struct.io.write(oprot);
15423 oprot.writeFieldEnd();
15424 }
15425 oprot.writeFieldStop();
15426 oprot.writeStructEnd();
15427 }
15428
15429 }
15430
15431 private static class mutateRow_resultTupleSchemeFactory implements SchemeFactory {
15432 public mutateRow_resultTupleScheme getScheme() {
15433 return new mutateRow_resultTupleScheme();
15434 }
15435 }
15436
15437 private static class mutateRow_resultTupleScheme extends TupleScheme<mutateRow_result> {
15438
15439 @Override
15440 public void write(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
15441 TTupleProtocol oprot = (TTupleProtocol) prot;
15442 BitSet optionals = new BitSet();
15443 if (struct.isSetIo()) {
15444 optionals.set(0);
15445 }
15446 oprot.writeBitSet(optionals, 1);
15447 if (struct.isSetIo()) {
15448 struct.io.write(oprot);
15449 }
15450 }
15451
15452 @Override
15453 public void read(org.apache.thrift.protocol.TProtocol prot, mutateRow_result struct) throws org.apache.thrift.TException {
15454 TTupleProtocol iprot = (TTupleProtocol) prot;
15455 BitSet incoming = iprot.readBitSet(1);
15456 if (incoming.get(0)) {
15457 struct.io = new TIOError();
15458 struct.io.read(iprot);
15459 struct.setIoIsSet(true);
15460 }
15461 }
15462 }
15463
15464 }
15465
15466 }