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 org.apache.thrift.protocol.TProtocolException;
16 import org.apache.thrift.EncodingUtils;
17 import org.apache.thrift.TException;
18 import java.util.List;
19 import java.util.ArrayList;
20 import java.util.Map;
21 import java.util.HashMap;
22 import java.util.EnumMap;
23 import java.util.Set;
24 import java.util.HashSet;
25 import java.util.EnumSet;
26 import java.util.Collections;
27 import java.util.BitSet;
28 import java.nio.ByteBuffer;
29 import java.util.Arrays;
30 import org.slf4j.Logger;
31 import org.slf4j.LoggerFactory;
32
33 public class THBaseService {
34
35 public interface Iface {
36
37
38
39
40
41
42
43
44
45
46 public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
47
48
49
50
51
52
53
54
55
56
57
58
59
60 public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77 public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException;
78
79
80
81
82
83
84
85
86 public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException;
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108 public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException;
109
110
111
112
113
114
115
116
117 public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException;
118
119
120
121
122
123
124
125
126
127
128
129 public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
130
131
132
133
134
135
136
137
138
139
140
141
142 public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException;
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164 public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
165
166 public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException;
167
168
169
170
171
172
173
174
175
176
177 public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException;
178
179
180
181
182
183
184
185
186
187
188 public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
189
190
191
192
193
194
195
196
197
198 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
199
200 }
201
202 public interface AsyncIface {
203
204 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.exists_call> resultHandler) throws org.apache.thrift.TException;
205
206 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.get_call> resultHandler) throws org.apache.thrift.TException;
207
208 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getMultiple_call> resultHandler) throws org.apache.thrift.TException;
209
210 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.put_call> resultHandler) throws org.apache.thrift.TException;
211
212 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;
213
214 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.putMultiple_call> resultHandler) throws org.apache.thrift.TException;
215
216 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteSingle_call> resultHandler) throws org.apache.thrift.TException;
217
218 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteMultiple_call> resultHandler) throws org.apache.thrift.TException;
219
220 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;
221
222 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.increment_call> resultHandler) throws org.apache.thrift.TException;
223
224 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.openScanner_call> resultHandler) throws org.apache.thrift.TException;
225
226 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getScannerRows_call> resultHandler) throws org.apache.thrift.TException;
227
228 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeScanner_call> resultHandler) throws org.apache.thrift.TException;
229
230 }
231
232 public static class Client extends org.apache.thrift.TServiceClient implements Iface {
233 public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
234 public Factory() {}
235 public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
236 return new Client(prot);
237 }
238 public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
239 return new Client(iprot, oprot);
240 }
241 }
242
243 public Client(org.apache.thrift.protocol.TProtocol prot)
244 {
245 super(prot, prot);
246 }
247
248 public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
249 super(iprot, oprot);
250 }
251
252 public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
253 {
254 send_exists(table, get);
255 return recv_exists();
256 }
257
258 public void send_exists(ByteBuffer table, TGet get) throws org.apache.thrift.TException
259 {
260 exists_args args = new exists_args();
261 args.setTable(table);
262 args.setGet(get);
263 sendBase("exists", args);
264 }
265
266 public boolean recv_exists() throws TIOError, org.apache.thrift.TException
267 {
268 exists_result result = new exists_result();
269 receiveBase(result, "exists");
270 if (result.isSetSuccess()) {
271 return result.success;
272 }
273 if (result.io != null) {
274 throw result.io;
275 }
276 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "exists failed: unknown result");
277 }
278
279 public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
280 {
281 send_get(table, get);
282 return recv_get();
283 }
284
285 public void send_get(ByteBuffer table, TGet get) throws org.apache.thrift.TException
286 {
287 get_args args = new get_args();
288 args.setTable(table);
289 args.setGet(get);
290 sendBase("get", args);
291 }
292
293 public TResult recv_get() throws TIOError, org.apache.thrift.TException
294 {
295 get_result result = new get_result();
296 receiveBase(result, "get");
297 if (result.isSetSuccess()) {
298 return result.success;
299 }
300 if (result.io != null) {
301 throw result.io;
302 }
303 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get failed: unknown result");
304 }
305
306 public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException
307 {
308 send_getMultiple(table, gets);
309 return recv_getMultiple();
310 }
311
312 public void send_getMultiple(ByteBuffer table, List<TGet> gets) throws org.apache.thrift.TException
313 {
314 getMultiple_args args = new getMultiple_args();
315 args.setTable(table);
316 args.setGets(gets);
317 sendBase("getMultiple", args);
318 }
319
320 public List<TResult> recv_getMultiple() throws TIOError, org.apache.thrift.TException
321 {
322 getMultiple_result result = new getMultiple_result();
323 receiveBase(result, "getMultiple");
324 if (result.isSetSuccess()) {
325 return result.success;
326 }
327 if (result.io != null) {
328 throw result.io;
329 }
330 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getMultiple failed: unknown result");
331 }
332
333 public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException
334 {
335 send_put(table, put);
336 recv_put();
337 }
338
339 public void send_put(ByteBuffer table, TPut put) throws org.apache.thrift.TException
340 {
341 put_args args = new put_args();
342 args.setTable(table);
343 args.setPut(put);
344 sendBase("put", args);
345 }
346
347 public void recv_put() throws TIOError, org.apache.thrift.TException
348 {
349 put_result result = new put_result();
350 receiveBase(result, "put");
351 if (result.io != null) {
352 throw result.io;
353 }
354 return;
355 }
356
357 public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException
358 {
359 send_checkAndPut(table, row, family, qualifier, value, put);
360 return recv_checkAndPut();
361 }
362
363 public void send_checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws org.apache.thrift.TException
364 {
365 checkAndPut_args args = new checkAndPut_args();
366 args.setTable(table);
367 args.setRow(row);
368 args.setFamily(family);
369 args.setQualifier(qualifier);
370 args.setValue(value);
371 args.setPut(put);
372 sendBase("checkAndPut", args);
373 }
374
375 public boolean recv_checkAndPut() throws TIOError, org.apache.thrift.TException
376 {
377 checkAndPut_result result = new checkAndPut_result();
378 receiveBase(result, "checkAndPut");
379 if (result.isSetSuccess()) {
380 return result.success;
381 }
382 if (result.io != null) {
383 throw result.io;
384 }
385 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndPut failed: unknown result");
386 }
387
388 public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException
389 {
390 send_putMultiple(table, puts);
391 recv_putMultiple();
392 }
393
394 public void send_putMultiple(ByteBuffer table, List<TPut> puts) throws org.apache.thrift.TException
395 {
396 putMultiple_args args = new putMultiple_args();
397 args.setTable(table);
398 args.setPuts(puts);
399 sendBase("putMultiple", args);
400 }
401
402 public void recv_putMultiple() throws TIOError, org.apache.thrift.TException
403 {
404 putMultiple_result result = new putMultiple_result();
405 receiveBase(result, "putMultiple");
406 if (result.io != null) {
407 throw result.io;
408 }
409 return;
410 }
411
412 public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
413 {
414 send_deleteSingle(table, deleteSingle);
415 recv_deleteSingle();
416 }
417
418 public void send_deleteSingle(ByteBuffer table, TDelete deleteSingle) throws org.apache.thrift.TException
419 {
420 deleteSingle_args args = new deleteSingle_args();
421 args.setTable(table);
422 args.setDeleteSingle(deleteSingle);
423 sendBase("deleteSingle", args);
424 }
425
426 public void recv_deleteSingle() throws TIOError, org.apache.thrift.TException
427 {
428 deleteSingle_result result = new deleteSingle_result();
429 receiveBase(result, "deleteSingle");
430 if (result.io != null) {
431 throw result.io;
432 }
433 return;
434 }
435
436 public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException
437 {
438 send_deleteMultiple(table, deletes);
439 return recv_deleteMultiple();
440 }
441
442 public void send_deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws org.apache.thrift.TException
443 {
444 deleteMultiple_args args = new deleteMultiple_args();
445 args.setTable(table);
446 args.setDeletes(deletes);
447 sendBase("deleteMultiple", args);
448 }
449
450 public List<TDelete> recv_deleteMultiple() throws TIOError, org.apache.thrift.TException
451 {
452 deleteMultiple_result result = new deleteMultiple_result();
453 receiveBase(result, "deleteMultiple");
454 if (result.isSetSuccess()) {
455 return result.success;
456 }
457 if (result.io != null) {
458 throw result.io;
459 }
460 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "deleteMultiple failed: unknown result");
461 }
462
463 public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
464 {
465 send_checkAndDelete(table, row, family, qualifier, value, deleteSingle);
466 return recv_checkAndDelete();
467 }
468
469 public void send_checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws org.apache.thrift.TException
470 {
471 checkAndDelete_args args = new checkAndDelete_args();
472 args.setTable(table);
473 args.setRow(row);
474 args.setFamily(family);
475 args.setQualifier(qualifier);
476 args.setValue(value);
477 args.setDeleteSingle(deleteSingle);
478 sendBase("checkAndDelete", args);
479 }
480
481 public boolean recv_checkAndDelete() throws TIOError, org.apache.thrift.TException
482 {
483 checkAndDelete_result result = new checkAndDelete_result();
484 receiveBase(result, "checkAndDelete");
485 if (result.isSetSuccess()) {
486 return result.success;
487 }
488 if (result.io != null) {
489 throw result.io;
490 }
491 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndDelete failed: unknown result");
492 }
493
494 public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException
495 {
496 send_increment(table, increment);
497 return recv_increment();
498 }
499
500 public void send_increment(ByteBuffer table, TIncrement increment) throws org.apache.thrift.TException
501 {
502 increment_args args = new increment_args();
503 args.setTable(table);
504 args.setIncrement(increment);
505 sendBase("increment", args);
506 }
507
508 public TResult recv_increment() throws TIOError, org.apache.thrift.TException
509 {
510 increment_result result = new increment_result();
511 receiveBase(result, "increment");
512 if (result.isSetSuccess()) {
513 return result.success;
514 }
515 if (result.io != null) {
516 throw result.io;
517 }
518 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "increment failed: unknown result");
519 }
520
521 public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException
522 {
523 send_openScanner(table, scan);
524 return recv_openScanner();
525 }
526
527 public void send_openScanner(ByteBuffer table, TScan scan) throws org.apache.thrift.TException
528 {
529 openScanner_args args = new openScanner_args();
530 args.setTable(table);
531 args.setScan(scan);
532 sendBase("openScanner", args);
533 }
534
535 public int recv_openScanner() throws TIOError, org.apache.thrift.TException
536 {
537 openScanner_result result = new openScanner_result();
538 receiveBase(result, "openScanner");
539 if (result.isSetSuccess()) {
540 return result.success;
541 }
542 if (result.io != null) {
543 throw result.io;
544 }
545 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "openScanner failed: unknown result");
546 }
547
548 public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException
549 {
550 send_getScannerRows(scannerId, numRows);
551 return recv_getScannerRows();
552 }
553
554 public void send_getScannerRows(int scannerId, int numRows) throws org.apache.thrift.TException
555 {
556 getScannerRows_args args = new getScannerRows_args();
557 args.setScannerId(scannerId);
558 args.setNumRows(numRows);
559 sendBase("getScannerRows", args);
560 }
561
562 public List<TResult> recv_getScannerRows() throws TIOError, TIllegalArgument, org.apache.thrift.TException
563 {
564 getScannerRows_result result = new getScannerRows_result();
565 receiveBase(result, "getScannerRows");
566 if (result.isSetSuccess()) {
567 return result.success;
568 }
569 if (result.io != null) {
570 throw result.io;
571 }
572 if (result.ia != null) {
573 throw result.ia;
574 }
575 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerRows failed: unknown result");
576 }
577
578 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException
579 {
580 send_closeScanner(scannerId);
581 recv_closeScanner();
582 }
583
584 public void send_closeScanner(int scannerId) throws org.apache.thrift.TException
585 {
586 closeScanner_args args = new closeScanner_args();
587 args.setScannerId(scannerId);
588 sendBase("closeScanner", args);
589 }
590
591 public void recv_closeScanner() throws TIOError, TIllegalArgument, org.apache.thrift.TException
592 {
593 closeScanner_result result = new closeScanner_result();
594 receiveBase(result, "closeScanner");
595 if (result.io != null) {
596 throw result.io;
597 }
598 if (result.ia != null) {
599 throw result.ia;
600 }
601 return;
602 }
603
604 }
605 public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
606 public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
607 private org.apache.thrift.async.TAsyncClientManager clientManager;
608 private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
609 public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) {
610 this.clientManager = clientManager;
611 this.protocolFactory = protocolFactory;
612 }
613 public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) {
614 return new AsyncClient(protocolFactory, clientManager, transport);
615 }
616 }
617
618 public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) {
619 super(protocolFactory, clientManager, transport);
620 }
621
622 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<exists_call> resultHandler) throws org.apache.thrift.TException {
623 checkReady();
624 exists_call method_call = new exists_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
625 this.___currentMethod = method_call;
626 ___manager.call(method_call);
627 }
628
629 public static class exists_call extends org.apache.thrift.async.TAsyncMethodCall {
630 private ByteBuffer table;
631 private TGet get;
632 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 {
633 super(client, protocolFactory, transport, resultHandler, false);
634 this.table = table;
635 this.get = get;
636 }
637
638 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
639 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("exists", org.apache.thrift.protocol.TMessageType.CALL, 0));
640 exists_args args = new exists_args();
641 args.setTable(table);
642 args.setGet(get);
643 args.write(prot);
644 prot.writeMessageEnd();
645 }
646
647 public boolean getResult() throws TIOError, org.apache.thrift.TException {
648 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
649 throw new IllegalStateException("Method call not finished!");
650 }
651 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
652 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
653 return (new Client(prot)).recv_exists();
654 }
655 }
656
657 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<get_call> resultHandler) throws org.apache.thrift.TException {
658 checkReady();
659 get_call method_call = new get_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
660 this.___currentMethod = method_call;
661 ___manager.call(method_call);
662 }
663
664 public static class get_call extends org.apache.thrift.async.TAsyncMethodCall {
665 private ByteBuffer table;
666 private TGet get;
667 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 {
668 super(client, protocolFactory, transport, resultHandler, false);
669 this.table = table;
670 this.get = get;
671 }
672
673 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
674 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.CALL, 0));
675 get_args args = new get_args();
676 args.setTable(table);
677 args.setGet(get);
678 args.write(prot);
679 prot.writeMessageEnd();
680 }
681
682 public TResult getResult() throws TIOError, org.apache.thrift.TException {
683 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
684 throw new IllegalStateException("Method call not finished!");
685 }
686 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
687 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
688 return (new Client(prot)).recv_get();
689 }
690 }
691
692 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<getMultiple_call> resultHandler) throws org.apache.thrift.TException {
693 checkReady();
694 getMultiple_call method_call = new getMultiple_call(table, gets, resultHandler, this, ___protocolFactory, ___transport);
695 this.___currentMethod = method_call;
696 ___manager.call(method_call);
697 }
698
699 public static class getMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
700 private ByteBuffer table;
701 private List<TGet> gets;
702 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 {
703 super(client, protocolFactory, transport, resultHandler, false);
704 this.table = table;
705 this.gets = gets;
706 }
707
708 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
709 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
710 getMultiple_args args = new getMultiple_args();
711 args.setTable(table);
712 args.setGets(gets);
713 args.write(prot);
714 prot.writeMessageEnd();
715 }
716
717 public List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
718 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
719 throw new IllegalStateException("Method call not finished!");
720 }
721 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
722 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
723 return (new Client(prot)).recv_getMultiple();
724 }
725 }
726
727 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<put_call> resultHandler) throws org.apache.thrift.TException {
728 checkReady();
729 put_call method_call = new put_call(table, put, resultHandler, this, ___protocolFactory, ___transport);
730 this.___currentMethod = method_call;
731 ___manager.call(method_call);
732 }
733
734 public static class put_call extends org.apache.thrift.async.TAsyncMethodCall {
735 private ByteBuffer table;
736 private TPut put;
737 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 {
738 super(client, protocolFactory, transport, resultHandler, false);
739 this.table = table;
740 this.put = put;
741 }
742
743 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
744 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("put", org.apache.thrift.protocol.TMessageType.CALL, 0));
745 put_args args = new put_args();
746 args.setTable(table);
747 args.setPut(put);
748 args.write(prot);
749 prot.writeMessageEnd();
750 }
751
752 public void getResult() throws TIOError, org.apache.thrift.TException {
753 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
754 throw new IllegalStateException("Method call not finished!");
755 }
756 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
757 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
758 (new Client(prot)).recv_put();
759 }
760 }
761
762 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 {
763 checkReady();
764 checkAndPut_call method_call = new checkAndPut_call(table, row, family, qualifier, value, put, resultHandler, this, ___protocolFactory, ___transport);
765 this.___currentMethod = method_call;
766 ___manager.call(method_call);
767 }
768
769 public static class checkAndPut_call extends org.apache.thrift.async.TAsyncMethodCall {
770 private ByteBuffer table;
771 private ByteBuffer row;
772 private ByteBuffer family;
773 private ByteBuffer qualifier;
774 private ByteBuffer value;
775 private TPut put;
776 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 {
777 super(client, protocolFactory, transport, resultHandler, false);
778 this.table = table;
779 this.row = row;
780 this.family = family;
781 this.qualifier = qualifier;
782 this.value = value;
783 this.put = put;
784 }
785
786 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
787 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndPut", org.apache.thrift.protocol.TMessageType.CALL, 0));
788 checkAndPut_args args = new checkAndPut_args();
789 args.setTable(table);
790 args.setRow(row);
791 args.setFamily(family);
792 args.setQualifier(qualifier);
793 args.setValue(value);
794 args.setPut(put);
795 args.write(prot);
796 prot.writeMessageEnd();
797 }
798
799 public boolean getResult() throws TIOError, org.apache.thrift.TException {
800 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
801 throw new IllegalStateException("Method call not finished!");
802 }
803 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
804 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
805 return (new Client(prot)).recv_checkAndPut();
806 }
807 }
808
809 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<putMultiple_call> resultHandler) throws org.apache.thrift.TException {
810 checkReady();
811 putMultiple_call method_call = new putMultiple_call(table, puts, resultHandler, this, ___protocolFactory, ___transport);
812 this.___currentMethod = method_call;
813 ___manager.call(method_call);
814 }
815
816 public static class putMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
817 private ByteBuffer table;
818 private List<TPut> puts;
819 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 {
820 super(client, protocolFactory, transport, resultHandler, false);
821 this.table = table;
822 this.puts = puts;
823 }
824
825 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
826 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("putMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
827 putMultiple_args args = new putMultiple_args();
828 args.setTable(table);
829 args.setPuts(puts);
830 args.write(prot);
831 prot.writeMessageEnd();
832 }
833
834 public void getResult() throws TIOError, org.apache.thrift.TException {
835 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
836 throw new IllegalStateException("Method call not finished!");
837 }
838 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
839 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
840 (new Client(prot)).recv_putMultiple();
841 }
842 }
843
844 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<deleteSingle_call> resultHandler) throws org.apache.thrift.TException {
845 checkReady();
846 deleteSingle_call method_call = new deleteSingle_call(table, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
847 this.___currentMethod = method_call;
848 ___manager.call(method_call);
849 }
850
851 public static class deleteSingle_call extends org.apache.thrift.async.TAsyncMethodCall {
852 private ByteBuffer table;
853 private TDelete deleteSingle;
854 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 {
855 super(client, protocolFactory, transport, resultHandler, false);
856 this.table = table;
857 this.deleteSingle = deleteSingle;
858 }
859
860 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
861 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteSingle", org.apache.thrift.protocol.TMessageType.CALL, 0));
862 deleteSingle_args args = new deleteSingle_args();
863 args.setTable(table);
864 args.setDeleteSingle(deleteSingle);
865 args.write(prot);
866 prot.writeMessageEnd();
867 }
868
869 public void getResult() throws TIOError, org.apache.thrift.TException {
870 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
871 throw new IllegalStateException("Method call not finished!");
872 }
873 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
874 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
875 (new Client(prot)).recv_deleteSingle();
876 }
877 }
878
879 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<deleteMultiple_call> resultHandler) throws org.apache.thrift.TException {
880 checkReady();
881 deleteMultiple_call method_call = new deleteMultiple_call(table, deletes, resultHandler, this, ___protocolFactory, ___transport);
882 this.___currentMethod = method_call;
883 ___manager.call(method_call);
884 }
885
886 public static class deleteMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
887 private ByteBuffer table;
888 private List<TDelete> deletes;
889 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 {
890 super(client, protocolFactory, transport, resultHandler, false);
891 this.table = table;
892 this.deletes = deletes;
893 }
894
895 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
896 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
897 deleteMultiple_args args = new deleteMultiple_args();
898 args.setTable(table);
899 args.setDeletes(deletes);
900 args.write(prot);
901 prot.writeMessageEnd();
902 }
903
904 public List<TDelete> getResult() throws TIOError, org.apache.thrift.TException {
905 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
906 throw new IllegalStateException("Method call not finished!");
907 }
908 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
909 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
910 return (new Client(prot)).recv_deleteMultiple();
911 }
912 }
913
914 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 {
915 checkReady();
916 checkAndDelete_call method_call = new checkAndDelete_call(table, row, family, qualifier, value, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
917 this.___currentMethod = method_call;
918 ___manager.call(method_call);
919 }
920
921 public static class checkAndDelete_call extends org.apache.thrift.async.TAsyncMethodCall {
922 private ByteBuffer table;
923 private ByteBuffer row;
924 private ByteBuffer family;
925 private ByteBuffer qualifier;
926 private ByteBuffer value;
927 private TDelete deleteSingle;
928 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 {
929 super(client, protocolFactory, transport, resultHandler, false);
930 this.table = table;
931 this.row = row;
932 this.family = family;
933 this.qualifier = qualifier;
934 this.value = value;
935 this.deleteSingle = deleteSingle;
936 }
937
938 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
939 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndDelete", org.apache.thrift.protocol.TMessageType.CALL, 0));
940 checkAndDelete_args args = new checkAndDelete_args();
941 args.setTable(table);
942 args.setRow(row);
943 args.setFamily(family);
944 args.setQualifier(qualifier);
945 args.setValue(value);
946 args.setDeleteSingle(deleteSingle);
947 args.write(prot);
948 prot.writeMessageEnd();
949 }
950
951 public boolean getResult() throws TIOError, org.apache.thrift.TException {
952 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
953 throw new IllegalStateException("Method call not finished!");
954 }
955 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
956 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
957 return (new Client(prot)).recv_checkAndDelete();
958 }
959 }
960
961 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<increment_call> resultHandler) throws org.apache.thrift.TException {
962 checkReady();
963 increment_call method_call = new increment_call(table, increment, resultHandler, this, ___protocolFactory, ___transport);
964 this.___currentMethod = method_call;
965 ___manager.call(method_call);
966 }
967
968 public static class increment_call extends org.apache.thrift.async.TAsyncMethodCall {
969 private ByteBuffer table;
970 private TIncrement increment;
971 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 {
972 super(client, protocolFactory, transport, resultHandler, false);
973 this.table = table;
974 this.increment = increment;
975 }
976
977 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
978 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("increment", org.apache.thrift.protocol.TMessageType.CALL, 0));
979 increment_args args = new increment_args();
980 args.setTable(table);
981 args.setIncrement(increment);
982 args.write(prot);
983 prot.writeMessageEnd();
984 }
985
986 public TResult getResult() throws TIOError, org.apache.thrift.TException {
987 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
988 throw new IllegalStateException("Method call not finished!");
989 }
990 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
991 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
992 return (new Client(prot)).recv_increment();
993 }
994 }
995
996 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<openScanner_call> resultHandler) throws org.apache.thrift.TException {
997 checkReady();
998 openScanner_call method_call = new openScanner_call(table, scan, resultHandler, this, ___protocolFactory, ___transport);
999 this.___currentMethod = method_call;
1000 ___manager.call(method_call);
1001 }
1002
1003 public static class openScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1004 private ByteBuffer table;
1005 private TScan scan;
1006 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 {
1007 super(client, protocolFactory, transport, resultHandler, false);
1008 this.table = table;
1009 this.scan = scan;
1010 }
1011
1012 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1013 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("openScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1014 openScanner_args args = new openScanner_args();
1015 args.setTable(table);
1016 args.setScan(scan);
1017 args.write(prot);
1018 prot.writeMessageEnd();
1019 }
1020
1021 public int getResult() throws TIOError, org.apache.thrift.TException {
1022 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1023 throw new IllegalStateException("Method call not finished!");
1024 }
1025 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1026 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1027 return (new Client(prot)).recv_openScanner();
1028 }
1029 }
1030
1031 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerRows_call> resultHandler) throws org.apache.thrift.TException {
1032 checkReady();
1033 getScannerRows_call method_call = new getScannerRows_call(scannerId, numRows, resultHandler, this, ___protocolFactory, ___transport);
1034 this.___currentMethod = method_call;
1035 ___manager.call(method_call);
1036 }
1037
1038 public static class getScannerRows_call extends org.apache.thrift.async.TAsyncMethodCall {
1039 private int scannerId;
1040 private int numRows;
1041 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 {
1042 super(client, protocolFactory, transport, resultHandler, false);
1043 this.scannerId = scannerId;
1044 this.numRows = numRows;
1045 }
1046
1047 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1048 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerRows", org.apache.thrift.protocol.TMessageType.CALL, 0));
1049 getScannerRows_args args = new getScannerRows_args();
1050 args.setScannerId(scannerId);
1051 args.setNumRows(numRows);
1052 args.write(prot);
1053 prot.writeMessageEnd();
1054 }
1055
1056 public List<TResult> getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1057 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1058 throw new IllegalStateException("Method call not finished!");
1059 }
1060 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1061 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1062 return (new Client(prot)).recv_getScannerRows();
1063 }
1064 }
1065
1066 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<closeScanner_call> resultHandler) throws org.apache.thrift.TException {
1067 checkReady();
1068 closeScanner_call method_call = new closeScanner_call(scannerId, resultHandler, this, ___protocolFactory, ___transport);
1069 this.___currentMethod = method_call;
1070 ___manager.call(method_call);
1071 }
1072
1073 public static class closeScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1074 private int scannerId;
1075 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 {
1076 super(client, protocolFactory, transport, resultHandler, false);
1077 this.scannerId = scannerId;
1078 }
1079
1080 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1081 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1082 closeScanner_args args = new closeScanner_args();
1083 args.setScannerId(scannerId);
1084 args.write(prot);
1085 prot.writeMessageEnd();
1086 }
1087
1088 public void 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 (new Client(prot)).recv_closeScanner();
1095 }
1096 }
1097
1098 }
1099
1100 public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
1101 private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1102 public Processor(I iface) {
1103 super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
1104 }
1105
1106 protected Processor(I iface, Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
1107 super(iface, getProcessMap(processMap));
1108 }
1109
1110 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) {
1111 processMap.put("exists", new exists());
1112 processMap.put("get", new get());
1113 processMap.put("getMultiple", new getMultiple());
1114 processMap.put("put", new put());
1115 processMap.put("checkAndPut", new checkAndPut());
1116 processMap.put("putMultiple", new putMultiple());
1117 processMap.put("deleteSingle", new deleteSingle());
1118 processMap.put("deleteMultiple", new deleteMultiple());
1119 processMap.put("checkAndDelete", new checkAndDelete());
1120 processMap.put("increment", new increment());
1121 processMap.put("openScanner", new openScanner());
1122 processMap.put("getScannerRows", new getScannerRows());
1123 processMap.put("closeScanner", new closeScanner());
1124 return processMap;
1125 }
1126
1127 public static class exists<I extends Iface> extends org.apache.thrift.ProcessFunction<I, exists_args> {
1128 public exists() {
1129 super("exists");
1130 }
1131
1132 public exists_args getEmptyArgsInstance() {
1133 return new exists_args();
1134 }
1135
1136 protected boolean isOneway() {
1137 return false;
1138 }
1139
1140 public exists_result getResult(I iface, exists_args args) throws org.apache.thrift.TException {
1141 exists_result result = new exists_result();
1142 try {
1143 result.success = iface.exists(args.table, args.get);
1144 result.setSuccessIsSet(true);
1145 } catch (TIOError io) {
1146 result.io = io;
1147 }
1148 return result;
1149 }
1150 }
1151
1152 public static class get<I extends Iface> extends org.apache.thrift.ProcessFunction<I, get_args> {
1153 public get() {
1154 super("get");
1155 }
1156
1157 public get_args getEmptyArgsInstance() {
1158 return new get_args();
1159 }
1160
1161 protected boolean isOneway() {
1162 return false;
1163 }
1164
1165 public get_result getResult(I iface, get_args args) throws org.apache.thrift.TException {
1166 get_result result = new get_result();
1167 try {
1168 result.success = iface.get(args.table, args.get);
1169 } catch (TIOError io) {
1170 result.io = io;
1171 }
1172 return result;
1173 }
1174 }
1175
1176 public static class getMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getMultiple_args> {
1177 public getMultiple() {
1178 super("getMultiple");
1179 }
1180
1181 public getMultiple_args getEmptyArgsInstance() {
1182 return new getMultiple_args();
1183 }
1184
1185 protected boolean isOneway() {
1186 return false;
1187 }
1188
1189 public getMultiple_result getResult(I iface, getMultiple_args args) throws org.apache.thrift.TException {
1190 getMultiple_result result = new getMultiple_result();
1191 try {
1192 result.success = iface.getMultiple(args.table, args.gets);
1193 } catch (TIOError io) {
1194 result.io = io;
1195 }
1196 return result;
1197 }
1198 }
1199
1200 public static class put<I extends Iface> extends org.apache.thrift.ProcessFunction<I, put_args> {
1201 public put() {
1202 super("put");
1203 }
1204
1205 public put_args getEmptyArgsInstance() {
1206 return new put_args();
1207 }
1208
1209 protected boolean isOneway() {
1210 return false;
1211 }
1212
1213 public put_result getResult(I iface, put_args args) throws org.apache.thrift.TException {
1214 put_result result = new put_result();
1215 try {
1216 iface.put(args.table, args.put);
1217 } catch (TIOError io) {
1218 result.io = io;
1219 }
1220 return result;
1221 }
1222 }
1223
1224 public static class checkAndPut<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndPut_args> {
1225 public checkAndPut() {
1226 super("checkAndPut");
1227 }
1228
1229 public checkAndPut_args getEmptyArgsInstance() {
1230 return new checkAndPut_args();
1231 }
1232
1233 protected boolean isOneway() {
1234 return false;
1235 }
1236
1237 public checkAndPut_result getResult(I iface, checkAndPut_args args) throws org.apache.thrift.TException {
1238 checkAndPut_result result = new checkAndPut_result();
1239 try {
1240 result.success = iface.checkAndPut(args.table, args.row, args.family, args.qualifier, args.value, args.put);
1241 result.setSuccessIsSet(true);
1242 } catch (TIOError io) {
1243 result.io = io;
1244 }
1245 return result;
1246 }
1247 }
1248
1249 public static class putMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, putMultiple_args> {
1250 public putMultiple() {
1251 super("putMultiple");
1252 }
1253
1254 public putMultiple_args getEmptyArgsInstance() {
1255 return new putMultiple_args();
1256 }
1257
1258 protected boolean isOneway() {
1259 return false;
1260 }
1261
1262 public putMultiple_result getResult(I iface, putMultiple_args args) throws org.apache.thrift.TException {
1263 putMultiple_result result = new putMultiple_result();
1264 try {
1265 iface.putMultiple(args.table, args.puts);
1266 } catch (TIOError io) {
1267 result.io = io;
1268 }
1269 return result;
1270 }
1271 }
1272
1273 public static class deleteSingle<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteSingle_args> {
1274 public deleteSingle() {
1275 super("deleteSingle");
1276 }
1277
1278 public deleteSingle_args getEmptyArgsInstance() {
1279 return new deleteSingle_args();
1280 }
1281
1282 protected boolean isOneway() {
1283 return false;
1284 }
1285
1286 public deleteSingle_result getResult(I iface, deleteSingle_args args) throws org.apache.thrift.TException {
1287 deleteSingle_result result = new deleteSingle_result();
1288 try {
1289 iface.deleteSingle(args.table, args.deleteSingle);
1290 } catch (TIOError io) {
1291 result.io = io;
1292 }
1293 return result;
1294 }
1295 }
1296
1297 public static class deleteMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteMultiple_args> {
1298 public deleteMultiple() {
1299 super("deleteMultiple");
1300 }
1301
1302 public deleteMultiple_args getEmptyArgsInstance() {
1303 return new deleteMultiple_args();
1304 }
1305
1306 protected boolean isOneway() {
1307 return false;
1308 }
1309
1310 public deleteMultiple_result getResult(I iface, deleteMultiple_args args) throws org.apache.thrift.TException {
1311 deleteMultiple_result result = new deleteMultiple_result();
1312 try {
1313 result.success = iface.deleteMultiple(args.table, args.deletes);
1314 } catch (TIOError io) {
1315 result.io = io;
1316 }
1317 return result;
1318 }
1319 }
1320
1321 public static class checkAndDelete<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndDelete_args> {
1322 public checkAndDelete() {
1323 super("checkAndDelete");
1324 }
1325
1326 public checkAndDelete_args getEmptyArgsInstance() {
1327 return new checkAndDelete_args();
1328 }
1329
1330 protected boolean isOneway() {
1331 return false;
1332 }
1333
1334 public checkAndDelete_result getResult(I iface, checkAndDelete_args args) throws org.apache.thrift.TException {
1335 checkAndDelete_result result = new checkAndDelete_result();
1336 try {
1337 result.success = iface.checkAndDelete(args.table, args.row, args.family, args.qualifier, args.value, args.deleteSingle);
1338 result.setSuccessIsSet(true);
1339 } catch (TIOError io) {
1340 result.io = io;
1341 }
1342 return result;
1343 }
1344 }
1345
1346 public static class increment<I extends Iface> extends org.apache.thrift.ProcessFunction<I, increment_args> {
1347 public increment() {
1348 super("increment");
1349 }
1350
1351 public increment_args getEmptyArgsInstance() {
1352 return new increment_args();
1353 }
1354
1355 protected boolean isOneway() {
1356 return false;
1357 }
1358
1359 public increment_result getResult(I iface, increment_args args) throws org.apache.thrift.TException {
1360 increment_result result = new increment_result();
1361 try {
1362 result.success = iface.increment(args.table, args.increment);
1363 } catch (TIOError io) {
1364 result.io = io;
1365 }
1366 return result;
1367 }
1368 }
1369
1370 public static class openScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, openScanner_args> {
1371 public openScanner() {
1372 super("openScanner");
1373 }
1374
1375 public openScanner_args getEmptyArgsInstance() {
1376 return new openScanner_args();
1377 }
1378
1379 protected boolean isOneway() {
1380 return false;
1381 }
1382
1383 public openScanner_result getResult(I iface, openScanner_args args) throws org.apache.thrift.TException {
1384 openScanner_result result = new openScanner_result();
1385 try {
1386 result.success = iface.openScanner(args.table, args.scan);
1387 result.setSuccessIsSet(true);
1388 } catch (TIOError io) {
1389 result.io = io;
1390 }
1391 return result;
1392 }
1393 }
1394
1395 public static class getScannerRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerRows_args> {
1396 public getScannerRows() {
1397 super("getScannerRows");
1398 }
1399
1400 public getScannerRows_args getEmptyArgsInstance() {
1401 return new getScannerRows_args();
1402 }
1403
1404 protected boolean isOneway() {
1405 return false;
1406 }
1407
1408 public getScannerRows_result getResult(I iface, getScannerRows_args args) throws org.apache.thrift.TException {
1409 getScannerRows_result result = new getScannerRows_result();
1410 try {
1411 result.success = iface.getScannerRows(args.scannerId, args.numRows);
1412 } catch (TIOError io) {
1413 result.io = io;
1414 } catch (TIllegalArgument ia) {
1415 result.ia = ia;
1416 }
1417 return result;
1418 }
1419 }
1420
1421 public static class closeScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeScanner_args> {
1422 public closeScanner() {
1423 super("closeScanner");
1424 }
1425
1426 public closeScanner_args getEmptyArgsInstance() {
1427 return new closeScanner_args();
1428 }
1429
1430 protected boolean isOneway() {
1431 return false;
1432 }
1433
1434 public closeScanner_result getResult(I iface, closeScanner_args args) throws org.apache.thrift.TException {
1435 closeScanner_result result = new closeScanner_result();
1436 try {
1437 iface.closeScanner(args.scannerId);
1438 } catch (TIOError io) {
1439 result.io = io;
1440 } catch (TIllegalArgument ia) {
1441 result.ia = ia;
1442 }
1443 return result;
1444 }
1445 }
1446
1447 }
1448
1449 public static class exists_args implements org.apache.thrift.TBase<exists_args, exists_args._Fields>, java.io.Serializable, Cloneable {
1450 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_args");
1451
1452 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);
1453 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);
1454
1455 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
1456 static {
1457 schemes.put(StandardScheme.class, new exists_argsStandardSchemeFactory());
1458 schemes.put(TupleScheme.class, new exists_argsTupleSchemeFactory());
1459 }
1460
1461
1462
1463
1464 public ByteBuffer table;
1465
1466
1467
1468 public TGet get;
1469
1470
1471 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
1472
1473
1474
1475 TABLE((short)1, "table"),
1476
1477
1478
1479 GET((short)2, "get");
1480
1481 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
1482
1483 static {
1484 for (_Fields field : EnumSet.allOf(_Fields.class)) {
1485 byName.put(field.getFieldName(), field);
1486 }
1487 }
1488
1489
1490
1491
1492 public static _Fields findByThriftId(int fieldId) {
1493 switch(fieldId) {
1494 case 1:
1495 return TABLE;
1496 case 2:
1497 return GET;
1498 default:
1499 return null;
1500 }
1501 }
1502
1503
1504
1505
1506
1507 public static _Fields findByThriftIdOrThrow(int fieldId) {
1508 _Fields fields = findByThriftId(fieldId);
1509 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
1510 return fields;
1511 }
1512
1513
1514
1515
1516 public static _Fields findByName(String name) {
1517 return byName.get(name);
1518 }
1519
1520 private final short _thriftId;
1521 private final String _fieldName;
1522
1523 _Fields(short thriftId, String fieldName) {
1524 _thriftId = thriftId;
1525 _fieldName = fieldName;
1526 }
1527
1528 public short getThriftFieldId() {
1529 return _thriftId;
1530 }
1531
1532 public String getFieldName() {
1533 return _fieldName;
1534 }
1535 }
1536
1537
1538 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
1539 static {
1540 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
1541 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
1542 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
1543 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
1544 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
1545 metaDataMap = Collections.unmodifiableMap(tmpMap);
1546 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_args.class, metaDataMap);
1547 }
1548
1549 public exists_args() {
1550 }
1551
1552 public exists_args(
1553 ByteBuffer table,
1554 TGet get)
1555 {
1556 this();
1557 this.table = table;
1558 this.get = get;
1559 }
1560
1561
1562
1563
1564 public exists_args(exists_args other) {
1565 if (other.isSetTable()) {
1566 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
1567 ;
1568 }
1569 if (other.isSetGet()) {
1570 this.get = new TGet(other.get);
1571 }
1572 }
1573
1574 public exists_args deepCopy() {
1575 return new exists_args(this);
1576 }
1577
1578 @Override
1579 public void clear() {
1580 this.table = null;
1581 this.get = null;
1582 }
1583
1584
1585
1586
1587 public byte[] getTable() {
1588 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
1589 return table == null ? null : table.array();
1590 }
1591
1592 public ByteBuffer bufferForTable() {
1593 return table;
1594 }
1595
1596
1597
1598
1599 public exists_args setTable(byte[] table) {
1600 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
1601 return this;
1602 }
1603
1604 public exists_args setTable(ByteBuffer table) {
1605 this.table = table;
1606 return this;
1607 }
1608
1609 public void unsetTable() {
1610 this.table = null;
1611 }
1612
1613
1614 public boolean isSetTable() {
1615 return this.table != null;
1616 }
1617
1618 public void setTableIsSet(boolean value) {
1619 if (!value) {
1620 this.table = null;
1621 }
1622 }
1623
1624
1625
1626
1627 public TGet getGet() {
1628 return this.get;
1629 }
1630
1631
1632
1633
1634 public exists_args setGet(TGet get) {
1635 this.get = get;
1636 return this;
1637 }
1638
1639 public void unsetGet() {
1640 this.get = null;
1641 }
1642
1643
1644 public boolean isSetGet() {
1645 return this.get != null;
1646 }
1647
1648 public void setGetIsSet(boolean value) {
1649 if (!value) {
1650 this.get = null;
1651 }
1652 }
1653
1654 public void setFieldValue(_Fields field, Object value) {
1655 switch (field) {
1656 case TABLE:
1657 if (value == null) {
1658 unsetTable();
1659 } else {
1660 setTable((ByteBuffer)value);
1661 }
1662 break;
1663
1664 case GET:
1665 if (value == null) {
1666 unsetGet();
1667 } else {
1668 setGet((TGet)value);
1669 }
1670 break;
1671
1672 }
1673 }
1674
1675 public Object getFieldValue(_Fields field) {
1676 switch (field) {
1677 case TABLE:
1678 return getTable();
1679
1680 case GET:
1681 return getGet();
1682
1683 }
1684 throw new IllegalStateException();
1685 }
1686
1687
1688 public boolean isSet(_Fields field) {
1689 if (field == null) {
1690 throw new IllegalArgumentException();
1691 }
1692
1693 switch (field) {
1694 case TABLE:
1695 return isSetTable();
1696 case GET:
1697 return isSetGet();
1698 }
1699 throw new IllegalStateException();
1700 }
1701
1702 @Override
1703 public boolean equals(Object that) {
1704 if (that == null)
1705 return false;
1706 if (that instanceof exists_args)
1707 return this.equals((exists_args)that);
1708 return false;
1709 }
1710
1711 public boolean equals(exists_args that) {
1712 if (that == null)
1713 return false;
1714
1715 boolean this_present_table = true && this.isSetTable();
1716 boolean that_present_table = true && that.isSetTable();
1717 if (this_present_table || that_present_table) {
1718 if (!(this_present_table && that_present_table))
1719 return false;
1720 if (!this.table.equals(that.table))
1721 return false;
1722 }
1723
1724 boolean this_present_get = true && this.isSetGet();
1725 boolean that_present_get = true && that.isSetGet();
1726 if (this_present_get || that_present_get) {
1727 if (!(this_present_get && that_present_get))
1728 return false;
1729 if (!this.get.equals(that.get))
1730 return false;
1731 }
1732
1733 return true;
1734 }
1735
1736 @Override
1737 public int hashCode() {
1738 return 0;
1739 }
1740
1741 public int compareTo(exists_args other) {
1742 if (!getClass().equals(other.getClass())) {
1743 return getClass().getName().compareTo(other.getClass().getName());
1744 }
1745
1746 int lastComparison = 0;
1747 exists_args typedOther = (exists_args)other;
1748
1749 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
1750 if (lastComparison != 0) {
1751 return lastComparison;
1752 }
1753 if (isSetTable()) {
1754 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
1755 if (lastComparison != 0) {
1756 return lastComparison;
1757 }
1758 }
1759 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
1760 if (lastComparison != 0) {
1761 return lastComparison;
1762 }
1763 if (isSetGet()) {
1764 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
1765 if (lastComparison != 0) {
1766 return lastComparison;
1767 }
1768 }
1769 return 0;
1770 }
1771
1772 public _Fields fieldForId(int fieldId) {
1773 return _Fields.findByThriftId(fieldId);
1774 }
1775
1776 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
1777 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
1778 }
1779
1780 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
1781 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
1782 }
1783
1784 @Override
1785 public String toString() {
1786 StringBuilder sb = new StringBuilder("exists_args(");
1787 boolean first = true;
1788
1789 sb.append("table:");
1790 if (this.table == null) {
1791 sb.append("null");
1792 } else {
1793 org.apache.thrift.TBaseHelper.toString(this.table, sb);
1794 }
1795 first = false;
1796 if (!first) sb.append(", ");
1797 sb.append("get:");
1798 if (this.get == null) {
1799 sb.append("null");
1800 } else {
1801 sb.append(this.get);
1802 }
1803 first = false;
1804 sb.append(")");
1805 return sb.toString();
1806 }
1807
1808 public void validate() throws org.apache.thrift.TException {
1809
1810 if (table == null) {
1811 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
1812 }
1813 if (get == null) {
1814 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
1815 }
1816
1817 if (get != null) {
1818 get.validate();
1819 }
1820 }
1821
1822 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
1823 try {
1824 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
1825 } catch (org.apache.thrift.TException te) {
1826 throw new java.io.IOException(te);
1827 }
1828 }
1829
1830 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
1831 try {
1832 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
1833 } catch (org.apache.thrift.TException te) {
1834 throw new java.io.IOException(te);
1835 }
1836 }
1837
1838 private static class exists_argsStandardSchemeFactory implements SchemeFactory {
1839 public exists_argsStandardScheme getScheme() {
1840 return new exists_argsStandardScheme();
1841 }
1842 }
1843
1844 private static class exists_argsStandardScheme extends StandardScheme<exists_args> {
1845
1846 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_args struct) throws org.apache.thrift.TException {
1847 org.apache.thrift.protocol.TField schemeField;
1848 iprot.readStructBegin();
1849 while (true)
1850 {
1851 schemeField = iprot.readFieldBegin();
1852 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
1853 break;
1854 }
1855 switch (schemeField.id) {
1856 case 1:
1857 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
1858 struct.table = iprot.readBinary();
1859 struct.setTableIsSet(true);
1860 } else {
1861 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1862 }
1863 break;
1864 case 2:
1865 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
1866 struct.get = new TGet();
1867 struct.get.read(iprot);
1868 struct.setGetIsSet(true);
1869 } else {
1870 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1871 }
1872 break;
1873 default:
1874 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1875 }
1876 iprot.readFieldEnd();
1877 }
1878 iprot.readStructEnd();
1879
1880
1881 struct.validate();
1882 }
1883
1884 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_args struct) throws org.apache.thrift.TException {
1885 struct.validate();
1886
1887 oprot.writeStructBegin(STRUCT_DESC);
1888 if (struct.table != null) {
1889 oprot.writeFieldBegin(TABLE_FIELD_DESC);
1890 oprot.writeBinary(struct.table);
1891 oprot.writeFieldEnd();
1892 }
1893 if (struct.get != null) {
1894 oprot.writeFieldBegin(GET_FIELD_DESC);
1895 struct.get.write(oprot);
1896 oprot.writeFieldEnd();
1897 }
1898 oprot.writeFieldStop();
1899 oprot.writeStructEnd();
1900 }
1901
1902 }
1903
1904 private static class exists_argsTupleSchemeFactory implements SchemeFactory {
1905 public exists_argsTupleScheme getScheme() {
1906 return new exists_argsTupleScheme();
1907 }
1908 }
1909
1910 private static class exists_argsTupleScheme extends TupleScheme<exists_args> {
1911
1912 @Override
1913 public void write(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
1914 TTupleProtocol oprot = (TTupleProtocol) prot;
1915 oprot.writeBinary(struct.table);
1916 struct.get.write(oprot);
1917 }
1918
1919 @Override
1920 public void read(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
1921 TTupleProtocol iprot = (TTupleProtocol) prot;
1922 struct.table = iprot.readBinary();
1923 struct.setTableIsSet(true);
1924 struct.get = new TGet();
1925 struct.get.read(iprot);
1926 struct.setGetIsSet(true);
1927 }
1928 }
1929
1930 }
1931
1932 public static class exists_result implements org.apache.thrift.TBase<exists_result, exists_result._Fields>, java.io.Serializable, Cloneable {
1933 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_result");
1934
1935 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);
1936 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);
1937
1938 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
1939 static {
1940 schemes.put(StandardScheme.class, new exists_resultStandardSchemeFactory());
1941 schemes.put(TupleScheme.class, new exists_resultTupleSchemeFactory());
1942 }
1943
1944 public boolean success;
1945 public TIOError io;
1946
1947
1948 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
1949 SUCCESS((short)0, "success"),
1950 IO((short)1, "io");
1951
1952 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
1953
1954 static {
1955 for (_Fields field : EnumSet.allOf(_Fields.class)) {
1956 byName.put(field.getFieldName(), field);
1957 }
1958 }
1959
1960
1961
1962
1963 public static _Fields findByThriftId(int fieldId) {
1964 switch(fieldId) {
1965 case 0:
1966 return SUCCESS;
1967 case 1:
1968 return IO;
1969 default:
1970 return null;
1971 }
1972 }
1973
1974
1975
1976
1977
1978 public static _Fields findByThriftIdOrThrow(int fieldId) {
1979 _Fields fields = findByThriftId(fieldId);
1980 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
1981 return fields;
1982 }
1983
1984
1985
1986
1987 public static _Fields findByName(String name) {
1988 return byName.get(name);
1989 }
1990
1991 private final short _thriftId;
1992 private final String _fieldName;
1993
1994 _Fields(short thriftId, String fieldName) {
1995 _thriftId = thriftId;
1996 _fieldName = fieldName;
1997 }
1998
1999 public short getThriftFieldId() {
2000 return _thriftId;
2001 }
2002
2003 public String getFieldName() {
2004 return _fieldName;
2005 }
2006 }
2007
2008
2009 private static final int __SUCCESS_ISSET_ID = 0;
2010 private byte __isset_bitfield = 0;
2011 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2012 static {
2013 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2014 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
2015 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
2016 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
2017 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
2018 metaDataMap = Collections.unmodifiableMap(tmpMap);
2019 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_result.class, metaDataMap);
2020 }
2021
2022 public exists_result() {
2023 }
2024
2025 public exists_result(
2026 boolean success,
2027 TIOError io)
2028 {
2029 this();
2030 this.success = success;
2031 setSuccessIsSet(true);
2032 this.io = io;
2033 }
2034
2035
2036
2037
2038 public exists_result(exists_result other) {
2039 __isset_bitfield = other.__isset_bitfield;
2040 this.success = other.success;
2041 if (other.isSetIo()) {
2042 this.io = new TIOError(other.io);
2043 }
2044 }
2045
2046 public exists_result deepCopy() {
2047 return new exists_result(this);
2048 }
2049
2050 @Override
2051 public void clear() {
2052 setSuccessIsSet(false);
2053 this.success = false;
2054 this.io = null;
2055 }
2056
2057 public boolean isSuccess() {
2058 return this.success;
2059 }
2060
2061 public exists_result setSuccess(boolean success) {
2062 this.success = success;
2063 setSuccessIsSet(true);
2064 return this;
2065 }
2066
2067 public void unsetSuccess() {
2068 __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
2069 }
2070
2071
2072 public boolean isSetSuccess() {
2073 return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
2074 }
2075
2076 public void setSuccessIsSet(boolean value) {
2077 __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
2078 }
2079
2080 public TIOError getIo() {
2081 return this.io;
2082 }
2083
2084 public exists_result setIo(TIOError io) {
2085 this.io = io;
2086 return this;
2087 }
2088
2089 public void unsetIo() {
2090 this.io = null;
2091 }
2092
2093
2094 public boolean isSetIo() {
2095 return this.io != null;
2096 }
2097
2098 public void setIoIsSet(boolean value) {
2099 if (!value) {
2100 this.io = null;
2101 }
2102 }
2103
2104 public void setFieldValue(_Fields field, Object value) {
2105 switch (field) {
2106 case SUCCESS:
2107 if (value == null) {
2108 unsetSuccess();
2109 } else {
2110 setSuccess((Boolean)value);
2111 }
2112 break;
2113
2114 case IO:
2115 if (value == null) {
2116 unsetIo();
2117 } else {
2118 setIo((TIOError)value);
2119 }
2120 break;
2121
2122 }
2123 }
2124
2125 public Object getFieldValue(_Fields field) {
2126 switch (field) {
2127 case SUCCESS:
2128 return Boolean.valueOf(isSuccess());
2129
2130 case IO:
2131 return getIo();
2132
2133 }
2134 throw new IllegalStateException();
2135 }
2136
2137
2138 public boolean isSet(_Fields field) {
2139 if (field == null) {
2140 throw new IllegalArgumentException();
2141 }
2142
2143 switch (field) {
2144 case SUCCESS:
2145 return isSetSuccess();
2146 case IO:
2147 return isSetIo();
2148 }
2149 throw new IllegalStateException();
2150 }
2151
2152 @Override
2153 public boolean equals(Object that) {
2154 if (that == null)
2155 return false;
2156 if (that instanceof exists_result)
2157 return this.equals((exists_result)that);
2158 return false;
2159 }
2160
2161 public boolean equals(exists_result that) {
2162 if (that == null)
2163 return false;
2164
2165 boolean this_present_success = true;
2166 boolean that_present_success = true;
2167 if (this_present_success || that_present_success) {
2168 if (!(this_present_success && that_present_success))
2169 return false;
2170 if (this.success != that.success)
2171 return false;
2172 }
2173
2174 boolean this_present_io = true && this.isSetIo();
2175 boolean that_present_io = true && that.isSetIo();
2176 if (this_present_io || that_present_io) {
2177 if (!(this_present_io && that_present_io))
2178 return false;
2179 if (!this.io.equals(that.io))
2180 return false;
2181 }
2182
2183 return true;
2184 }
2185
2186 @Override
2187 public int hashCode() {
2188 return 0;
2189 }
2190
2191 public int compareTo(exists_result other) {
2192 if (!getClass().equals(other.getClass())) {
2193 return getClass().getName().compareTo(other.getClass().getName());
2194 }
2195
2196 int lastComparison = 0;
2197 exists_result typedOther = (exists_result)other;
2198
2199 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
2200 if (lastComparison != 0) {
2201 return lastComparison;
2202 }
2203 if (isSetSuccess()) {
2204 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
2205 if (lastComparison != 0) {
2206 return lastComparison;
2207 }
2208 }
2209 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
2210 if (lastComparison != 0) {
2211 return lastComparison;
2212 }
2213 if (isSetIo()) {
2214 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
2215 if (lastComparison != 0) {
2216 return lastComparison;
2217 }
2218 }
2219 return 0;
2220 }
2221
2222 public _Fields fieldForId(int fieldId) {
2223 return _Fields.findByThriftId(fieldId);
2224 }
2225
2226 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2227 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2228 }
2229
2230 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2231 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2232 }
2233
2234 @Override
2235 public String toString() {
2236 StringBuilder sb = new StringBuilder("exists_result(");
2237 boolean first = true;
2238
2239 sb.append("success:");
2240 sb.append(this.success);
2241 first = false;
2242 if (!first) sb.append(", ");
2243 sb.append("io:");
2244 if (this.io == null) {
2245 sb.append("null");
2246 } else {
2247 sb.append(this.io);
2248 }
2249 first = false;
2250 sb.append(")");
2251 return sb.toString();
2252 }
2253
2254 public void validate() throws org.apache.thrift.TException {
2255
2256
2257 }
2258
2259 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2260 try {
2261 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2262 } catch (org.apache.thrift.TException te) {
2263 throw new java.io.IOException(te);
2264 }
2265 }
2266
2267 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2268 try {
2269
2270 __isset_bitfield = 0;
2271 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2272 } catch (org.apache.thrift.TException te) {
2273 throw new java.io.IOException(te);
2274 }
2275 }
2276
2277 private static class exists_resultStandardSchemeFactory implements SchemeFactory {
2278 public exists_resultStandardScheme getScheme() {
2279 return new exists_resultStandardScheme();
2280 }
2281 }
2282
2283 private static class exists_resultStandardScheme extends StandardScheme<exists_result> {
2284
2285 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_result struct) throws org.apache.thrift.TException {
2286 org.apache.thrift.protocol.TField schemeField;
2287 iprot.readStructBegin();
2288 while (true)
2289 {
2290 schemeField = iprot.readFieldBegin();
2291 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2292 break;
2293 }
2294 switch (schemeField.id) {
2295 case 0:
2296 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
2297 struct.success = iprot.readBool();
2298 struct.setSuccessIsSet(true);
2299 } else {
2300 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2301 }
2302 break;
2303 case 1:
2304 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2305 struct.io = new TIOError();
2306 struct.io.read(iprot);
2307 struct.setIoIsSet(true);
2308 } else {
2309 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2310 }
2311 break;
2312 default:
2313 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2314 }
2315 iprot.readFieldEnd();
2316 }
2317 iprot.readStructEnd();
2318
2319
2320 struct.validate();
2321 }
2322
2323 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_result struct) throws org.apache.thrift.TException {
2324 struct.validate();
2325
2326 oprot.writeStructBegin(STRUCT_DESC);
2327 if (struct.isSetSuccess()) {
2328 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
2329 oprot.writeBool(struct.success);
2330 oprot.writeFieldEnd();
2331 }
2332 if (struct.io != null) {
2333 oprot.writeFieldBegin(IO_FIELD_DESC);
2334 struct.io.write(oprot);
2335 oprot.writeFieldEnd();
2336 }
2337 oprot.writeFieldStop();
2338 oprot.writeStructEnd();
2339 }
2340
2341 }
2342
2343 private static class exists_resultTupleSchemeFactory implements SchemeFactory {
2344 public exists_resultTupleScheme getScheme() {
2345 return new exists_resultTupleScheme();
2346 }
2347 }
2348
2349 private static class exists_resultTupleScheme extends TupleScheme<exists_result> {
2350
2351 @Override
2352 public void write(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2353 TTupleProtocol oprot = (TTupleProtocol) prot;
2354 BitSet optionals = new BitSet();
2355 if (struct.isSetSuccess()) {
2356 optionals.set(0);
2357 }
2358 if (struct.isSetIo()) {
2359 optionals.set(1);
2360 }
2361 oprot.writeBitSet(optionals, 2);
2362 if (struct.isSetSuccess()) {
2363 oprot.writeBool(struct.success);
2364 }
2365 if (struct.isSetIo()) {
2366 struct.io.write(oprot);
2367 }
2368 }
2369
2370 @Override
2371 public void read(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2372 TTupleProtocol iprot = (TTupleProtocol) prot;
2373 BitSet incoming = iprot.readBitSet(2);
2374 if (incoming.get(0)) {
2375 struct.success = iprot.readBool();
2376 struct.setSuccessIsSet(true);
2377 }
2378 if (incoming.get(1)) {
2379 struct.io = new TIOError();
2380 struct.io.read(iprot);
2381 struct.setIoIsSet(true);
2382 }
2383 }
2384 }
2385
2386 }
2387
2388 public static class get_args implements org.apache.thrift.TBase<get_args, get_args._Fields>, java.io.Serializable, Cloneable {
2389 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_args");
2390
2391 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);
2392 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);
2393
2394 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2395 static {
2396 schemes.put(StandardScheme.class, new get_argsStandardSchemeFactory());
2397 schemes.put(TupleScheme.class, new get_argsTupleSchemeFactory());
2398 }
2399
2400
2401
2402
2403 public ByteBuffer table;
2404
2405
2406
2407 public TGet get;
2408
2409
2410 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2411
2412
2413
2414 TABLE((short)1, "table"),
2415
2416
2417
2418 GET((short)2, "get");
2419
2420 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2421
2422 static {
2423 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2424 byName.put(field.getFieldName(), field);
2425 }
2426 }
2427
2428
2429
2430
2431 public static _Fields findByThriftId(int fieldId) {
2432 switch(fieldId) {
2433 case 1:
2434 return TABLE;
2435 case 2:
2436 return GET;
2437 default:
2438 return null;
2439 }
2440 }
2441
2442
2443
2444
2445
2446 public static _Fields findByThriftIdOrThrow(int fieldId) {
2447 _Fields fields = findByThriftId(fieldId);
2448 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2449 return fields;
2450 }
2451
2452
2453
2454
2455 public static _Fields findByName(String name) {
2456 return byName.get(name);
2457 }
2458
2459 private final short _thriftId;
2460 private final String _fieldName;
2461
2462 _Fields(short thriftId, String fieldName) {
2463 _thriftId = thriftId;
2464 _fieldName = fieldName;
2465 }
2466
2467 public short getThriftFieldId() {
2468 return _thriftId;
2469 }
2470
2471 public String getFieldName() {
2472 return _fieldName;
2473 }
2474 }
2475
2476
2477 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2478 static {
2479 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2480 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
2481 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
2482 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
2483 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
2484 metaDataMap = Collections.unmodifiableMap(tmpMap);
2485 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
2486 }
2487
2488 public get_args() {
2489 }
2490
2491 public get_args(
2492 ByteBuffer table,
2493 TGet get)
2494 {
2495 this();
2496 this.table = table;
2497 this.get = get;
2498 }
2499
2500
2501
2502
2503 public get_args(get_args other) {
2504 if (other.isSetTable()) {
2505 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
2506 ;
2507 }
2508 if (other.isSetGet()) {
2509 this.get = new TGet(other.get);
2510 }
2511 }
2512
2513 public get_args deepCopy() {
2514 return new get_args(this);
2515 }
2516
2517 @Override
2518 public void clear() {
2519 this.table = null;
2520 this.get = null;
2521 }
2522
2523
2524
2525
2526 public byte[] getTable() {
2527 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
2528 return table == null ? null : table.array();
2529 }
2530
2531 public ByteBuffer bufferForTable() {
2532 return table;
2533 }
2534
2535
2536
2537
2538 public get_args setTable(byte[] table) {
2539 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
2540 return this;
2541 }
2542
2543 public get_args setTable(ByteBuffer table) {
2544 this.table = table;
2545 return this;
2546 }
2547
2548 public void unsetTable() {
2549 this.table = null;
2550 }
2551
2552
2553 public boolean isSetTable() {
2554 return this.table != null;
2555 }
2556
2557 public void setTableIsSet(boolean value) {
2558 if (!value) {
2559 this.table = null;
2560 }
2561 }
2562
2563
2564
2565
2566 public TGet getGet() {
2567 return this.get;
2568 }
2569
2570
2571
2572
2573 public get_args setGet(TGet get) {
2574 this.get = get;
2575 return this;
2576 }
2577
2578 public void unsetGet() {
2579 this.get = null;
2580 }
2581
2582
2583 public boolean isSetGet() {
2584 return this.get != null;
2585 }
2586
2587 public void setGetIsSet(boolean value) {
2588 if (!value) {
2589 this.get = null;
2590 }
2591 }
2592
2593 public void setFieldValue(_Fields field, Object value) {
2594 switch (field) {
2595 case TABLE:
2596 if (value == null) {
2597 unsetTable();
2598 } else {
2599 setTable((ByteBuffer)value);
2600 }
2601 break;
2602
2603 case GET:
2604 if (value == null) {
2605 unsetGet();
2606 } else {
2607 setGet((TGet)value);
2608 }
2609 break;
2610
2611 }
2612 }
2613
2614 public Object getFieldValue(_Fields field) {
2615 switch (field) {
2616 case TABLE:
2617 return getTable();
2618
2619 case GET:
2620 return getGet();
2621
2622 }
2623 throw new IllegalStateException();
2624 }
2625
2626
2627 public boolean isSet(_Fields field) {
2628 if (field == null) {
2629 throw new IllegalArgumentException();
2630 }
2631
2632 switch (field) {
2633 case TABLE:
2634 return isSetTable();
2635 case GET:
2636 return isSetGet();
2637 }
2638 throw new IllegalStateException();
2639 }
2640
2641 @Override
2642 public boolean equals(Object that) {
2643 if (that == null)
2644 return false;
2645 if (that instanceof get_args)
2646 return this.equals((get_args)that);
2647 return false;
2648 }
2649
2650 public boolean equals(get_args that) {
2651 if (that == null)
2652 return false;
2653
2654 boolean this_present_table = true && this.isSetTable();
2655 boolean that_present_table = true && that.isSetTable();
2656 if (this_present_table || that_present_table) {
2657 if (!(this_present_table && that_present_table))
2658 return false;
2659 if (!this.table.equals(that.table))
2660 return false;
2661 }
2662
2663 boolean this_present_get = true && this.isSetGet();
2664 boolean that_present_get = true && that.isSetGet();
2665 if (this_present_get || that_present_get) {
2666 if (!(this_present_get && that_present_get))
2667 return false;
2668 if (!this.get.equals(that.get))
2669 return false;
2670 }
2671
2672 return true;
2673 }
2674
2675 @Override
2676 public int hashCode() {
2677 return 0;
2678 }
2679
2680 public int compareTo(get_args other) {
2681 if (!getClass().equals(other.getClass())) {
2682 return getClass().getName().compareTo(other.getClass().getName());
2683 }
2684
2685 int lastComparison = 0;
2686 get_args typedOther = (get_args)other;
2687
2688 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
2689 if (lastComparison != 0) {
2690 return lastComparison;
2691 }
2692 if (isSetTable()) {
2693 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
2694 if (lastComparison != 0) {
2695 return lastComparison;
2696 }
2697 }
2698 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
2699 if (lastComparison != 0) {
2700 return lastComparison;
2701 }
2702 if (isSetGet()) {
2703 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
2704 if (lastComparison != 0) {
2705 return lastComparison;
2706 }
2707 }
2708 return 0;
2709 }
2710
2711 public _Fields fieldForId(int fieldId) {
2712 return _Fields.findByThriftId(fieldId);
2713 }
2714
2715 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2716 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2717 }
2718
2719 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2720 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2721 }
2722
2723 @Override
2724 public String toString() {
2725 StringBuilder sb = new StringBuilder("get_args(");
2726 boolean first = true;
2727
2728 sb.append("table:");
2729 if (this.table == null) {
2730 sb.append("null");
2731 } else {
2732 org.apache.thrift.TBaseHelper.toString(this.table, sb);
2733 }
2734 first = false;
2735 if (!first) sb.append(", ");
2736 sb.append("get:");
2737 if (this.get == null) {
2738 sb.append("null");
2739 } else {
2740 sb.append(this.get);
2741 }
2742 first = false;
2743 sb.append(")");
2744 return sb.toString();
2745 }
2746
2747 public void validate() throws org.apache.thrift.TException {
2748
2749 if (table == null) {
2750 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
2751 }
2752 if (get == null) {
2753 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
2754 }
2755
2756 if (get != null) {
2757 get.validate();
2758 }
2759 }
2760
2761 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2762 try {
2763 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2764 } catch (org.apache.thrift.TException te) {
2765 throw new java.io.IOException(te);
2766 }
2767 }
2768
2769 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2770 try {
2771 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2772 } catch (org.apache.thrift.TException te) {
2773 throw new java.io.IOException(te);
2774 }
2775 }
2776
2777 private static class get_argsStandardSchemeFactory implements SchemeFactory {
2778 public get_argsStandardScheme getScheme() {
2779 return new get_argsStandardScheme();
2780 }
2781 }
2782
2783 private static class get_argsStandardScheme extends StandardScheme<get_args> {
2784
2785 public void read(org.apache.thrift.protocol.TProtocol iprot, get_args struct) throws org.apache.thrift.TException {
2786 org.apache.thrift.protocol.TField schemeField;
2787 iprot.readStructBegin();
2788 while (true)
2789 {
2790 schemeField = iprot.readFieldBegin();
2791 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2792 break;
2793 }
2794 switch (schemeField.id) {
2795 case 1:
2796 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
2797 struct.table = iprot.readBinary();
2798 struct.setTableIsSet(true);
2799 } else {
2800 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2801 }
2802 break;
2803 case 2:
2804 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2805 struct.get = new TGet();
2806 struct.get.read(iprot);
2807 struct.setGetIsSet(true);
2808 } else {
2809 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2810 }
2811 break;
2812 default:
2813 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2814 }
2815 iprot.readFieldEnd();
2816 }
2817 iprot.readStructEnd();
2818
2819
2820 struct.validate();
2821 }
2822
2823 public void write(org.apache.thrift.protocol.TProtocol oprot, get_args struct) throws org.apache.thrift.TException {
2824 struct.validate();
2825
2826 oprot.writeStructBegin(STRUCT_DESC);
2827 if (struct.table != null) {
2828 oprot.writeFieldBegin(TABLE_FIELD_DESC);
2829 oprot.writeBinary(struct.table);
2830 oprot.writeFieldEnd();
2831 }
2832 if (struct.get != null) {
2833 oprot.writeFieldBegin(GET_FIELD_DESC);
2834 struct.get.write(oprot);
2835 oprot.writeFieldEnd();
2836 }
2837 oprot.writeFieldStop();
2838 oprot.writeStructEnd();
2839 }
2840
2841 }
2842
2843 private static class get_argsTupleSchemeFactory implements SchemeFactory {
2844 public get_argsTupleScheme getScheme() {
2845 return new get_argsTupleScheme();
2846 }
2847 }
2848
2849 private static class get_argsTupleScheme extends TupleScheme<get_args> {
2850
2851 @Override
2852 public void write(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2853 TTupleProtocol oprot = (TTupleProtocol) prot;
2854 oprot.writeBinary(struct.table);
2855 struct.get.write(oprot);
2856 }
2857
2858 @Override
2859 public void read(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2860 TTupleProtocol iprot = (TTupleProtocol) prot;
2861 struct.table = iprot.readBinary();
2862 struct.setTableIsSet(true);
2863 struct.get = new TGet();
2864 struct.get.read(iprot);
2865 struct.setGetIsSet(true);
2866 }
2867 }
2868
2869 }
2870
2871 public static class get_result implements org.apache.thrift.TBase<get_result, get_result._Fields>, java.io.Serializable, Cloneable {
2872 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_result");
2873
2874 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);
2875 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);
2876
2877 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2878 static {
2879 schemes.put(StandardScheme.class, new get_resultStandardSchemeFactory());
2880 schemes.put(TupleScheme.class, new get_resultTupleSchemeFactory());
2881 }
2882
2883 public TResult success;
2884 public TIOError io;
2885
2886
2887 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2888 SUCCESS((short)0, "success"),
2889 IO((short)1, "io");
2890
2891 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2892
2893 static {
2894 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2895 byName.put(field.getFieldName(), field);
2896 }
2897 }
2898
2899
2900
2901
2902 public static _Fields findByThriftId(int fieldId) {
2903 switch(fieldId) {
2904 case 0:
2905 return SUCCESS;
2906 case 1:
2907 return IO;
2908 default:
2909 return null;
2910 }
2911 }
2912
2913
2914
2915
2916
2917 public static _Fields findByThriftIdOrThrow(int fieldId) {
2918 _Fields fields = findByThriftId(fieldId);
2919 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2920 return fields;
2921 }
2922
2923
2924
2925
2926 public static _Fields findByName(String name) {
2927 return byName.get(name);
2928 }
2929
2930 private final short _thriftId;
2931 private final String _fieldName;
2932
2933 _Fields(short thriftId, String fieldName) {
2934 _thriftId = thriftId;
2935 _fieldName = fieldName;
2936 }
2937
2938 public short getThriftFieldId() {
2939 return _thriftId;
2940 }
2941
2942 public String getFieldName() {
2943 return _fieldName;
2944 }
2945 }
2946
2947
2948 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2949 static {
2950 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2951 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
2952 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
2953 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
2954 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
2955 metaDataMap = Collections.unmodifiableMap(tmpMap);
2956 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
2957 }
2958
2959 public get_result() {
2960 }
2961
2962 public get_result(
2963 TResult success,
2964 TIOError io)
2965 {
2966 this();
2967 this.success = success;
2968 this.io = io;
2969 }
2970
2971
2972
2973
2974 public get_result(get_result other) {
2975 if (other.isSetSuccess()) {
2976 this.success = new TResult(other.success);
2977 }
2978 if (other.isSetIo()) {
2979 this.io = new TIOError(other.io);
2980 }
2981 }
2982
2983 public get_result deepCopy() {
2984 return new get_result(this);
2985 }
2986
2987 @Override
2988 public void clear() {
2989 this.success = null;
2990 this.io = null;
2991 }
2992
2993 public TResult getSuccess() {
2994 return this.success;
2995 }
2996
2997 public get_result setSuccess(TResult success) {
2998 this.success = success;
2999 return this;
3000 }
3001
3002 public void unsetSuccess() {
3003 this.success = null;
3004 }
3005
3006
3007 public boolean isSetSuccess() {
3008 return this.success != null;
3009 }
3010
3011 public void setSuccessIsSet(boolean value) {
3012 if (!value) {
3013 this.success = null;
3014 }
3015 }
3016
3017 public TIOError getIo() {
3018 return this.io;
3019 }
3020
3021 public get_result setIo(TIOError io) {
3022 this.io = io;
3023 return this;
3024 }
3025
3026 public void unsetIo() {
3027 this.io = null;
3028 }
3029
3030
3031 public boolean isSetIo() {
3032 return this.io != null;
3033 }
3034
3035 public void setIoIsSet(boolean value) {
3036 if (!value) {
3037 this.io = null;
3038 }
3039 }
3040
3041 public void setFieldValue(_Fields field, Object value) {
3042 switch (field) {
3043 case SUCCESS:
3044 if (value == null) {
3045 unsetSuccess();
3046 } else {
3047 setSuccess((TResult)value);
3048 }
3049 break;
3050
3051 case IO:
3052 if (value == null) {
3053 unsetIo();
3054 } else {
3055 setIo((TIOError)value);
3056 }
3057 break;
3058
3059 }
3060 }
3061
3062 public Object getFieldValue(_Fields field) {
3063 switch (field) {
3064 case SUCCESS:
3065 return getSuccess();
3066
3067 case IO:
3068 return getIo();
3069
3070 }
3071 throw new IllegalStateException();
3072 }
3073
3074
3075 public boolean isSet(_Fields field) {
3076 if (field == null) {
3077 throw new IllegalArgumentException();
3078 }
3079
3080 switch (field) {
3081 case SUCCESS:
3082 return isSetSuccess();
3083 case IO:
3084 return isSetIo();
3085 }
3086 throw new IllegalStateException();
3087 }
3088
3089 @Override
3090 public boolean equals(Object that) {
3091 if (that == null)
3092 return false;
3093 if (that instanceof get_result)
3094 return this.equals((get_result)that);
3095 return false;
3096 }
3097
3098 public boolean equals(get_result that) {
3099 if (that == null)
3100 return false;
3101
3102 boolean this_present_success = true && this.isSetSuccess();
3103 boolean that_present_success = true && that.isSetSuccess();
3104 if (this_present_success || that_present_success) {
3105 if (!(this_present_success && that_present_success))
3106 return false;
3107 if (!this.success.equals(that.success))
3108 return false;
3109 }
3110
3111 boolean this_present_io = true && this.isSetIo();
3112 boolean that_present_io = true && that.isSetIo();
3113 if (this_present_io || that_present_io) {
3114 if (!(this_present_io && that_present_io))
3115 return false;
3116 if (!this.io.equals(that.io))
3117 return false;
3118 }
3119
3120 return true;
3121 }
3122
3123 @Override
3124 public int hashCode() {
3125 return 0;
3126 }
3127
3128 public int compareTo(get_result other) {
3129 if (!getClass().equals(other.getClass())) {
3130 return getClass().getName().compareTo(other.getClass().getName());
3131 }
3132
3133 int lastComparison = 0;
3134 get_result typedOther = (get_result)other;
3135
3136 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
3137 if (lastComparison != 0) {
3138 return lastComparison;
3139 }
3140 if (isSetSuccess()) {
3141 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
3142 if (lastComparison != 0) {
3143 return lastComparison;
3144 }
3145 }
3146 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
3147 if (lastComparison != 0) {
3148 return lastComparison;
3149 }
3150 if (isSetIo()) {
3151 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
3152 if (lastComparison != 0) {
3153 return lastComparison;
3154 }
3155 }
3156 return 0;
3157 }
3158
3159 public _Fields fieldForId(int fieldId) {
3160 return _Fields.findByThriftId(fieldId);
3161 }
3162
3163 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3164 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3165 }
3166
3167 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3168 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3169 }
3170
3171 @Override
3172 public String toString() {
3173 StringBuilder sb = new StringBuilder("get_result(");
3174 boolean first = true;
3175
3176 sb.append("success:");
3177 if (this.success == null) {
3178 sb.append("null");
3179 } else {
3180 sb.append(this.success);
3181 }
3182 first = false;
3183 if (!first) sb.append(", ");
3184 sb.append("io:");
3185 if (this.io == null) {
3186 sb.append("null");
3187 } else {
3188 sb.append(this.io);
3189 }
3190 first = false;
3191 sb.append(")");
3192 return sb.toString();
3193 }
3194
3195 public void validate() throws org.apache.thrift.TException {
3196
3197
3198 if (success != null) {
3199 success.validate();
3200 }
3201 }
3202
3203 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3204 try {
3205 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3206 } catch (org.apache.thrift.TException te) {
3207 throw new java.io.IOException(te);
3208 }
3209 }
3210
3211 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3212 try {
3213 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3214 } catch (org.apache.thrift.TException te) {
3215 throw new java.io.IOException(te);
3216 }
3217 }
3218
3219 private static class get_resultStandardSchemeFactory implements SchemeFactory {
3220 public get_resultStandardScheme getScheme() {
3221 return new get_resultStandardScheme();
3222 }
3223 }
3224
3225 private static class get_resultStandardScheme extends StandardScheme<get_result> {
3226
3227 public void read(org.apache.thrift.protocol.TProtocol iprot, get_result struct) throws org.apache.thrift.TException {
3228 org.apache.thrift.protocol.TField schemeField;
3229 iprot.readStructBegin();
3230 while (true)
3231 {
3232 schemeField = iprot.readFieldBegin();
3233 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3234 break;
3235 }
3236 switch (schemeField.id) {
3237 case 0:
3238 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3239 struct.success = new TResult();
3240 struct.success.read(iprot);
3241 struct.setSuccessIsSet(true);
3242 } else {
3243 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3244 }
3245 break;
3246 case 1:
3247 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3248 struct.io = new TIOError();
3249 struct.io.read(iprot);
3250 struct.setIoIsSet(true);
3251 } else {
3252 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3253 }
3254 break;
3255 default:
3256 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3257 }
3258 iprot.readFieldEnd();
3259 }
3260 iprot.readStructEnd();
3261
3262
3263 struct.validate();
3264 }
3265
3266 public void write(org.apache.thrift.protocol.TProtocol oprot, get_result struct) throws org.apache.thrift.TException {
3267 struct.validate();
3268
3269 oprot.writeStructBegin(STRUCT_DESC);
3270 if (struct.success != null) {
3271 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3272 struct.success.write(oprot);
3273 oprot.writeFieldEnd();
3274 }
3275 if (struct.io != null) {
3276 oprot.writeFieldBegin(IO_FIELD_DESC);
3277 struct.io.write(oprot);
3278 oprot.writeFieldEnd();
3279 }
3280 oprot.writeFieldStop();
3281 oprot.writeStructEnd();
3282 }
3283
3284 }
3285
3286 private static class get_resultTupleSchemeFactory implements SchemeFactory {
3287 public get_resultTupleScheme getScheme() {
3288 return new get_resultTupleScheme();
3289 }
3290 }
3291
3292 private static class get_resultTupleScheme extends TupleScheme<get_result> {
3293
3294 @Override
3295 public void write(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3296 TTupleProtocol oprot = (TTupleProtocol) prot;
3297 BitSet optionals = new BitSet();
3298 if (struct.isSetSuccess()) {
3299 optionals.set(0);
3300 }
3301 if (struct.isSetIo()) {
3302 optionals.set(1);
3303 }
3304 oprot.writeBitSet(optionals, 2);
3305 if (struct.isSetSuccess()) {
3306 struct.success.write(oprot);
3307 }
3308 if (struct.isSetIo()) {
3309 struct.io.write(oprot);
3310 }
3311 }
3312
3313 @Override
3314 public void read(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3315 TTupleProtocol iprot = (TTupleProtocol) prot;
3316 BitSet incoming = iprot.readBitSet(2);
3317 if (incoming.get(0)) {
3318 struct.success = new TResult();
3319 struct.success.read(iprot);
3320 struct.setSuccessIsSet(true);
3321 }
3322 if (incoming.get(1)) {
3323 struct.io = new TIOError();
3324 struct.io.read(iprot);
3325 struct.setIoIsSet(true);
3326 }
3327 }
3328 }
3329
3330 }
3331
3332 public static class getMultiple_args implements org.apache.thrift.TBase<getMultiple_args, getMultiple_args._Fields>, java.io.Serializable, Cloneable {
3333 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_args");
3334
3335 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);
3336 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);
3337
3338 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3339 static {
3340 schemes.put(StandardScheme.class, new getMultiple_argsStandardSchemeFactory());
3341 schemes.put(TupleScheme.class, new getMultiple_argsTupleSchemeFactory());
3342 }
3343
3344
3345
3346
3347 public ByteBuffer table;
3348
3349
3350
3351
3352
3353 public List<TGet> gets;
3354
3355
3356 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3357
3358
3359
3360 TABLE((short)1, "table"),
3361
3362
3363
3364
3365
3366 GETS((short)2, "gets");
3367
3368 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3369
3370 static {
3371 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3372 byName.put(field.getFieldName(), field);
3373 }
3374 }
3375
3376
3377
3378
3379 public static _Fields findByThriftId(int fieldId) {
3380 switch(fieldId) {
3381 case 1:
3382 return TABLE;
3383 case 2:
3384 return GETS;
3385 default:
3386 return null;
3387 }
3388 }
3389
3390
3391
3392
3393
3394 public static _Fields findByThriftIdOrThrow(int fieldId) {
3395 _Fields fields = findByThriftId(fieldId);
3396 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3397 return fields;
3398 }
3399
3400
3401
3402
3403 public static _Fields findByName(String name) {
3404 return byName.get(name);
3405 }
3406
3407 private final short _thriftId;
3408 private final String _fieldName;
3409
3410 _Fields(short thriftId, String fieldName) {
3411 _thriftId = thriftId;
3412 _fieldName = fieldName;
3413 }
3414
3415 public short getThriftFieldId() {
3416 return _thriftId;
3417 }
3418
3419 public String getFieldName() {
3420 return _fieldName;
3421 }
3422 }
3423
3424
3425 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3426 static {
3427 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3428 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
3429 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
3430 tmpMap.put(_Fields.GETS, new org.apache.thrift.meta_data.FieldMetaData("gets", org.apache.thrift.TFieldRequirementType.REQUIRED,
3431 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
3432 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class))));
3433 metaDataMap = Collections.unmodifiableMap(tmpMap);
3434 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_args.class, metaDataMap);
3435 }
3436
3437 public getMultiple_args() {
3438 }
3439
3440 public getMultiple_args(
3441 ByteBuffer table,
3442 List<TGet> gets)
3443 {
3444 this();
3445 this.table = table;
3446 this.gets = gets;
3447 }
3448
3449
3450
3451
3452 public getMultiple_args(getMultiple_args other) {
3453 if (other.isSetTable()) {
3454 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
3455 ;
3456 }
3457 if (other.isSetGets()) {
3458 List<TGet> __this__gets = new ArrayList<TGet>();
3459 for (TGet other_element : other.gets) {
3460 __this__gets.add(new TGet(other_element));
3461 }
3462 this.gets = __this__gets;
3463 }
3464 }
3465
3466 public getMultiple_args deepCopy() {
3467 return new getMultiple_args(this);
3468 }
3469
3470 @Override
3471 public void clear() {
3472 this.table = null;
3473 this.gets = null;
3474 }
3475
3476
3477
3478
3479 public byte[] getTable() {
3480 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
3481 return table == null ? null : table.array();
3482 }
3483
3484 public ByteBuffer bufferForTable() {
3485 return table;
3486 }
3487
3488
3489
3490
3491 public getMultiple_args setTable(byte[] table) {
3492 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
3493 return this;
3494 }
3495
3496 public getMultiple_args setTable(ByteBuffer table) {
3497 this.table = table;
3498 return this;
3499 }
3500
3501 public void unsetTable() {
3502 this.table = null;
3503 }
3504
3505
3506 public boolean isSetTable() {
3507 return this.table != null;
3508 }
3509
3510 public void setTableIsSet(boolean value) {
3511 if (!value) {
3512 this.table = null;
3513 }
3514 }
3515
3516 public int getGetsSize() {
3517 return (this.gets == null) ? 0 : this.gets.size();
3518 }
3519
3520 public java.util.Iterator<TGet> getGetsIterator() {
3521 return (this.gets == null) ? null : this.gets.iterator();
3522 }
3523
3524 public void addToGets(TGet elem) {
3525 if (this.gets == null) {
3526 this.gets = new ArrayList<TGet>();
3527 }
3528 this.gets.add(elem);
3529 }
3530
3531
3532
3533
3534
3535
3536 public List<TGet> getGets() {
3537 return this.gets;
3538 }
3539
3540
3541
3542
3543
3544
3545 public getMultiple_args setGets(List<TGet> gets) {
3546 this.gets = gets;
3547 return this;
3548 }
3549
3550 public void unsetGets() {
3551 this.gets = null;
3552 }
3553
3554
3555 public boolean isSetGets() {
3556 return this.gets != null;
3557 }
3558
3559 public void setGetsIsSet(boolean value) {
3560 if (!value) {
3561 this.gets = null;
3562 }
3563 }
3564
3565 public void setFieldValue(_Fields field, Object value) {
3566 switch (field) {
3567 case TABLE:
3568 if (value == null) {
3569 unsetTable();
3570 } else {
3571 setTable((ByteBuffer)value);
3572 }
3573 break;
3574
3575 case GETS:
3576 if (value == null) {
3577 unsetGets();
3578 } else {
3579 setGets((List<TGet>)value);
3580 }
3581 break;
3582
3583 }
3584 }
3585
3586 public Object getFieldValue(_Fields field) {
3587 switch (field) {
3588 case TABLE:
3589 return getTable();
3590
3591 case GETS:
3592 return getGets();
3593
3594 }
3595 throw new IllegalStateException();
3596 }
3597
3598
3599 public boolean isSet(_Fields field) {
3600 if (field == null) {
3601 throw new IllegalArgumentException();
3602 }
3603
3604 switch (field) {
3605 case TABLE:
3606 return isSetTable();
3607 case GETS:
3608 return isSetGets();
3609 }
3610 throw new IllegalStateException();
3611 }
3612
3613 @Override
3614 public boolean equals(Object that) {
3615 if (that == null)
3616 return false;
3617 if (that instanceof getMultiple_args)
3618 return this.equals((getMultiple_args)that);
3619 return false;
3620 }
3621
3622 public boolean equals(getMultiple_args that) {
3623 if (that == null)
3624 return false;
3625
3626 boolean this_present_table = true && this.isSetTable();
3627 boolean that_present_table = true && that.isSetTable();
3628 if (this_present_table || that_present_table) {
3629 if (!(this_present_table && that_present_table))
3630 return false;
3631 if (!this.table.equals(that.table))
3632 return false;
3633 }
3634
3635 boolean this_present_gets = true && this.isSetGets();
3636 boolean that_present_gets = true && that.isSetGets();
3637 if (this_present_gets || that_present_gets) {
3638 if (!(this_present_gets && that_present_gets))
3639 return false;
3640 if (!this.gets.equals(that.gets))
3641 return false;
3642 }
3643
3644 return true;
3645 }
3646
3647 @Override
3648 public int hashCode() {
3649 return 0;
3650 }
3651
3652 public int compareTo(getMultiple_args other) {
3653 if (!getClass().equals(other.getClass())) {
3654 return getClass().getName().compareTo(other.getClass().getName());
3655 }
3656
3657 int lastComparison = 0;
3658 getMultiple_args typedOther = (getMultiple_args)other;
3659
3660 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
3661 if (lastComparison != 0) {
3662 return lastComparison;
3663 }
3664 if (isSetTable()) {
3665 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
3666 if (lastComparison != 0) {
3667 return lastComparison;
3668 }
3669 }
3670 lastComparison = Boolean.valueOf(isSetGets()).compareTo(typedOther.isSetGets());
3671 if (lastComparison != 0) {
3672 return lastComparison;
3673 }
3674 if (isSetGets()) {
3675 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gets, typedOther.gets);
3676 if (lastComparison != 0) {
3677 return lastComparison;
3678 }
3679 }
3680 return 0;
3681 }
3682
3683 public _Fields fieldForId(int fieldId) {
3684 return _Fields.findByThriftId(fieldId);
3685 }
3686
3687 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3688 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3689 }
3690
3691 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3692 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3693 }
3694
3695 @Override
3696 public String toString() {
3697 StringBuilder sb = new StringBuilder("getMultiple_args(");
3698 boolean first = true;
3699
3700 sb.append("table:");
3701 if (this.table == null) {
3702 sb.append("null");
3703 } else {
3704 org.apache.thrift.TBaseHelper.toString(this.table, sb);
3705 }
3706 first = false;
3707 if (!first) sb.append(", ");
3708 sb.append("gets:");
3709 if (this.gets == null) {
3710 sb.append("null");
3711 } else {
3712 sb.append(this.gets);
3713 }
3714 first = false;
3715 sb.append(")");
3716 return sb.toString();
3717 }
3718
3719 public void validate() throws org.apache.thrift.TException {
3720
3721 if (table == null) {
3722 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
3723 }
3724 if (gets == null) {
3725 throw new org.apache.thrift.protocol.TProtocolException("Required field 'gets' was not present! Struct: " + toString());
3726 }
3727
3728 }
3729
3730 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3731 try {
3732 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3733 } catch (org.apache.thrift.TException te) {
3734 throw new java.io.IOException(te);
3735 }
3736 }
3737
3738 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3739 try {
3740 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3741 } catch (org.apache.thrift.TException te) {
3742 throw new java.io.IOException(te);
3743 }
3744 }
3745
3746 private static class getMultiple_argsStandardSchemeFactory implements SchemeFactory {
3747 public getMultiple_argsStandardScheme getScheme() {
3748 return new getMultiple_argsStandardScheme();
3749 }
3750 }
3751
3752 private static class getMultiple_argsStandardScheme extends StandardScheme<getMultiple_args> {
3753
3754 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_args struct) throws org.apache.thrift.TException {
3755 org.apache.thrift.protocol.TField schemeField;
3756 iprot.readStructBegin();
3757 while (true)
3758 {
3759 schemeField = iprot.readFieldBegin();
3760 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3761 break;
3762 }
3763 switch (schemeField.id) {
3764 case 1:
3765 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
3766 struct.table = iprot.readBinary();
3767 struct.setTableIsSet(true);
3768 } else {
3769 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3770 }
3771 break;
3772 case 2:
3773 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
3774 {
3775 org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
3776 struct.gets = new ArrayList<TGet>(_list48.size);
3777 for (int _i49 = 0; _i49 < _list48.size; ++_i49)
3778 {
3779 TGet _elem50;
3780 _elem50 = new TGet();
3781 _elem50.read(iprot);
3782 struct.gets.add(_elem50);
3783 }
3784 iprot.readListEnd();
3785 }
3786 struct.setGetsIsSet(true);
3787 } else {
3788 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3789 }
3790 break;
3791 default:
3792 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3793 }
3794 iprot.readFieldEnd();
3795 }
3796 iprot.readStructEnd();
3797
3798
3799 struct.validate();
3800 }
3801
3802 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_args struct) throws org.apache.thrift.TException {
3803 struct.validate();
3804
3805 oprot.writeStructBegin(STRUCT_DESC);
3806 if (struct.table != null) {
3807 oprot.writeFieldBegin(TABLE_FIELD_DESC);
3808 oprot.writeBinary(struct.table);
3809 oprot.writeFieldEnd();
3810 }
3811 if (struct.gets != null) {
3812 oprot.writeFieldBegin(GETS_FIELD_DESC);
3813 {
3814 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.gets.size()));
3815 for (TGet _iter51 : struct.gets)
3816 {
3817 _iter51.write(oprot);
3818 }
3819 oprot.writeListEnd();
3820 }
3821 oprot.writeFieldEnd();
3822 }
3823 oprot.writeFieldStop();
3824 oprot.writeStructEnd();
3825 }
3826
3827 }
3828
3829 private static class getMultiple_argsTupleSchemeFactory implements SchemeFactory {
3830 public getMultiple_argsTupleScheme getScheme() {
3831 return new getMultiple_argsTupleScheme();
3832 }
3833 }
3834
3835 private static class getMultiple_argsTupleScheme extends TupleScheme<getMultiple_args> {
3836
3837 @Override
3838 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3839 TTupleProtocol oprot = (TTupleProtocol) prot;
3840 oprot.writeBinary(struct.table);
3841 {
3842 oprot.writeI32(struct.gets.size());
3843 for (TGet _iter52 : struct.gets)
3844 {
3845 _iter52.write(oprot);
3846 }
3847 }
3848 }
3849
3850 @Override
3851 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3852 TTupleProtocol iprot = (TTupleProtocol) prot;
3853 struct.table = iprot.readBinary();
3854 struct.setTableIsSet(true);
3855 {
3856 org.apache.thrift.protocol.TList _list53 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
3857 struct.gets = new ArrayList<TGet>(_list53.size);
3858 for (int _i54 = 0; _i54 < _list53.size; ++_i54)
3859 {
3860 TGet _elem55;
3861 _elem55 = new TGet();
3862 _elem55.read(iprot);
3863 struct.gets.add(_elem55);
3864 }
3865 }
3866 struct.setGetsIsSet(true);
3867 }
3868 }
3869
3870 }
3871
3872 public static class getMultiple_result implements org.apache.thrift.TBase<getMultiple_result, getMultiple_result._Fields>, java.io.Serializable, Cloneable {
3873 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_result");
3874
3875 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);
3876 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);
3877
3878 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3879 static {
3880 schemes.put(StandardScheme.class, new getMultiple_resultStandardSchemeFactory());
3881 schemes.put(TupleScheme.class, new getMultiple_resultTupleSchemeFactory());
3882 }
3883
3884 public List<TResult> success;
3885 public TIOError io;
3886
3887
3888 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3889 SUCCESS((short)0, "success"),
3890 IO((short)1, "io");
3891
3892 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3893
3894 static {
3895 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3896 byName.put(field.getFieldName(), field);
3897 }
3898 }
3899
3900
3901
3902
3903 public static _Fields findByThriftId(int fieldId) {
3904 switch(fieldId) {
3905 case 0:
3906 return SUCCESS;
3907 case 1:
3908 return IO;
3909 default:
3910 return null;
3911 }
3912 }
3913
3914
3915
3916
3917
3918 public static _Fields findByThriftIdOrThrow(int fieldId) {
3919 _Fields fields = findByThriftId(fieldId);
3920 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3921 return fields;
3922 }
3923
3924
3925
3926
3927 public static _Fields findByName(String name) {
3928 return byName.get(name);
3929 }
3930
3931 private final short _thriftId;
3932 private final String _fieldName;
3933
3934 _Fields(short thriftId, String fieldName) {
3935 _thriftId = thriftId;
3936 _fieldName = fieldName;
3937 }
3938
3939 public short getThriftFieldId() {
3940 return _thriftId;
3941 }
3942
3943 public String getFieldName() {
3944 return _fieldName;
3945 }
3946 }
3947
3948
3949 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3950 static {
3951 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3952 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
3953 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
3954 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
3955 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
3956 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
3957 metaDataMap = Collections.unmodifiableMap(tmpMap);
3958 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_result.class, metaDataMap);
3959 }
3960
3961 public getMultiple_result() {
3962 }
3963
3964 public getMultiple_result(
3965 List<TResult> success,
3966 TIOError io)
3967 {
3968 this();
3969 this.success = success;
3970 this.io = io;
3971 }
3972
3973
3974
3975
3976 public getMultiple_result(getMultiple_result other) {
3977 if (other.isSetSuccess()) {
3978 List<TResult> __this__success = new ArrayList<TResult>();
3979 for (TResult other_element : other.success) {
3980 __this__success.add(new TResult(other_element));
3981 }
3982 this.success = __this__success;
3983 }
3984 if (other.isSetIo()) {
3985 this.io = new TIOError(other.io);
3986 }
3987 }
3988
3989 public getMultiple_result deepCopy() {
3990 return new getMultiple_result(this);
3991 }
3992
3993 @Override
3994 public void clear() {
3995 this.success = null;
3996 this.io = null;
3997 }
3998
3999 public int getSuccessSize() {
4000 return (this.success == null) ? 0 : this.success.size();
4001 }
4002
4003 public java.util.Iterator<TResult> getSuccessIterator() {
4004 return (this.success == null) ? null : this.success.iterator();
4005 }
4006
4007 public void addToSuccess(TResult elem) {
4008 if (this.success == null) {
4009 this.success = new ArrayList<TResult>();
4010 }
4011 this.success.add(elem);
4012 }
4013
4014 public List<TResult> getSuccess() {
4015 return this.success;
4016 }
4017
4018 public getMultiple_result setSuccess(List<TResult> success) {
4019 this.success = success;
4020 return this;
4021 }
4022
4023 public void unsetSuccess() {
4024 this.success = null;
4025 }
4026
4027
4028 public boolean isSetSuccess() {
4029 return this.success != null;
4030 }
4031
4032 public void setSuccessIsSet(boolean value) {
4033 if (!value) {
4034 this.success = null;
4035 }
4036 }
4037
4038 public TIOError getIo() {
4039 return this.io;
4040 }
4041
4042 public getMultiple_result setIo(TIOError io) {
4043 this.io = io;
4044 return this;
4045 }
4046
4047 public void unsetIo() {
4048 this.io = null;
4049 }
4050
4051
4052 public boolean isSetIo() {
4053 return this.io != null;
4054 }
4055
4056 public void setIoIsSet(boolean value) {
4057 if (!value) {
4058 this.io = null;
4059 }
4060 }
4061
4062 public void setFieldValue(_Fields field, Object value) {
4063 switch (field) {
4064 case SUCCESS:
4065 if (value == null) {
4066 unsetSuccess();
4067 } else {
4068 setSuccess((List<TResult>)value);
4069 }
4070 break;
4071
4072 case IO:
4073 if (value == null) {
4074 unsetIo();
4075 } else {
4076 setIo((TIOError)value);
4077 }
4078 break;
4079
4080 }
4081 }
4082
4083 public Object getFieldValue(_Fields field) {
4084 switch (field) {
4085 case SUCCESS:
4086 return getSuccess();
4087
4088 case IO:
4089 return getIo();
4090
4091 }
4092 throw new IllegalStateException();
4093 }
4094
4095
4096 public boolean isSet(_Fields field) {
4097 if (field == null) {
4098 throw new IllegalArgumentException();
4099 }
4100
4101 switch (field) {
4102 case SUCCESS:
4103 return isSetSuccess();
4104 case IO:
4105 return isSetIo();
4106 }
4107 throw new IllegalStateException();
4108 }
4109
4110 @Override
4111 public boolean equals(Object that) {
4112 if (that == null)
4113 return false;
4114 if (that instanceof getMultiple_result)
4115 return this.equals((getMultiple_result)that);
4116 return false;
4117 }
4118
4119 public boolean equals(getMultiple_result that) {
4120 if (that == null)
4121 return false;
4122
4123 boolean this_present_success = true && this.isSetSuccess();
4124 boolean that_present_success = true && that.isSetSuccess();
4125 if (this_present_success || that_present_success) {
4126 if (!(this_present_success && that_present_success))
4127 return false;
4128 if (!this.success.equals(that.success))
4129 return false;
4130 }
4131
4132 boolean this_present_io = true && this.isSetIo();
4133 boolean that_present_io = true && that.isSetIo();
4134 if (this_present_io || that_present_io) {
4135 if (!(this_present_io && that_present_io))
4136 return false;
4137 if (!this.io.equals(that.io))
4138 return false;
4139 }
4140
4141 return true;
4142 }
4143
4144 @Override
4145 public int hashCode() {
4146 return 0;
4147 }
4148
4149 public int compareTo(getMultiple_result other) {
4150 if (!getClass().equals(other.getClass())) {
4151 return getClass().getName().compareTo(other.getClass().getName());
4152 }
4153
4154 int lastComparison = 0;
4155 getMultiple_result typedOther = (getMultiple_result)other;
4156
4157 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
4158 if (lastComparison != 0) {
4159 return lastComparison;
4160 }
4161 if (isSetSuccess()) {
4162 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
4163 if (lastComparison != 0) {
4164 return lastComparison;
4165 }
4166 }
4167 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
4168 if (lastComparison != 0) {
4169 return lastComparison;
4170 }
4171 if (isSetIo()) {
4172 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
4173 if (lastComparison != 0) {
4174 return lastComparison;
4175 }
4176 }
4177 return 0;
4178 }
4179
4180 public _Fields fieldForId(int fieldId) {
4181 return _Fields.findByThriftId(fieldId);
4182 }
4183
4184 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4185 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4186 }
4187
4188 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4189 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4190 }
4191
4192 @Override
4193 public String toString() {
4194 StringBuilder sb = new StringBuilder("getMultiple_result(");
4195 boolean first = true;
4196
4197 sb.append("success:");
4198 if (this.success == null) {
4199 sb.append("null");
4200 } else {
4201 sb.append(this.success);
4202 }
4203 first = false;
4204 if (!first) sb.append(", ");
4205 sb.append("io:");
4206 if (this.io == null) {
4207 sb.append("null");
4208 } else {
4209 sb.append(this.io);
4210 }
4211 first = false;
4212 sb.append(")");
4213 return sb.toString();
4214 }
4215
4216 public void validate() throws org.apache.thrift.TException {
4217
4218
4219 }
4220
4221 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4222 try {
4223 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4224 } catch (org.apache.thrift.TException te) {
4225 throw new java.io.IOException(te);
4226 }
4227 }
4228
4229 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4230 try {
4231 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4232 } catch (org.apache.thrift.TException te) {
4233 throw new java.io.IOException(te);
4234 }
4235 }
4236
4237 private static class getMultiple_resultStandardSchemeFactory implements SchemeFactory {
4238 public getMultiple_resultStandardScheme getScheme() {
4239 return new getMultiple_resultStandardScheme();
4240 }
4241 }
4242
4243 private static class getMultiple_resultStandardScheme extends StandardScheme<getMultiple_result> {
4244
4245 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_result struct) throws org.apache.thrift.TException {
4246 org.apache.thrift.protocol.TField schemeField;
4247 iprot.readStructBegin();
4248 while (true)
4249 {
4250 schemeField = iprot.readFieldBegin();
4251 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4252 break;
4253 }
4254 switch (schemeField.id) {
4255 case 0:
4256 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
4257 {
4258 org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
4259 struct.success = new ArrayList<TResult>(_list56.size);
4260 for (int _i57 = 0; _i57 < _list56.size; ++_i57)
4261 {
4262 TResult _elem58;
4263 _elem58 = new TResult();
4264 _elem58.read(iprot);
4265 struct.success.add(_elem58);
4266 }
4267 iprot.readListEnd();
4268 }
4269 struct.setSuccessIsSet(true);
4270 } else {
4271 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4272 }
4273 break;
4274 case 1:
4275 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4276 struct.io = new TIOError();
4277 struct.io.read(iprot);
4278 struct.setIoIsSet(true);
4279 } else {
4280 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4281 }
4282 break;
4283 default:
4284 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4285 }
4286 iprot.readFieldEnd();
4287 }
4288 iprot.readStructEnd();
4289
4290
4291 struct.validate();
4292 }
4293
4294 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_result struct) throws org.apache.thrift.TException {
4295 struct.validate();
4296
4297 oprot.writeStructBegin(STRUCT_DESC);
4298 if (struct.success != null) {
4299 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4300 {
4301 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
4302 for (TResult _iter59 : struct.success)
4303 {
4304 _iter59.write(oprot);
4305 }
4306 oprot.writeListEnd();
4307 }
4308 oprot.writeFieldEnd();
4309 }
4310 if (struct.io != null) {
4311 oprot.writeFieldBegin(IO_FIELD_DESC);
4312 struct.io.write(oprot);
4313 oprot.writeFieldEnd();
4314 }
4315 oprot.writeFieldStop();
4316 oprot.writeStructEnd();
4317 }
4318
4319 }
4320
4321 private static class getMultiple_resultTupleSchemeFactory implements SchemeFactory {
4322 public getMultiple_resultTupleScheme getScheme() {
4323 return new getMultiple_resultTupleScheme();
4324 }
4325 }
4326
4327 private static class getMultiple_resultTupleScheme extends TupleScheme<getMultiple_result> {
4328
4329 @Override
4330 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4331 TTupleProtocol oprot = (TTupleProtocol) prot;
4332 BitSet optionals = new BitSet();
4333 if (struct.isSetSuccess()) {
4334 optionals.set(0);
4335 }
4336 if (struct.isSetIo()) {
4337 optionals.set(1);
4338 }
4339 oprot.writeBitSet(optionals, 2);
4340 if (struct.isSetSuccess()) {
4341 {
4342 oprot.writeI32(struct.success.size());
4343 for (TResult _iter60 : struct.success)
4344 {
4345 _iter60.write(oprot);
4346 }
4347 }
4348 }
4349 if (struct.isSetIo()) {
4350 struct.io.write(oprot);
4351 }
4352 }
4353
4354 @Override
4355 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4356 TTupleProtocol iprot = (TTupleProtocol) prot;
4357 BitSet incoming = iprot.readBitSet(2);
4358 if (incoming.get(0)) {
4359 {
4360 org.apache.thrift.protocol.TList _list61 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
4361 struct.success = new ArrayList<TResult>(_list61.size);
4362 for (int _i62 = 0; _i62 < _list61.size; ++_i62)
4363 {
4364 TResult _elem63;
4365 _elem63 = new TResult();
4366 _elem63.read(iprot);
4367 struct.success.add(_elem63);
4368 }
4369 }
4370 struct.setSuccessIsSet(true);
4371 }
4372 if (incoming.get(1)) {
4373 struct.io = new TIOError();
4374 struct.io.read(iprot);
4375 struct.setIoIsSet(true);
4376 }
4377 }
4378 }
4379
4380 }
4381
4382 public static class put_args implements org.apache.thrift.TBase<put_args, put_args._Fields>, java.io.Serializable, Cloneable {
4383 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_args");
4384
4385 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);
4386 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);
4387
4388 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4389 static {
4390 schemes.put(StandardScheme.class, new put_argsStandardSchemeFactory());
4391 schemes.put(TupleScheme.class, new put_argsTupleSchemeFactory());
4392 }
4393
4394
4395
4396
4397 public ByteBuffer table;
4398
4399
4400
4401 public TPut put;
4402
4403
4404 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4405
4406
4407
4408 TABLE((short)1, "table"),
4409
4410
4411
4412 PUT((short)2, "put");
4413
4414 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4415
4416 static {
4417 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4418 byName.put(field.getFieldName(), field);
4419 }
4420 }
4421
4422
4423
4424
4425 public static _Fields findByThriftId(int fieldId) {
4426 switch(fieldId) {
4427 case 1:
4428 return TABLE;
4429 case 2:
4430 return PUT;
4431 default:
4432 return null;
4433 }
4434 }
4435
4436
4437
4438
4439
4440 public static _Fields findByThriftIdOrThrow(int fieldId) {
4441 _Fields fields = findByThriftId(fieldId);
4442 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4443 return fields;
4444 }
4445
4446
4447
4448
4449 public static _Fields findByName(String name) {
4450 return byName.get(name);
4451 }
4452
4453 private final short _thriftId;
4454 private final String _fieldName;
4455
4456 _Fields(short thriftId, String fieldName) {
4457 _thriftId = thriftId;
4458 _fieldName = fieldName;
4459 }
4460
4461 public short getThriftFieldId() {
4462 return _thriftId;
4463 }
4464
4465 public String getFieldName() {
4466 return _fieldName;
4467 }
4468 }
4469
4470
4471 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4472 static {
4473 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4474 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
4475 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
4476 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
4477 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
4478 metaDataMap = Collections.unmodifiableMap(tmpMap);
4479 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_args.class, metaDataMap);
4480 }
4481
4482 public put_args() {
4483 }
4484
4485 public put_args(
4486 ByteBuffer table,
4487 TPut put)
4488 {
4489 this();
4490 this.table = table;
4491 this.put = put;
4492 }
4493
4494
4495
4496
4497 public put_args(put_args other) {
4498 if (other.isSetTable()) {
4499 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
4500 ;
4501 }
4502 if (other.isSetPut()) {
4503 this.put = new TPut(other.put);
4504 }
4505 }
4506
4507 public put_args deepCopy() {
4508 return new put_args(this);
4509 }
4510
4511 @Override
4512 public void clear() {
4513 this.table = null;
4514 this.put = null;
4515 }
4516
4517
4518
4519
4520 public byte[] getTable() {
4521 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
4522 return table == null ? null : table.array();
4523 }
4524
4525 public ByteBuffer bufferForTable() {
4526 return table;
4527 }
4528
4529
4530
4531
4532 public put_args setTable(byte[] table) {
4533 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
4534 return this;
4535 }
4536
4537 public put_args setTable(ByteBuffer table) {
4538 this.table = table;
4539 return this;
4540 }
4541
4542 public void unsetTable() {
4543 this.table = null;
4544 }
4545
4546
4547 public boolean isSetTable() {
4548 return this.table != null;
4549 }
4550
4551 public void setTableIsSet(boolean value) {
4552 if (!value) {
4553 this.table = null;
4554 }
4555 }
4556
4557
4558
4559
4560 public TPut getPut() {
4561 return this.put;
4562 }
4563
4564
4565
4566
4567 public put_args setPut(TPut put) {
4568 this.put = put;
4569 return this;
4570 }
4571
4572 public void unsetPut() {
4573 this.put = null;
4574 }
4575
4576
4577 public boolean isSetPut() {
4578 return this.put != null;
4579 }
4580
4581 public void setPutIsSet(boolean value) {
4582 if (!value) {
4583 this.put = null;
4584 }
4585 }
4586
4587 public void setFieldValue(_Fields field, Object value) {
4588 switch (field) {
4589 case TABLE:
4590 if (value == null) {
4591 unsetTable();
4592 } else {
4593 setTable((ByteBuffer)value);
4594 }
4595 break;
4596
4597 case PUT:
4598 if (value == null) {
4599 unsetPut();
4600 } else {
4601 setPut((TPut)value);
4602 }
4603 break;
4604
4605 }
4606 }
4607
4608 public Object getFieldValue(_Fields field) {
4609 switch (field) {
4610 case TABLE:
4611 return getTable();
4612
4613 case PUT:
4614 return getPut();
4615
4616 }
4617 throw new IllegalStateException();
4618 }
4619
4620
4621 public boolean isSet(_Fields field) {
4622 if (field == null) {
4623 throw new IllegalArgumentException();
4624 }
4625
4626 switch (field) {
4627 case TABLE:
4628 return isSetTable();
4629 case PUT:
4630 return isSetPut();
4631 }
4632 throw new IllegalStateException();
4633 }
4634
4635 @Override
4636 public boolean equals(Object that) {
4637 if (that == null)
4638 return false;
4639 if (that instanceof put_args)
4640 return this.equals((put_args)that);
4641 return false;
4642 }
4643
4644 public boolean equals(put_args that) {
4645 if (that == null)
4646 return false;
4647
4648 boolean this_present_table = true && this.isSetTable();
4649 boolean that_present_table = true && that.isSetTable();
4650 if (this_present_table || that_present_table) {
4651 if (!(this_present_table && that_present_table))
4652 return false;
4653 if (!this.table.equals(that.table))
4654 return false;
4655 }
4656
4657 boolean this_present_put = true && this.isSetPut();
4658 boolean that_present_put = true && that.isSetPut();
4659 if (this_present_put || that_present_put) {
4660 if (!(this_present_put && that_present_put))
4661 return false;
4662 if (!this.put.equals(that.put))
4663 return false;
4664 }
4665
4666 return true;
4667 }
4668
4669 @Override
4670 public int hashCode() {
4671 return 0;
4672 }
4673
4674 public int compareTo(put_args other) {
4675 if (!getClass().equals(other.getClass())) {
4676 return getClass().getName().compareTo(other.getClass().getName());
4677 }
4678
4679 int lastComparison = 0;
4680 put_args typedOther = (put_args)other;
4681
4682 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
4683 if (lastComparison != 0) {
4684 return lastComparison;
4685 }
4686 if (isSetTable()) {
4687 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
4688 if (lastComparison != 0) {
4689 return lastComparison;
4690 }
4691 }
4692 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
4693 if (lastComparison != 0) {
4694 return lastComparison;
4695 }
4696 if (isSetPut()) {
4697 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
4698 if (lastComparison != 0) {
4699 return lastComparison;
4700 }
4701 }
4702 return 0;
4703 }
4704
4705 public _Fields fieldForId(int fieldId) {
4706 return _Fields.findByThriftId(fieldId);
4707 }
4708
4709 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4710 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4711 }
4712
4713 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4714 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4715 }
4716
4717 @Override
4718 public String toString() {
4719 StringBuilder sb = new StringBuilder("put_args(");
4720 boolean first = true;
4721
4722 sb.append("table:");
4723 if (this.table == null) {
4724 sb.append("null");
4725 } else {
4726 org.apache.thrift.TBaseHelper.toString(this.table, sb);
4727 }
4728 first = false;
4729 if (!first) sb.append(", ");
4730 sb.append("put:");
4731 if (this.put == null) {
4732 sb.append("null");
4733 } else {
4734 sb.append(this.put);
4735 }
4736 first = false;
4737 sb.append(")");
4738 return sb.toString();
4739 }
4740
4741 public void validate() throws org.apache.thrift.TException {
4742
4743 if (table == null) {
4744 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
4745 }
4746 if (put == null) {
4747 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
4748 }
4749
4750 if (put != null) {
4751 put.validate();
4752 }
4753 }
4754
4755 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4756 try {
4757 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4758 } catch (org.apache.thrift.TException te) {
4759 throw new java.io.IOException(te);
4760 }
4761 }
4762
4763 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4764 try {
4765 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4766 } catch (org.apache.thrift.TException te) {
4767 throw new java.io.IOException(te);
4768 }
4769 }
4770
4771 private static class put_argsStandardSchemeFactory implements SchemeFactory {
4772 public put_argsStandardScheme getScheme() {
4773 return new put_argsStandardScheme();
4774 }
4775 }
4776
4777 private static class put_argsStandardScheme extends StandardScheme<put_args> {
4778
4779 public void read(org.apache.thrift.protocol.TProtocol iprot, put_args struct) throws org.apache.thrift.TException {
4780 org.apache.thrift.protocol.TField schemeField;
4781 iprot.readStructBegin();
4782 while (true)
4783 {
4784 schemeField = iprot.readFieldBegin();
4785 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4786 break;
4787 }
4788 switch (schemeField.id) {
4789 case 1:
4790 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
4791 struct.table = iprot.readBinary();
4792 struct.setTableIsSet(true);
4793 } else {
4794 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4795 }
4796 break;
4797 case 2:
4798 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4799 struct.put = new TPut();
4800 struct.put.read(iprot);
4801 struct.setPutIsSet(true);
4802 } else {
4803 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4804 }
4805 break;
4806 default:
4807 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4808 }
4809 iprot.readFieldEnd();
4810 }
4811 iprot.readStructEnd();
4812
4813
4814 struct.validate();
4815 }
4816
4817 public void write(org.apache.thrift.protocol.TProtocol oprot, put_args struct) throws org.apache.thrift.TException {
4818 struct.validate();
4819
4820 oprot.writeStructBegin(STRUCT_DESC);
4821 if (struct.table != null) {
4822 oprot.writeFieldBegin(TABLE_FIELD_DESC);
4823 oprot.writeBinary(struct.table);
4824 oprot.writeFieldEnd();
4825 }
4826 if (struct.put != null) {
4827 oprot.writeFieldBegin(PUT_FIELD_DESC);
4828 struct.put.write(oprot);
4829 oprot.writeFieldEnd();
4830 }
4831 oprot.writeFieldStop();
4832 oprot.writeStructEnd();
4833 }
4834
4835 }
4836
4837 private static class put_argsTupleSchemeFactory implements SchemeFactory {
4838 public put_argsTupleScheme getScheme() {
4839 return new put_argsTupleScheme();
4840 }
4841 }
4842
4843 private static class put_argsTupleScheme extends TupleScheme<put_args> {
4844
4845 @Override
4846 public void write(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4847 TTupleProtocol oprot = (TTupleProtocol) prot;
4848 oprot.writeBinary(struct.table);
4849 struct.put.write(oprot);
4850 }
4851
4852 @Override
4853 public void read(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4854 TTupleProtocol iprot = (TTupleProtocol) prot;
4855 struct.table = iprot.readBinary();
4856 struct.setTableIsSet(true);
4857 struct.put = new TPut();
4858 struct.put.read(iprot);
4859 struct.setPutIsSet(true);
4860 }
4861 }
4862
4863 }
4864
4865 public static class put_result implements org.apache.thrift.TBase<put_result, put_result._Fields>, java.io.Serializable, Cloneable {
4866 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_result");
4867
4868 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);
4869
4870 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4871 static {
4872 schemes.put(StandardScheme.class, new put_resultStandardSchemeFactory());
4873 schemes.put(TupleScheme.class, new put_resultTupleSchemeFactory());
4874 }
4875
4876 public TIOError io;
4877
4878
4879 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4880 IO((short)1, "io");
4881
4882 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4883
4884 static {
4885 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4886 byName.put(field.getFieldName(), field);
4887 }
4888 }
4889
4890
4891
4892
4893 public static _Fields findByThriftId(int fieldId) {
4894 switch(fieldId) {
4895 case 1:
4896 return IO;
4897 default:
4898 return null;
4899 }
4900 }
4901
4902
4903
4904
4905
4906 public static _Fields findByThriftIdOrThrow(int fieldId) {
4907 _Fields fields = findByThriftId(fieldId);
4908 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4909 return fields;
4910 }
4911
4912
4913
4914
4915 public static _Fields findByName(String name) {
4916 return byName.get(name);
4917 }
4918
4919 private final short _thriftId;
4920 private final String _fieldName;
4921
4922 _Fields(short thriftId, String fieldName) {
4923 _thriftId = thriftId;
4924 _fieldName = fieldName;
4925 }
4926
4927 public short getThriftFieldId() {
4928 return _thriftId;
4929 }
4930
4931 public String getFieldName() {
4932 return _fieldName;
4933 }
4934 }
4935
4936
4937 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4938 static {
4939 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4940 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
4941 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
4942 metaDataMap = Collections.unmodifiableMap(tmpMap);
4943 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_result.class, metaDataMap);
4944 }
4945
4946 public put_result() {
4947 }
4948
4949 public put_result(
4950 TIOError io)
4951 {
4952 this();
4953 this.io = io;
4954 }
4955
4956
4957
4958
4959 public put_result(put_result other) {
4960 if (other.isSetIo()) {
4961 this.io = new TIOError(other.io);
4962 }
4963 }
4964
4965 public put_result deepCopy() {
4966 return new put_result(this);
4967 }
4968
4969 @Override
4970 public void clear() {
4971 this.io = null;
4972 }
4973
4974 public TIOError getIo() {
4975 return this.io;
4976 }
4977
4978 public put_result setIo(TIOError io) {
4979 this.io = io;
4980 return this;
4981 }
4982
4983 public void unsetIo() {
4984 this.io = null;
4985 }
4986
4987
4988 public boolean isSetIo() {
4989 return this.io != null;
4990 }
4991
4992 public void setIoIsSet(boolean value) {
4993 if (!value) {
4994 this.io = null;
4995 }
4996 }
4997
4998 public void setFieldValue(_Fields field, Object value) {
4999 switch (field) {
5000 case IO:
5001 if (value == null) {
5002 unsetIo();
5003 } else {
5004 setIo((TIOError)value);
5005 }
5006 break;
5007
5008 }
5009 }
5010
5011 public Object getFieldValue(_Fields field) {
5012 switch (field) {
5013 case IO:
5014 return getIo();
5015
5016 }
5017 throw new IllegalStateException();
5018 }
5019
5020
5021 public boolean isSet(_Fields field) {
5022 if (field == null) {
5023 throw new IllegalArgumentException();
5024 }
5025
5026 switch (field) {
5027 case IO:
5028 return isSetIo();
5029 }
5030 throw new IllegalStateException();
5031 }
5032
5033 @Override
5034 public boolean equals(Object that) {
5035 if (that == null)
5036 return false;
5037 if (that instanceof put_result)
5038 return this.equals((put_result)that);
5039 return false;
5040 }
5041
5042 public boolean equals(put_result that) {
5043 if (that == null)
5044 return false;
5045
5046 boolean this_present_io = true && this.isSetIo();
5047 boolean that_present_io = true && that.isSetIo();
5048 if (this_present_io || that_present_io) {
5049 if (!(this_present_io && that_present_io))
5050 return false;
5051 if (!this.io.equals(that.io))
5052 return false;
5053 }
5054
5055 return true;
5056 }
5057
5058 @Override
5059 public int hashCode() {
5060 return 0;
5061 }
5062
5063 public int compareTo(put_result other) {
5064 if (!getClass().equals(other.getClass())) {
5065 return getClass().getName().compareTo(other.getClass().getName());
5066 }
5067
5068 int lastComparison = 0;
5069 put_result typedOther = (put_result)other;
5070
5071 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
5072 if (lastComparison != 0) {
5073 return lastComparison;
5074 }
5075 if (isSetIo()) {
5076 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
5077 if (lastComparison != 0) {
5078 return lastComparison;
5079 }
5080 }
5081 return 0;
5082 }
5083
5084 public _Fields fieldForId(int fieldId) {
5085 return _Fields.findByThriftId(fieldId);
5086 }
5087
5088 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
5089 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
5090 }
5091
5092 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
5093 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
5094 }
5095
5096 @Override
5097 public String toString() {
5098 StringBuilder sb = new StringBuilder("put_result(");
5099 boolean first = true;
5100
5101 sb.append("io:");
5102 if (this.io == null) {
5103 sb.append("null");
5104 } else {
5105 sb.append(this.io);
5106 }
5107 first = false;
5108 sb.append(")");
5109 return sb.toString();
5110 }
5111
5112 public void validate() throws org.apache.thrift.TException {
5113
5114
5115 }
5116
5117 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
5118 try {
5119 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
5120 } catch (org.apache.thrift.TException te) {
5121 throw new java.io.IOException(te);
5122 }
5123 }
5124
5125 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
5126 try {
5127 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
5128 } catch (org.apache.thrift.TException te) {
5129 throw new java.io.IOException(te);
5130 }
5131 }
5132
5133 private static class put_resultStandardSchemeFactory implements SchemeFactory {
5134 public put_resultStandardScheme getScheme() {
5135 return new put_resultStandardScheme();
5136 }
5137 }
5138
5139 private static class put_resultStandardScheme extends StandardScheme<put_result> {
5140
5141 public void read(org.apache.thrift.protocol.TProtocol iprot, put_result struct) throws org.apache.thrift.TException {
5142 org.apache.thrift.protocol.TField schemeField;
5143 iprot.readStructBegin();
5144 while (true)
5145 {
5146 schemeField = iprot.readFieldBegin();
5147 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
5148 break;
5149 }
5150 switch (schemeField.id) {
5151 case 1:
5152 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
5153 struct.io = new TIOError();
5154 struct.io.read(iprot);
5155 struct.setIoIsSet(true);
5156 } else {
5157 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5158 }
5159 break;
5160 default:
5161 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5162 }
5163 iprot.readFieldEnd();
5164 }
5165 iprot.readStructEnd();
5166
5167
5168 struct.validate();
5169 }
5170
5171 public void write(org.apache.thrift.protocol.TProtocol oprot, put_result struct) throws org.apache.thrift.TException {
5172 struct.validate();
5173
5174 oprot.writeStructBegin(STRUCT_DESC);
5175 if (struct.io != null) {
5176 oprot.writeFieldBegin(IO_FIELD_DESC);
5177 struct.io.write(oprot);
5178 oprot.writeFieldEnd();
5179 }
5180 oprot.writeFieldStop();
5181 oprot.writeStructEnd();
5182 }
5183
5184 }
5185
5186 private static class put_resultTupleSchemeFactory implements SchemeFactory {
5187 public put_resultTupleScheme getScheme() {
5188 return new put_resultTupleScheme();
5189 }
5190 }
5191
5192 private static class put_resultTupleScheme extends TupleScheme<put_result> {
5193
5194 @Override
5195 public void write(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5196 TTupleProtocol oprot = (TTupleProtocol) prot;
5197 BitSet optionals = new BitSet();
5198 if (struct.isSetIo()) {
5199 optionals.set(0);
5200 }
5201 oprot.writeBitSet(optionals, 1);
5202 if (struct.isSetIo()) {
5203 struct.io.write(oprot);
5204 }
5205 }
5206
5207 @Override
5208 public void read(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5209 TTupleProtocol iprot = (TTupleProtocol) prot;
5210 BitSet incoming = iprot.readBitSet(1);
5211 if (incoming.get(0)) {
5212 struct.io = new TIOError();
5213 struct.io.read(iprot);
5214 struct.setIoIsSet(true);
5215 }
5216 }
5217 }
5218
5219 }
5220
5221 public static class checkAndPut_args implements org.apache.thrift.TBase<checkAndPut_args, checkAndPut_args._Fields>, java.io.Serializable, Cloneable {
5222 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_args");
5223
5224 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);
5225 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);
5226 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);
5227 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);
5228 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);
5229 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);
5230
5231 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
5232 static {
5233 schemes.put(StandardScheme.class, new checkAndPut_argsStandardSchemeFactory());
5234 schemes.put(TupleScheme.class, new checkAndPut_argsTupleSchemeFactory());
5235 }
5236
5237
5238
5239
5240 public ByteBuffer table;
5241
5242
5243
5244 public ByteBuffer row;
5245
5246
5247
5248 public ByteBuffer family;
5249
5250
5251
5252 public ByteBuffer qualifier;
5253
5254
5255
5256
5257
5258 public ByteBuffer value;
5259
5260
5261
5262 public TPut put;
5263
5264
5265 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
5266
5267
5268
5269 TABLE((short)1, "table"),
5270
5271
5272
5273 ROW((short)2, "row"),
5274
5275
5276
5277 FAMILY((short)3, "family"),
5278
5279
5280
5281 QUALIFIER((short)4, "qualifier"),
5282
5283
5284
5285
5286
5287 VALUE((short)5, "value"),
5288
5289
5290
5291 PUT((short)6, "put");
5292
5293 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5294
5295 static {
5296 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5297 byName.put(field.getFieldName(), field);
5298 }
5299 }
5300
5301
5302
5303
5304 public static _Fields findByThriftId(int fieldId) {
5305 switch(fieldId) {
5306 case 1:
5307 return TABLE;
5308 case 2:
5309 return ROW;
5310 case 3:
5311 return FAMILY;
5312 case 4:
5313 return QUALIFIER;
5314 case 5:
5315 return VALUE;
5316 case 6:
5317 return PUT;
5318 default:
5319 return null;
5320 }
5321 }
5322
5323
5324
5325
5326
5327 public static _Fields findByThriftIdOrThrow(int fieldId) {
5328 _Fields fields = findByThriftId(fieldId);
5329 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5330 return fields;
5331 }
5332
5333
5334
5335
5336 public static _Fields findByName(String name) {
5337 return byName.get(name);
5338 }
5339
5340 private final short _thriftId;
5341 private final String _fieldName;
5342
5343 _Fields(short thriftId, String fieldName) {
5344 _thriftId = thriftId;
5345 _fieldName = fieldName;
5346 }
5347
5348 public short getThriftFieldId() {
5349 return _thriftId;
5350 }
5351
5352 public String getFieldName() {
5353 return _fieldName;
5354 }
5355 }
5356
5357
5358 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
5359 static {
5360 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
5361 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
5362 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5363 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
5364 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5365 tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
5366 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5367 tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
5368 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5369 tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT,
5370 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5371 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
5372 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
5373 metaDataMap = Collections.unmodifiableMap(tmpMap);
5374 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_args.class, metaDataMap);
5375 }
5376
5377 public checkAndPut_args() {
5378 }
5379
5380 public checkAndPut_args(
5381 ByteBuffer table,
5382 ByteBuffer row,
5383 ByteBuffer family,
5384 ByteBuffer qualifier,
5385 ByteBuffer value,
5386 TPut put)
5387 {
5388 this();
5389 this.table = table;
5390 this.row = row;
5391 this.family = family;
5392 this.qualifier = qualifier;
5393 this.value = value;
5394 this.put = put;
5395 }
5396
5397
5398
5399
5400 public checkAndPut_args(checkAndPut_args other) {
5401 if (other.isSetTable()) {
5402 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
5403 ;
5404 }
5405 if (other.isSetRow()) {
5406 this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
5407 ;
5408 }
5409 if (other.isSetFamily()) {
5410 this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
5411 ;
5412 }
5413 if (other.isSetQualifier()) {
5414 this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
5415 ;
5416 }
5417 if (other.isSetValue()) {
5418 this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
5419 ;
5420 }
5421 if (other.isSetPut()) {
5422 this.put = new TPut(other.put);
5423 }
5424 }
5425
5426 public checkAndPut_args deepCopy() {
5427 return new checkAndPut_args(this);
5428 }
5429
5430 @Override
5431 public void clear() {
5432 this.table = null;
5433 this.row = null;
5434 this.family = null;
5435 this.qualifier = null;
5436 this.value = null;
5437 this.put = null;
5438 }
5439
5440
5441
5442
5443 public byte[] getTable() {
5444 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
5445 return table == null ? null : table.array();
5446 }
5447
5448 public ByteBuffer bufferForTable() {
5449 return table;
5450 }
5451
5452
5453
5454
5455 public checkAndPut_args setTable(byte[] table) {
5456 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
5457 return this;
5458 }
5459
5460 public checkAndPut_args setTable(ByteBuffer table) {
5461 this.table = table;
5462 return this;
5463 }
5464
5465 public void unsetTable() {
5466 this.table = null;
5467 }
5468
5469
5470 public boolean isSetTable() {
5471 return this.table != null;
5472 }
5473
5474 public void setTableIsSet(boolean value) {
5475 if (!value) {
5476 this.table = null;
5477 }
5478 }
5479
5480
5481
5482
5483 public byte[] getRow() {
5484 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
5485 return row == null ? null : row.array();
5486 }
5487
5488 public ByteBuffer bufferForRow() {
5489 return row;
5490 }
5491
5492
5493
5494
5495 public checkAndPut_args setRow(byte[] row) {
5496 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
5497 return this;
5498 }
5499
5500 public checkAndPut_args setRow(ByteBuffer row) {
5501 this.row = row;
5502 return this;
5503 }
5504
5505 public void unsetRow() {
5506 this.row = null;
5507 }
5508
5509
5510 public boolean isSetRow() {
5511 return this.row != null;
5512 }
5513
5514 public void setRowIsSet(boolean value) {
5515 if (!value) {
5516 this.row = null;
5517 }
5518 }
5519
5520
5521
5522
5523 public byte[] getFamily() {
5524 setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
5525 return family == null ? null : family.array();
5526 }
5527
5528 public ByteBuffer bufferForFamily() {
5529 return family;
5530 }
5531
5532
5533
5534
5535 public checkAndPut_args setFamily(byte[] family) {
5536 setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
5537 return this;
5538 }
5539
5540 public checkAndPut_args setFamily(ByteBuffer family) {
5541 this.family = family;
5542 return this;
5543 }
5544
5545 public void unsetFamily() {
5546 this.family = null;
5547 }
5548
5549
5550 public boolean isSetFamily() {
5551 return this.family != null;
5552 }
5553
5554 public void setFamilyIsSet(boolean value) {
5555 if (!value) {
5556 this.family = null;
5557 }
5558 }
5559
5560
5561
5562
5563 public byte[] getQualifier() {
5564 setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
5565 return qualifier == null ? null : qualifier.array();
5566 }
5567
5568 public ByteBuffer bufferForQualifier() {
5569 return qualifier;
5570 }
5571
5572
5573
5574
5575 public checkAndPut_args setQualifier(byte[] qualifier) {
5576 setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
5577 return this;
5578 }
5579
5580 public checkAndPut_args setQualifier(ByteBuffer qualifier) {
5581 this.qualifier = qualifier;
5582 return this;
5583 }
5584
5585 public void unsetQualifier() {
5586 this.qualifier = null;
5587 }
5588
5589
5590 public boolean isSetQualifier() {
5591 return this.qualifier != null;
5592 }
5593
5594 public void setQualifierIsSet(boolean value) {
5595 if (!value) {
5596 this.qualifier = null;
5597 }
5598 }
5599
5600
5601
5602
5603
5604
5605 public byte[] getValue() {
5606 setValue(org.apache.thrift.TBaseHelper.rightSize(value));
5607 return value == null ? null : value.array();
5608 }
5609
5610 public ByteBuffer bufferForValue() {
5611 return value;
5612 }
5613
5614
5615
5616
5617
5618
5619 public checkAndPut_args setValue(byte[] value) {
5620 setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
5621 return this;
5622 }
5623
5624 public checkAndPut_args setValue(ByteBuffer value) {
5625 this.value = value;
5626 return this;
5627 }
5628
5629 public void unsetValue() {
5630 this.value = null;
5631 }
5632
5633
5634 public boolean isSetValue() {
5635 return this.value != null;
5636 }
5637
5638 public void setValueIsSet(boolean value) {
5639 if (!value) {
5640 this.value = null;
5641 }
5642 }
5643
5644
5645
5646
5647 public TPut getPut() {
5648 return this.put;
5649 }
5650
5651
5652
5653
5654 public checkAndPut_args setPut(TPut put) {
5655 this.put = put;
5656 return this;
5657 }
5658
5659 public void unsetPut() {
5660 this.put = null;
5661 }
5662
5663
5664 public boolean isSetPut() {
5665 return this.put != null;
5666 }
5667
5668 public void setPutIsSet(boolean value) {
5669 if (!value) {
5670 this.put = null;
5671 }
5672 }
5673
5674 public void setFieldValue(_Fields field, Object value) {
5675 switch (field) {
5676 case TABLE:
5677 if (value == null) {
5678 unsetTable();
5679 } else {
5680 setTable((ByteBuffer)value);
5681 }
5682 break;
5683
5684 case ROW:
5685 if (value == null) {
5686 unsetRow();
5687 } else {
5688 setRow((ByteBuffer)value);
5689 }
5690 break;
5691
5692 case FAMILY:
5693 if (value == null) {
5694 unsetFamily();
5695 } else {
5696 setFamily((ByteBuffer)value);
5697 }
5698 break;
5699
5700 case QUALIFIER:
5701 if (value == null) {
5702 unsetQualifier();
5703 } else {
5704 setQualifier((ByteBuffer)value);
5705 }
5706 break;
5707
5708 case VALUE:
5709 if (value == null) {
5710 unsetValue();
5711 } else {
5712 setValue((ByteBuffer)value);
5713 }
5714 break;
5715
5716 case PUT:
5717 if (value == null) {
5718 unsetPut();
5719 } else {
5720 setPut((TPut)value);
5721 }
5722 break;
5723
5724 }
5725 }
5726
5727 public Object getFieldValue(_Fields field) {
5728 switch (field) {
5729 case TABLE:
5730 return getTable();
5731
5732 case ROW:
5733 return getRow();
5734
5735 case FAMILY:
5736 return getFamily();
5737
5738 case QUALIFIER:
5739 return getQualifier();
5740
5741 case VALUE:
5742 return getValue();
5743
5744 case PUT:
5745 return getPut();
5746
5747 }
5748 throw new IllegalStateException();
5749 }
5750
5751
5752 public boolean isSet(_Fields field) {
5753 if (field == null) {
5754 throw new IllegalArgumentException();
5755 }
5756
5757 switch (field) {
5758 case TABLE:
5759 return isSetTable();
5760 case ROW:
5761 return isSetRow();
5762 case FAMILY:
5763 return isSetFamily();
5764 case QUALIFIER:
5765 return isSetQualifier();
5766 case VALUE:
5767 return isSetValue();
5768 case PUT:
5769 return isSetPut();
5770 }
5771 throw new IllegalStateException();
5772 }
5773
5774 @Override
5775 public boolean equals(Object that) {
5776 if (that == null)
5777 return false;
5778 if (that instanceof checkAndPut_args)
5779 return this.equals((checkAndPut_args)that);
5780 return false;
5781 }
5782
5783 public boolean equals(checkAndPut_args that) {
5784 if (that == null)
5785 return false;
5786
5787 boolean this_present_table = true && this.isSetTable();
5788 boolean that_present_table = true && that.isSetTable();
5789 if (this_present_table || that_present_table) {
5790 if (!(this_present_table && that_present_table))
5791 return false;
5792 if (!this.table.equals(that.table))
5793 return false;
5794 }
5795
5796 boolean this_present_row = true && this.isSetRow();
5797 boolean that_present_row = true && that.isSetRow();
5798 if (this_present_row || that_present_row) {
5799 if (!(this_present_row && that_present_row))
5800 return false;
5801 if (!this.row.equals(that.row))
5802 return false;
5803 }
5804
5805 boolean this_present_family = true && this.isSetFamily();
5806 boolean that_present_family = true && that.isSetFamily();
5807 if (this_present_family || that_present_family) {
5808 if (!(this_present_family && that_present_family))
5809 return false;
5810 if (!this.family.equals(that.family))
5811 return false;
5812 }
5813
5814 boolean this_present_qualifier = true && this.isSetQualifier();
5815 boolean that_present_qualifier = true && that.isSetQualifier();
5816 if (this_present_qualifier || that_present_qualifier) {
5817 if (!(this_present_qualifier && that_present_qualifier))
5818 return false;
5819 if (!this.qualifier.equals(that.qualifier))
5820 return false;
5821 }
5822
5823 boolean this_present_value = true && this.isSetValue();
5824 boolean that_present_value = true && that.isSetValue();
5825 if (this_present_value || that_present_value) {
5826 if (!(this_present_value && that_present_value))
5827 return false;
5828 if (!this.value.equals(that.value))
5829 return false;
5830 }
5831
5832 boolean this_present_put = true && this.isSetPut();
5833 boolean that_present_put = true && that.isSetPut();
5834 if (this_present_put || that_present_put) {
5835 if (!(this_present_put && that_present_put))
5836 return false;
5837 if (!this.put.equals(that.put))
5838 return false;
5839 }
5840
5841 return true;
5842 }
5843
5844 @Override
5845 public int hashCode() {
5846 return 0;
5847 }
5848
5849 public int compareTo(checkAndPut_args other) {
5850 if (!getClass().equals(other.getClass())) {
5851 return getClass().getName().compareTo(other.getClass().getName());
5852 }
5853
5854 int lastComparison = 0;
5855 checkAndPut_args typedOther = (checkAndPut_args)other;
5856
5857 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
5858 if (lastComparison != 0) {
5859 return lastComparison;
5860 }
5861 if (isSetTable()) {
5862 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
5863 if (lastComparison != 0) {
5864 return lastComparison;
5865 }
5866 }
5867 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
5868 if (lastComparison != 0) {
5869 return lastComparison;
5870 }
5871 if (isSetRow()) {
5872 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
5873 if (lastComparison != 0) {
5874 return lastComparison;
5875 }
5876 }
5877 lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
5878 if (lastComparison != 0) {
5879 return lastComparison;
5880 }
5881 if (isSetFamily()) {
5882 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
5883 if (lastComparison != 0) {
5884 return lastComparison;
5885 }
5886 }
5887 lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
5888 if (lastComparison != 0) {
5889 return lastComparison;
5890 }
5891 if (isSetQualifier()) {
5892 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
5893 if (lastComparison != 0) {
5894 return lastComparison;
5895 }
5896 }
5897 lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
5898 if (lastComparison != 0) {
5899 return lastComparison;
5900 }
5901 if (isSetValue()) {
5902 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
5903 if (lastComparison != 0) {
5904 return lastComparison;
5905 }
5906 }
5907 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
5908 if (lastComparison != 0) {
5909 return lastComparison;
5910 }
5911 if (isSetPut()) {
5912 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
5913 if (lastComparison != 0) {
5914 return lastComparison;
5915 }
5916 }
5917 return 0;
5918 }
5919
5920 public _Fields fieldForId(int fieldId) {
5921 return _Fields.findByThriftId(fieldId);
5922 }
5923
5924 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
5925 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
5926 }
5927
5928 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
5929 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
5930 }
5931
5932 @Override
5933 public String toString() {
5934 StringBuilder sb = new StringBuilder("checkAndPut_args(");
5935 boolean first = true;
5936
5937 sb.append("table:");
5938 if (this.table == null) {
5939 sb.append("null");
5940 } else {
5941 org.apache.thrift.TBaseHelper.toString(this.table, sb);
5942 }
5943 first = false;
5944 if (!first) sb.append(", ");
5945 sb.append("row:");
5946 if (this.row == null) {
5947 sb.append("null");
5948 } else {
5949 org.apache.thrift.TBaseHelper.toString(this.row, sb);
5950 }
5951 first = false;
5952 if (!first) sb.append(", ");
5953 sb.append("family:");
5954 if (this.family == null) {
5955 sb.append("null");
5956 } else {
5957 org.apache.thrift.TBaseHelper.toString(this.family, sb);
5958 }
5959 first = false;
5960 if (!first) sb.append(", ");
5961 sb.append("qualifier:");
5962 if (this.qualifier == null) {
5963 sb.append("null");
5964 } else {
5965 org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
5966 }
5967 first = false;
5968 if (!first) sb.append(", ");
5969 sb.append("value:");
5970 if (this.value == null) {
5971 sb.append("null");
5972 } else {
5973 org.apache.thrift.TBaseHelper.toString(this.value, sb);
5974 }
5975 first = false;
5976 if (!first) sb.append(", ");
5977 sb.append("put:");
5978 if (this.put == null) {
5979 sb.append("null");
5980 } else {
5981 sb.append(this.put);
5982 }
5983 first = false;
5984 sb.append(")");
5985 return sb.toString();
5986 }
5987
5988 public void validate() throws org.apache.thrift.TException {
5989
5990 if (table == null) {
5991 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
5992 }
5993 if (row == null) {
5994 throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
5995 }
5996 if (family == null) {
5997 throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
5998 }
5999 if (qualifier == null) {
6000 throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
6001 }
6002 if (put == null) {
6003 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
6004 }
6005
6006 if (put != null) {
6007 put.validate();
6008 }
6009 }
6010
6011 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6012 try {
6013 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6014 } catch (org.apache.thrift.TException te) {
6015 throw new java.io.IOException(te);
6016 }
6017 }
6018
6019 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6020 try {
6021 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6022 } catch (org.apache.thrift.TException te) {
6023 throw new java.io.IOException(te);
6024 }
6025 }
6026
6027 private static class checkAndPut_argsStandardSchemeFactory implements SchemeFactory {
6028 public checkAndPut_argsStandardScheme getScheme() {
6029 return new checkAndPut_argsStandardScheme();
6030 }
6031 }
6032
6033 private static class checkAndPut_argsStandardScheme extends StandardScheme<checkAndPut_args> {
6034
6035 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6036 org.apache.thrift.protocol.TField schemeField;
6037 iprot.readStructBegin();
6038 while (true)
6039 {
6040 schemeField = iprot.readFieldBegin();
6041 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6042 break;
6043 }
6044 switch (schemeField.id) {
6045 case 1:
6046 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6047 struct.table = iprot.readBinary();
6048 struct.setTableIsSet(true);
6049 } else {
6050 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6051 }
6052 break;
6053 case 2:
6054 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6055 struct.row = iprot.readBinary();
6056 struct.setRowIsSet(true);
6057 } else {
6058 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6059 }
6060 break;
6061 case 3:
6062 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6063 struct.family = iprot.readBinary();
6064 struct.setFamilyIsSet(true);
6065 } else {
6066 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6067 }
6068 break;
6069 case 4:
6070 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6071 struct.qualifier = iprot.readBinary();
6072 struct.setQualifierIsSet(true);
6073 } else {
6074 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6075 }
6076 break;
6077 case 5:
6078 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6079 struct.value = iprot.readBinary();
6080 struct.setValueIsSet(true);
6081 } else {
6082 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6083 }
6084 break;
6085 case 6:
6086 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6087 struct.put = new TPut();
6088 struct.put.read(iprot);
6089 struct.setPutIsSet(true);
6090 } else {
6091 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6092 }
6093 break;
6094 default:
6095 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6096 }
6097 iprot.readFieldEnd();
6098 }
6099 iprot.readStructEnd();
6100
6101
6102 struct.validate();
6103 }
6104
6105 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6106 struct.validate();
6107
6108 oprot.writeStructBegin(STRUCT_DESC);
6109 if (struct.table != null) {
6110 oprot.writeFieldBegin(TABLE_FIELD_DESC);
6111 oprot.writeBinary(struct.table);
6112 oprot.writeFieldEnd();
6113 }
6114 if (struct.row != null) {
6115 oprot.writeFieldBegin(ROW_FIELD_DESC);
6116 oprot.writeBinary(struct.row);
6117 oprot.writeFieldEnd();
6118 }
6119 if (struct.family != null) {
6120 oprot.writeFieldBegin(FAMILY_FIELD_DESC);
6121 oprot.writeBinary(struct.family);
6122 oprot.writeFieldEnd();
6123 }
6124 if (struct.qualifier != null) {
6125 oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
6126 oprot.writeBinary(struct.qualifier);
6127 oprot.writeFieldEnd();
6128 }
6129 if (struct.value != null) {
6130 oprot.writeFieldBegin(VALUE_FIELD_DESC);
6131 oprot.writeBinary(struct.value);
6132 oprot.writeFieldEnd();
6133 }
6134 if (struct.put != null) {
6135 oprot.writeFieldBegin(PUT_FIELD_DESC);
6136 struct.put.write(oprot);
6137 oprot.writeFieldEnd();
6138 }
6139 oprot.writeFieldStop();
6140 oprot.writeStructEnd();
6141 }
6142
6143 }
6144
6145 private static class checkAndPut_argsTupleSchemeFactory implements SchemeFactory {
6146 public checkAndPut_argsTupleScheme getScheme() {
6147 return new checkAndPut_argsTupleScheme();
6148 }
6149 }
6150
6151 private static class checkAndPut_argsTupleScheme extends TupleScheme<checkAndPut_args> {
6152
6153 @Override
6154 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6155 TTupleProtocol oprot = (TTupleProtocol) prot;
6156 oprot.writeBinary(struct.table);
6157 oprot.writeBinary(struct.row);
6158 oprot.writeBinary(struct.family);
6159 oprot.writeBinary(struct.qualifier);
6160 struct.put.write(oprot);
6161 BitSet optionals = new BitSet();
6162 if (struct.isSetValue()) {
6163 optionals.set(0);
6164 }
6165 oprot.writeBitSet(optionals, 1);
6166 if (struct.isSetValue()) {
6167 oprot.writeBinary(struct.value);
6168 }
6169 }
6170
6171 @Override
6172 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6173 TTupleProtocol iprot = (TTupleProtocol) prot;
6174 struct.table = iprot.readBinary();
6175 struct.setTableIsSet(true);
6176 struct.row = iprot.readBinary();
6177 struct.setRowIsSet(true);
6178 struct.family = iprot.readBinary();
6179 struct.setFamilyIsSet(true);
6180 struct.qualifier = iprot.readBinary();
6181 struct.setQualifierIsSet(true);
6182 struct.put = new TPut();
6183 struct.put.read(iprot);
6184 struct.setPutIsSet(true);
6185 BitSet incoming = iprot.readBitSet(1);
6186 if (incoming.get(0)) {
6187 struct.value = iprot.readBinary();
6188 struct.setValueIsSet(true);
6189 }
6190 }
6191 }
6192
6193 }
6194
6195 public static class checkAndPut_result implements org.apache.thrift.TBase<checkAndPut_result, checkAndPut_result._Fields>, java.io.Serializable, Cloneable {
6196 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_result");
6197
6198 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);
6199 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);
6200
6201 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6202 static {
6203 schemes.put(StandardScheme.class, new checkAndPut_resultStandardSchemeFactory());
6204 schemes.put(TupleScheme.class, new checkAndPut_resultTupleSchemeFactory());
6205 }
6206
6207 public boolean success;
6208 public TIOError io;
6209
6210
6211 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6212 SUCCESS((short)0, "success"),
6213 IO((short)1, "io");
6214
6215 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6216
6217 static {
6218 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6219 byName.put(field.getFieldName(), field);
6220 }
6221 }
6222
6223
6224
6225
6226 public static _Fields findByThriftId(int fieldId) {
6227 switch(fieldId) {
6228 case 0:
6229 return SUCCESS;
6230 case 1:
6231 return IO;
6232 default:
6233 return null;
6234 }
6235 }
6236
6237
6238
6239
6240
6241 public static _Fields findByThriftIdOrThrow(int fieldId) {
6242 _Fields fields = findByThriftId(fieldId);
6243 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6244 return fields;
6245 }
6246
6247
6248
6249
6250 public static _Fields findByName(String name) {
6251 return byName.get(name);
6252 }
6253
6254 private final short _thriftId;
6255 private final String _fieldName;
6256
6257 _Fields(short thriftId, String fieldName) {
6258 _thriftId = thriftId;
6259 _fieldName = fieldName;
6260 }
6261
6262 public short getThriftFieldId() {
6263 return _thriftId;
6264 }
6265
6266 public String getFieldName() {
6267 return _fieldName;
6268 }
6269 }
6270
6271
6272 private static final int __SUCCESS_ISSET_ID = 0;
6273 private byte __isset_bitfield = 0;
6274 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6275 static {
6276 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6277 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
6278 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
6279 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
6280 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
6281 metaDataMap = Collections.unmodifiableMap(tmpMap);
6282 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_result.class, metaDataMap);
6283 }
6284
6285 public checkAndPut_result() {
6286 }
6287
6288 public checkAndPut_result(
6289 boolean success,
6290 TIOError io)
6291 {
6292 this();
6293 this.success = success;
6294 setSuccessIsSet(true);
6295 this.io = io;
6296 }
6297
6298
6299
6300
6301 public checkAndPut_result(checkAndPut_result other) {
6302 __isset_bitfield = other.__isset_bitfield;
6303 this.success = other.success;
6304 if (other.isSetIo()) {
6305 this.io = new TIOError(other.io);
6306 }
6307 }
6308
6309 public checkAndPut_result deepCopy() {
6310 return new checkAndPut_result(this);
6311 }
6312
6313 @Override
6314 public void clear() {
6315 setSuccessIsSet(false);
6316 this.success = false;
6317 this.io = null;
6318 }
6319
6320 public boolean isSuccess() {
6321 return this.success;
6322 }
6323
6324 public checkAndPut_result setSuccess(boolean success) {
6325 this.success = success;
6326 setSuccessIsSet(true);
6327 return this;
6328 }
6329
6330 public void unsetSuccess() {
6331 __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
6332 }
6333
6334
6335 public boolean isSetSuccess() {
6336 return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
6337 }
6338
6339 public void setSuccessIsSet(boolean value) {
6340 __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
6341 }
6342
6343 public TIOError getIo() {
6344 return this.io;
6345 }
6346
6347 public checkAndPut_result setIo(TIOError io) {
6348 this.io = io;
6349 return this;
6350 }
6351
6352 public void unsetIo() {
6353 this.io = null;
6354 }
6355
6356
6357 public boolean isSetIo() {
6358 return this.io != null;
6359 }
6360
6361 public void setIoIsSet(boolean value) {
6362 if (!value) {
6363 this.io = null;
6364 }
6365 }
6366
6367 public void setFieldValue(_Fields field, Object value) {
6368 switch (field) {
6369 case SUCCESS:
6370 if (value == null) {
6371 unsetSuccess();
6372 } else {
6373 setSuccess((Boolean)value);
6374 }
6375 break;
6376
6377 case IO:
6378 if (value == null) {
6379 unsetIo();
6380 } else {
6381 setIo((TIOError)value);
6382 }
6383 break;
6384
6385 }
6386 }
6387
6388 public Object getFieldValue(_Fields field) {
6389 switch (field) {
6390 case SUCCESS:
6391 return Boolean.valueOf(isSuccess());
6392
6393 case IO:
6394 return getIo();
6395
6396 }
6397 throw new IllegalStateException();
6398 }
6399
6400
6401 public boolean isSet(_Fields field) {
6402 if (field == null) {
6403 throw new IllegalArgumentException();
6404 }
6405
6406 switch (field) {
6407 case SUCCESS:
6408 return isSetSuccess();
6409 case IO:
6410 return isSetIo();
6411 }
6412 throw new IllegalStateException();
6413 }
6414
6415 @Override
6416 public boolean equals(Object that) {
6417 if (that == null)
6418 return false;
6419 if (that instanceof checkAndPut_result)
6420 return this.equals((checkAndPut_result)that);
6421 return false;
6422 }
6423
6424 public boolean equals(checkAndPut_result that) {
6425 if (that == null)
6426 return false;
6427
6428 boolean this_present_success = true;
6429 boolean that_present_success = true;
6430 if (this_present_success || that_present_success) {
6431 if (!(this_present_success && that_present_success))
6432 return false;
6433 if (this.success != that.success)
6434 return false;
6435 }
6436
6437 boolean this_present_io = true && this.isSetIo();
6438 boolean that_present_io = true && that.isSetIo();
6439 if (this_present_io || that_present_io) {
6440 if (!(this_present_io && that_present_io))
6441 return false;
6442 if (!this.io.equals(that.io))
6443 return false;
6444 }
6445
6446 return true;
6447 }
6448
6449 @Override
6450 public int hashCode() {
6451 return 0;
6452 }
6453
6454 public int compareTo(checkAndPut_result other) {
6455 if (!getClass().equals(other.getClass())) {
6456 return getClass().getName().compareTo(other.getClass().getName());
6457 }
6458
6459 int lastComparison = 0;
6460 checkAndPut_result typedOther = (checkAndPut_result)other;
6461
6462 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
6463 if (lastComparison != 0) {
6464 return lastComparison;
6465 }
6466 if (isSetSuccess()) {
6467 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
6468 if (lastComparison != 0) {
6469 return lastComparison;
6470 }
6471 }
6472 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
6473 if (lastComparison != 0) {
6474 return lastComparison;
6475 }
6476 if (isSetIo()) {
6477 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
6478 if (lastComparison != 0) {
6479 return lastComparison;
6480 }
6481 }
6482 return 0;
6483 }
6484
6485 public _Fields fieldForId(int fieldId) {
6486 return _Fields.findByThriftId(fieldId);
6487 }
6488
6489 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6490 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6491 }
6492
6493 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6494 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6495 }
6496
6497 @Override
6498 public String toString() {
6499 StringBuilder sb = new StringBuilder("checkAndPut_result(");
6500 boolean first = true;
6501
6502 sb.append("success:");
6503 sb.append(this.success);
6504 first = false;
6505 if (!first) sb.append(", ");
6506 sb.append("io:");
6507 if (this.io == null) {
6508 sb.append("null");
6509 } else {
6510 sb.append(this.io);
6511 }
6512 first = false;
6513 sb.append(")");
6514 return sb.toString();
6515 }
6516
6517 public void validate() throws org.apache.thrift.TException {
6518
6519
6520 }
6521
6522 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6523 try {
6524 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6525 } catch (org.apache.thrift.TException te) {
6526 throw new java.io.IOException(te);
6527 }
6528 }
6529
6530 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6531 try {
6532
6533 __isset_bitfield = 0;
6534 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6535 } catch (org.apache.thrift.TException te) {
6536 throw new java.io.IOException(te);
6537 }
6538 }
6539
6540 private static class checkAndPut_resultStandardSchemeFactory implements SchemeFactory {
6541 public checkAndPut_resultStandardScheme getScheme() {
6542 return new checkAndPut_resultStandardScheme();
6543 }
6544 }
6545
6546 private static class checkAndPut_resultStandardScheme extends StandardScheme<checkAndPut_result> {
6547
6548 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6549 org.apache.thrift.protocol.TField schemeField;
6550 iprot.readStructBegin();
6551 while (true)
6552 {
6553 schemeField = iprot.readFieldBegin();
6554 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6555 break;
6556 }
6557 switch (schemeField.id) {
6558 case 0:
6559 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
6560 struct.success = iprot.readBool();
6561 struct.setSuccessIsSet(true);
6562 } else {
6563 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6564 }
6565 break;
6566 case 1:
6567 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6568 struct.io = new TIOError();
6569 struct.io.read(iprot);
6570 struct.setIoIsSet(true);
6571 } else {
6572 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6573 }
6574 break;
6575 default:
6576 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6577 }
6578 iprot.readFieldEnd();
6579 }
6580 iprot.readStructEnd();
6581
6582
6583 struct.validate();
6584 }
6585
6586 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6587 struct.validate();
6588
6589 oprot.writeStructBegin(STRUCT_DESC);
6590 if (struct.isSetSuccess()) {
6591 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6592 oprot.writeBool(struct.success);
6593 oprot.writeFieldEnd();
6594 }
6595 if (struct.io != null) {
6596 oprot.writeFieldBegin(IO_FIELD_DESC);
6597 struct.io.write(oprot);
6598 oprot.writeFieldEnd();
6599 }
6600 oprot.writeFieldStop();
6601 oprot.writeStructEnd();
6602 }
6603
6604 }
6605
6606 private static class checkAndPut_resultTupleSchemeFactory implements SchemeFactory {
6607 public checkAndPut_resultTupleScheme getScheme() {
6608 return new checkAndPut_resultTupleScheme();
6609 }
6610 }
6611
6612 private static class checkAndPut_resultTupleScheme extends TupleScheme<checkAndPut_result> {
6613
6614 @Override
6615 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6616 TTupleProtocol oprot = (TTupleProtocol) prot;
6617 BitSet optionals = new BitSet();
6618 if (struct.isSetSuccess()) {
6619 optionals.set(0);
6620 }
6621 if (struct.isSetIo()) {
6622 optionals.set(1);
6623 }
6624 oprot.writeBitSet(optionals, 2);
6625 if (struct.isSetSuccess()) {
6626 oprot.writeBool(struct.success);
6627 }
6628 if (struct.isSetIo()) {
6629 struct.io.write(oprot);
6630 }
6631 }
6632
6633 @Override
6634 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6635 TTupleProtocol iprot = (TTupleProtocol) prot;
6636 BitSet incoming = iprot.readBitSet(2);
6637 if (incoming.get(0)) {
6638 struct.success = iprot.readBool();
6639 struct.setSuccessIsSet(true);
6640 }
6641 if (incoming.get(1)) {
6642 struct.io = new TIOError();
6643 struct.io.read(iprot);
6644 struct.setIoIsSet(true);
6645 }
6646 }
6647 }
6648
6649 }
6650
6651 public static class putMultiple_args implements org.apache.thrift.TBase<putMultiple_args, putMultiple_args._Fields>, java.io.Serializable, Cloneable {
6652 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_args");
6653
6654 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);
6655 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);
6656
6657 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6658 static {
6659 schemes.put(StandardScheme.class, new putMultiple_argsStandardSchemeFactory());
6660 schemes.put(TupleScheme.class, new putMultiple_argsTupleSchemeFactory());
6661 }
6662
6663
6664
6665
6666 public ByteBuffer table;
6667
6668
6669
6670 public List<TPut> puts;
6671
6672
6673 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6674
6675
6676
6677 TABLE((short)1, "table"),
6678
6679
6680
6681 PUTS((short)2, "puts");
6682
6683 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6684
6685 static {
6686 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6687 byName.put(field.getFieldName(), field);
6688 }
6689 }
6690
6691
6692
6693
6694 public static _Fields findByThriftId(int fieldId) {
6695 switch(fieldId) {
6696 case 1:
6697 return TABLE;
6698 case 2:
6699 return PUTS;
6700 default:
6701 return null;
6702 }
6703 }
6704
6705
6706
6707
6708
6709 public static _Fields findByThriftIdOrThrow(int fieldId) {
6710 _Fields fields = findByThriftId(fieldId);
6711 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6712 return fields;
6713 }
6714
6715
6716
6717
6718 public static _Fields findByName(String name) {
6719 return byName.get(name);
6720 }
6721
6722 private final short _thriftId;
6723 private final String _fieldName;
6724
6725 _Fields(short thriftId, String fieldName) {
6726 _thriftId = thriftId;
6727 _fieldName = fieldName;
6728 }
6729
6730 public short getThriftFieldId() {
6731 return _thriftId;
6732 }
6733
6734 public String getFieldName() {
6735 return _fieldName;
6736 }
6737 }
6738
6739
6740 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6741 static {
6742 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6743 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
6744 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
6745 tmpMap.put(_Fields.PUTS, new org.apache.thrift.meta_data.FieldMetaData("puts", org.apache.thrift.TFieldRequirementType.REQUIRED,
6746 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
6747 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class))));
6748 metaDataMap = Collections.unmodifiableMap(tmpMap);
6749 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_args.class, metaDataMap);
6750 }
6751
6752 public putMultiple_args() {
6753 }
6754
6755 public putMultiple_args(
6756 ByteBuffer table,
6757 List<TPut> puts)
6758 {
6759 this();
6760 this.table = table;
6761 this.puts = puts;
6762 }
6763
6764
6765
6766
6767 public putMultiple_args(putMultiple_args other) {
6768 if (other.isSetTable()) {
6769 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
6770 ;
6771 }
6772 if (other.isSetPuts()) {
6773 List<TPut> __this__puts = new ArrayList<TPut>();
6774 for (TPut other_element : other.puts) {
6775 __this__puts.add(new TPut(other_element));
6776 }
6777 this.puts = __this__puts;
6778 }
6779 }
6780
6781 public putMultiple_args deepCopy() {
6782 return new putMultiple_args(this);
6783 }
6784
6785 @Override
6786 public void clear() {
6787 this.table = null;
6788 this.puts = null;
6789 }
6790
6791
6792
6793
6794 public byte[] getTable() {
6795 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
6796 return table == null ? null : table.array();
6797 }
6798
6799 public ByteBuffer bufferForTable() {
6800 return table;
6801 }
6802
6803
6804
6805
6806 public putMultiple_args setTable(byte[] table) {
6807 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
6808 return this;
6809 }
6810
6811 public putMultiple_args setTable(ByteBuffer table) {
6812 this.table = table;
6813 return this;
6814 }
6815
6816 public void unsetTable() {
6817 this.table = null;
6818 }
6819
6820
6821 public boolean isSetTable() {
6822 return this.table != null;
6823 }
6824
6825 public void setTableIsSet(boolean value) {
6826 if (!value) {
6827 this.table = null;
6828 }
6829 }
6830
6831 public int getPutsSize() {
6832 return (this.puts == null) ? 0 : this.puts.size();
6833 }
6834
6835 public java.util.Iterator<TPut> getPutsIterator() {
6836 return (this.puts == null) ? null : this.puts.iterator();
6837 }
6838
6839 public void addToPuts(TPut elem) {
6840 if (this.puts == null) {
6841 this.puts = new ArrayList<TPut>();
6842 }
6843 this.puts.add(elem);
6844 }
6845
6846
6847
6848
6849 public List<TPut> getPuts() {
6850 return this.puts;
6851 }
6852
6853
6854
6855
6856 public putMultiple_args setPuts(List<TPut> puts) {
6857 this.puts = puts;
6858 return this;
6859 }
6860
6861 public void unsetPuts() {
6862 this.puts = null;
6863 }
6864
6865
6866 public boolean isSetPuts() {
6867 return this.puts != null;
6868 }
6869
6870 public void setPutsIsSet(boolean value) {
6871 if (!value) {
6872 this.puts = null;
6873 }
6874 }
6875
6876 public void setFieldValue(_Fields field, Object value) {
6877 switch (field) {
6878 case TABLE:
6879 if (value == null) {
6880 unsetTable();
6881 } else {
6882 setTable((ByteBuffer)value);
6883 }
6884 break;
6885
6886 case PUTS:
6887 if (value == null) {
6888 unsetPuts();
6889 } else {
6890 setPuts((List<TPut>)value);
6891 }
6892 break;
6893
6894 }
6895 }
6896
6897 public Object getFieldValue(_Fields field) {
6898 switch (field) {
6899 case TABLE:
6900 return getTable();
6901
6902 case PUTS:
6903 return getPuts();
6904
6905 }
6906 throw new IllegalStateException();
6907 }
6908
6909
6910 public boolean isSet(_Fields field) {
6911 if (field == null) {
6912 throw new IllegalArgumentException();
6913 }
6914
6915 switch (field) {
6916 case TABLE:
6917 return isSetTable();
6918 case PUTS:
6919 return isSetPuts();
6920 }
6921 throw new IllegalStateException();
6922 }
6923
6924 @Override
6925 public boolean equals(Object that) {
6926 if (that == null)
6927 return false;
6928 if (that instanceof putMultiple_args)
6929 return this.equals((putMultiple_args)that);
6930 return false;
6931 }
6932
6933 public boolean equals(putMultiple_args that) {
6934 if (that == null)
6935 return false;
6936
6937 boolean this_present_table = true && this.isSetTable();
6938 boolean that_present_table = true && that.isSetTable();
6939 if (this_present_table || that_present_table) {
6940 if (!(this_present_table && that_present_table))
6941 return false;
6942 if (!this.table.equals(that.table))
6943 return false;
6944 }
6945
6946 boolean this_present_puts = true && this.isSetPuts();
6947 boolean that_present_puts = true && that.isSetPuts();
6948 if (this_present_puts || that_present_puts) {
6949 if (!(this_present_puts && that_present_puts))
6950 return false;
6951 if (!this.puts.equals(that.puts))
6952 return false;
6953 }
6954
6955 return true;
6956 }
6957
6958 @Override
6959 public int hashCode() {
6960 return 0;
6961 }
6962
6963 public int compareTo(putMultiple_args other) {
6964 if (!getClass().equals(other.getClass())) {
6965 return getClass().getName().compareTo(other.getClass().getName());
6966 }
6967
6968 int lastComparison = 0;
6969 putMultiple_args typedOther = (putMultiple_args)other;
6970
6971 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
6972 if (lastComparison != 0) {
6973 return lastComparison;
6974 }
6975 if (isSetTable()) {
6976 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
6977 if (lastComparison != 0) {
6978 return lastComparison;
6979 }
6980 }
6981 lastComparison = Boolean.valueOf(isSetPuts()).compareTo(typedOther.isSetPuts());
6982 if (lastComparison != 0) {
6983 return lastComparison;
6984 }
6985 if (isSetPuts()) {
6986 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.puts, typedOther.puts);
6987 if (lastComparison != 0) {
6988 return lastComparison;
6989 }
6990 }
6991 return 0;
6992 }
6993
6994 public _Fields fieldForId(int fieldId) {
6995 return _Fields.findByThriftId(fieldId);
6996 }
6997
6998 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6999 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7000 }
7001
7002 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7003 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7004 }
7005
7006 @Override
7007 public String toString() {
7008 StringBuilder sb = new StringBuilder("putMultiple_args(");
7009 boolean first = true;
7010
7011 sb.append("table:");
7012 if (this.table == null) {
7013 sb.append("null");
7014 } else {
7015 org.apache.thrift.TBaseHelper.toString(this.table, sb);
7016 }
7017 first = false;
7018 if (!first) sb.append(", ");
7019 sb.append("puts:");
7020 if (this.puts == null) {
7021 sb.append("null");
7022 } else {
7023 sb.append(this.puts);
7024 }
7025 first = false;
7026 sb.append(")");
7027 return sb.toString();
7028 }
7029
7030 public void validate() throws org.apache.thrift.TException {
7031
7032 if (table == null) {
7033 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
7034 }
7035 if (puts == null) {
7036 throw new org.apache.thrift.protocol.TProtocolException("Required field 'puts' was not present! Struct: " + toString());
7037 }
7038
7039 }
7040
7041 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7042 try {
7043 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7044 } catch (org.apache.thrift.TException te) {
7045 throw new java.io.IOException(te);
7046 }
7047 }
7048
7049 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7050 try {
7051 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7052 } catch (org.apache.thrift.TException te) {
7053 throw new java.io.IOException(te);
7054 }
7055 }
7056
7057 private static class putMultiple_argsStandardSchemeFactory implements SchemeFactory {
7058 public putMultiple_argsStandardScheme getScheme() {
7059 return new putMultiple_argsStandardScheme();
7060 }
7061 }
7062
7063 private static class putMultiple_argsStandardScheme extends StandardScheme<putMultiple_args> {
7064
7065 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_args struct) throws org.apache.thrift.TException {
7066 org.apache.thrift.protocol.TField schemeField;
7067 iprot.readStructBegin();
7068 while (true)
7069 {
7070 schemeField = iprot.readFieldBegin();
7071 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7072 break;
7073 }
7074 switch (schemeField.id) {
7075 case 1:
7076 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
7077 struct.table = iprot.readBinary();
7078 struct.setTableIsSet(true);
7079 } else {
7080 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7081 }
7082 break;
7083 case 2:
7084 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
7085 {
7086 org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
7087 struct.puts = new ArrayList<TPut>(_list64.size);
7088 for (int _i65 = 0; _i65 < _list64.size; ++_i65)
7089 {
7090 TPut _elem66;
7091 _elem66 = new TPut();
7092 _elem66.read(iprot);
7093 struct.puts.add(_elem66);
7094 }
7095 iprot.readListEnd();
7096 }
7097 struct.setPutsIsSet(true);
7098 } else {
7099 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7100 }
7101 break;
7102 default:
7103 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7104 }
7105 iprot.readFieldEnd();
7106 }
7107 iprot.readStructEnd();
7108
7109
7110 struct.validate();
7111 }
7112
7113 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_args struct) throws org.apache.thrift.TException {
7114 struct.validate();
7115
7116 oprot.writeStructBegin(STRUCT_DESC);
7117 if (struct.table != null) {
7118 oprot.writeFieldBegin(TABLE_FIELD_DESC);
7119 oprot.writeBinary(struct.table);
7120 oprot.writeFieldEnd();
7121 }
7122 if (struct.puts != null) {
7123 oprot.writeFieldBegin(PUTS_FIELD_DESC);
7124 {
7125 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.puts.size()));
7126 for (TPut _iter67 : struct.puts)
7127 {
7128 _iter67.write(oprot);
7129 }
7130 oprot.writeListEnd();
7131 }
7132 oprot.writeFieldEnd();
7133 }
7134 oprot.writeFieldStop();
7135 oprot.writeStructEnd();
7136 }
7137
7138 }
7139
7140 private static class putMultiple_argsTupleSchemeFactory implements SchemeFactory {
7141 public putMultiple_argsTupleScheme getScheme() {
7142 return new putMultiple_argsTupleScheme();
7143 }
7144 }
7145
7146 private static class putMultiple_argsTupleScheme extends TupleScheme<putMultiple_args> {
7147
7148 @Override
7149 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7150 TTupleProtocol oprot = (TTupleProtocol) prot;
7151 oprot.writeBinary(struct.table);
7152 {
7153 oprot.writeI32(struct.puts.size());
7154 for (TPut _iter68 : struct.puts)
7155 {
7156 _iter68.write(oprot);
7157 }
7158 }
7159 }
7160
7161 @Override
7162 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7163 TTupleProtocol iprot = (TTupleProtocol) prot;
7164 struct.table = iprot.readBinary();
7165 struct.setTableIsSet(true);
7166 {
7167 org.apache.thrift.protocol.TList _list69 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
7168 struct.puts = new ArrayList<TPut>(_list69.size);
7169 for (int _i70 = 0; _i70 < _list69.size; ++_i70)
7170 {
7171 TPut _elem71;
7172 _elem71 = new TPut();
7173 _elem71.read(iprot);
7174 struct.puts.add(_elem71);
7175 }
7176 }
7177 struct.setPutsIsSet(true);
7178 }
7179 }
7180
7181 }
7182
7183 public static class putMultiple_result implements org.apache.thrift.TBase<putMultiple_result, putMultiple_result._Fields>, java.io.Serializable, Cloneable {
7184 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_result");
7185
7186 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);
7187
7188 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7189 static {
7190 schemes.put(StandardScheme.class, new putMultiple_resultStandardSchemeFactory());
7191 schemes.put(TupleScheme.class, new putMultiple_resultTupleSchemeFactory());
7192 }
7193
7194 public TIOError io;
7195
7196
7197 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7198 IO((short)1, "io");
7199
7200 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7201
7202 static {
7203 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7204 byName.put(field.getFieldName(), field);
7205 }
7206 }
7207
7208
7209
7210
7211 public static _Fields findByThriftId(int fieldId) {
7212 switch(fieldId) {
7213 case 1:
7214 return IO;
7215 default:
7216 return null;
7217 }
7218 }
7219
7220
7221
7222
7223
7224 public static _Fields findByThriftIdOrThrow(int fieldId) {
7225 _Fields fields = findByThriftId(fieldId);
7226 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7227 return fields;
7228 }
7229
7230
7231
7232
7233 public static _Fields findByName(String name) {
7234 return byName.get(name);
7235 }
7236
7237 private final short _thriftId;
7238 private final String _fieldName;
7239
7240 _Fields(short thriftId, String fieldName) {
7241 _thriftId = thriftId;
7242 _fieldName = fieldName;
7243 }
7244
7245 public short getThriftFieldId() {
7246 return _thriftId;
7247 }
7248
7249 public String getFieldName() {
7250 return _fieldName;
7251 }
7252 }
7253
7254
7255 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7256 static {
7257 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7258 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
7259 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
7260 metaDataMap = Collections.unmodifiableMap(tmpMap);
7261 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_result.class, metaDataMap);
7262 }
7263
7264 public putMultiple_result() {
7265 }
7266
7267 public putMultiple_result(
7268 TIOError io)
7269 {
7270 this();
7271 this.io = io;
7272 }
7273
7274
7275
7276
7277 public putMultiple_result(putMultiple_result other) {
7278 if (other.isSetIo()) {
7279 this.io = new TIOError(other.io);
7280 }
7281 }
7282
7283 public putMultiple_result deepCopy() {
7284 return new putMultiple_result(this);
7285 }
7286
7287 @Override
7288 public void clear() {
7289 this.io = null;
7290 }
7291
7292 public TIOError getIo() {
7293 return this.io;
7294 }
7295
7296 public putMultiple_result setIo(TIOError io) {
7297 this.io = io;
7298 return this;
7299 }
7300
7301 public void unsetIo() {
7302 this.io = null;
7303 }
7304
7305
7306 public boolean isSetIo() {
7307 return this.io != null;
7308 }
7309
7310 public void setIoIsSet(boolean value) {
7311 if (!value) {
7312 this.io = null;
7313 }
7314 }
7315
7316 public void setFieldValue(_Fields field, Object value) {
7317 switch (field) {
7318 case IO:
7319 if (value == null) {
7320 unsetIo();
7321 } else {
7322 setIo((TIOError)value);
7323 }
7324 break;
7325
7326 }
7327 }
7328
7329 public Object getFieldValue(_Fields field) {
7330 switch (field) {
7331 case IO:
7332 return getIo();
7333
7334 }
7335 throw new IllegalStateException();
7336 }
7337
7338
7339 public boolean isSet(_Fields field) {
7340 if (field == null) {
7341 throw new IllegalArgumentException();
7342 }
7343
7344 switch (field) {
7345 case IO:
7346 return isSetIo();
7347 }
7348 throw new IllegalStateException();
7349 }
7350
7351 @Override
7352 public boolean equals(Object that) {
7353 if (that == null)
7354 return false;
7355 if (that instanceof putMultiple_result)
7356 return this.equals((putMultiple_result)that);
7357 return false;
7358 }
7359
7360 public boolean equals(putMultiple_result that) {
7361 if (that == null)
7362 return false;
7363
7364 boolean this_present_io = true && this.isSetIo();
7365 boolean that_present_io = true && that.isSetIo();
7366 if (this_present_io || that_present_io) {
7367 if (!(this_present_io && that_present_io))
7368 return false;
7369 if (!this.io.equals(that.io))
7370 return false;
7371 }
7372
7373 return true;
7374 }
7375
7376 @Override
7377 public int hashCode() {
7378 return 0;
7379 }
7380
7381 public int compareTo(putMultiple_result other) {
7382 if (!getClass().equals(other.getClass())) {
7383 return getClass().getName().compareTo(other.getClass().getName());
7384 }
7385
7386 int lastComparison = 0;
7387 putMultiple_result typedOther = (putMultiple_result)other;
7388
7389 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
7390 if (lastComparison != 0) {
7391 return lastComparison;
7392 }
7393 if (isSetIo()) {
7394 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
7395 if (lastComparison != 0) {
7396 return lastComparison;
7397 }
7398 }
7399 return 0;
7400 }
7401
7402 public _Fields fieldForId(int fieldId) {
7403 return _Fields.findByThriftId(fieldId);
7404 }
7405
7406 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7407 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7408 }
7409
7410 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7411 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7412 }
7413
7414 @Override
7415 public String toString() {
7416 StringBuilder sb = new StringBuilder("putMultiple_result(");
7417 boolean first = true;
7418
7419 sb.append("io:");
7420 if (this.io == null) {
7421 sb.append("null");
7422 } else {
7423 sb.append(this.io);
7424 }
7425 first = false;
7426 sb.append(")");
7427 return sb.toString();
7428 }
7429
7430 public void validate() throws org.apache.thrift.TException {
7431
7432
7433 }
7434
7435 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7436 try {
7437 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7438 } catch (org.apache.thrift.TException te) {
7439 throw new java.io.IOException(te);
7440 }
7441 }
7442
7443 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7444 try {
7445 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7446 } catch (org.apache.thrift.TException te) {
7447 throw new java.io.IOException(te);
7448 }
7449 }
7450
7451 private static class putMultiple_resultStandardSchemeFactory implements SchemeFactory {
7452 public putMultiple_resultStandardScheme getScheme() {
7453 return new putMultiple_resultStandardScheme();
7454 }
7455 }
7456
7457 private static class putMultiple_resultStandardScheme extends StandardScheme<putMultiple_result> {
7458
7459 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_result struct) throws org.apache.thrift.TException {
7460 org.apache.thrift.protocol.TField schemeField;
7461 iprot.readStructBegin();
7462 while (true)
7463 {
7464 schemeField = iprot.readFieldBegin();
7465 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7466 break;
7467 }
7468 switch (schemeField.id) {
7469 case 1:
7470 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
7471 struct.io = new TIOError();
7472 struct.io.read(iprot);
7473 struct.setIoIsSet(true);
7474 } else {
7475 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7476 }
7477 break;
7478 default:
7479 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7480 }
7481 iprot.readFieldEnd();
7482 }
7483 iprot.readStructEnd();
7484
7485
7486 struct.validate();
7487 }
7488
7489 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_result struct) throws org.apache.thrift.TException {
7490 struct.validate();
7491
7492 oprot.writeStructBegin(STRUCT_DESC);
7493 if (struct.io != null) {
7494 oprot.writeFieldBegin(IO_FIELD_DESC);
7495 struct.io.write(oprot);
7496 oprot.writeFieldEnd();
7497 }
7498 oprot.writeFieldStop();
7499 oprot.writeStructEnd();
7500 }
7501
7502 }
7503
7504 private static class putMultiple_resultTupleSchemeFactory implements SchemeFactory {
7505 public putMultiple_resultTupleScheme getScheme() {
7506 return new putMultiple_resultTupleScheme();
7507 }
7508 }
7509
7510 private static class putMultiple_resultTupleScheme extends TupleScheme<putMultiple_result> {
7511
7512 @Override
7513 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7514 TTupleProtocol oprot = (TTupleProtocol) prot;
7515 BitSet optionals = new BitSet();
7516 if (struct.isSetIo()) {
7517 optionals.set(0);
7518 }
7519 oprot.writeBitSet(optionals, 1);
7520 if (struct.isSetIo()) {
7521 struct.io.write(oprot);
7522 }
7523 }
7524
7525 @Override
7526 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7527 TTupleProtocol iprot = (TTupleProtocol) prot;
7528 BitSet incoming = iprot.readBitSet(1);
7529 if (incoming.get(0)) {
7530 struct.io = new TIOError();
7531 struct.io.read(iprot);
7532 struct.setIoIsSet(true);
7533 }
7534 }
7535 }
7536
7537 }
7538
7539 public static class deleteSingle_args implements org.apache.thrift.TBase<deleteSingle_args, deleteSingle_args._Fields>, java.io.Serializable, Cloneable {
7540 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_args");
7541
7542 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);
7543 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);
7544
7545 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7546 static {
7547 schemes.put(StandardScheme.class, new deleteSingle_argsStandardSchemeFactory());
7548 schemes.put(TupleScheme.class, new deleteSingle_argsTupleSchemeFactory());
7549 }
7550
7551
7552
7553
7554 public ByteBuffer table;
7555
7556
7557
7558 public