1
2
3
4
5
6
7 package org.apache.hadoop.hbase.thrift2.generated;
8
9 import org.apache.thrift.scheme.IScheme;
10 import org.apache.thrift.scheme.SchemeFactory;
11 import org.apache.thrift.scheme.StandardScheme;
12
13 import org.apache.thrift.scheme.TupleScheme;
14 import org.apache.thrift.protocol.TTupleProtocol;
15 import java.util.List;
16 import java.util.ArrayList;
17 import java.util.Map;
18 import java.util.HashMap;
19 import java.util.EnumMap;
20 import java.util.Set;
21 import java.util.HashSet;
22 import java.util.EnumSet;
23 import java.util.Collections;
24 import java.util.BitSet;
25 import java.nio.ByteBuffer;
26 import java.util.Arrays;
27 import org.slf4j.Logger;
28 import org.slf4j.LoggerFactory;
29
30 public class THBaseService {
31
32 public interface Iface {
33
34
35
36
37
38
39
40
41
42
43 public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
44
45
46
47
48
49
50
51
52
53
54
55
56
57 public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74 public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException;
75
76
77
78
79
80
81
82
83 public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException;
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105 public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException;
106
107
108
109
110
111
112
113
114 public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException;
115
116
117
118
119
120
121
122
123
124
125
126 public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
127
128
129
130
131
132
133
134
135
136
137
138
139 public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException;
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161 public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
162
163 public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException;
164
165
166
167
168
169
170
171
172
173
174 public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException;
175
176
177
178
179
180
181
182
183
184
185 public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
186
187
188
189
190
191
192
193
194
195 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
196
197 }
198
199 public interface AsyncIface {
200
201 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.exists_call> resultHandler) throws org.apache.thrift.TException;
202
203 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.get_call> resultHandler) throws org.apache.thrift.TException;
204
205 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getMultiple_call> resultHandler) throws org.apache.thrift.TException;
206
207 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.put_call> resultHandler) throws org.apache.thrift.TException;
208
209 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;
210
211 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.putMultiple_call> resultHandler) throws org.apache.thrift.TException;
212
213 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteSingle_call> resultHandler) throws org.apache.thrift.TException;
214
215 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteMultiple_call> resultHandler) throws org.apache.thrift.TException;
216
217 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;
218
219 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.increment_call> resultHandler) throws org.apache.thrift.TException;
220
221 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.openScanner_call> resultHandler) throws org.apache.thrift.TException;
222
223 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getScannerRows_call> resultHandler) throws org.apache.thrift.TException;
224
225 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeScanner_call> resultHandler) throws org.apache.thrift.TException;
226
227 }
228
229 public static class Client extends org.apache.thrift.TServiceClient implements Iface {
230 public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
231 public Factory() {}
232 public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
233 return new Client(prot);
234 }
235 public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
236 return new Client(iprot, oprot);
237 }
238 }
239
240 public Client(org.apache.thrift.protocol.TProtocol prot)
241 {
242 super(prot, prot);
243 }
244
245 public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
246 super(iprot, oprot);
247 }
248
249 public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
250 {
251 send_exists(table, get);
252 return recv_exists();
253 }
254
255 public void send_exists(ByteBuffer table, TGet get) throws org.apache.thrift.TException
256 {
257 exists_args args = new exists_args();
258 args.setTable(table);
259 args.setGet(get);
260 sendBase("exists", args);
261 }
262
263 public boolean recv_exists() throws TIOError, org.apache.thrift.TException
264 {
265 exists_result result = new exists_result();
266 receiveBase(result, "exists");
267 if (result.isSetSuccess()) {
268 return result.success;
269 }
270 if (result.io != null) {
271 throw result.io;
272 }
273 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "exists failed: unknown result");
274 }
275
276 public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
277 {
278 send_get(table, get);
279 return recv_get();
280 }
281
282 public void send_get(ByteBuffer table, TGet get) throws org.apache.thrift.TException
283 {
284 get_args args = new get_args();
285 args.setTable(table);
286 args.setGet(get);
287 sendBase("get", args);
288 }
289
290 public TResult recv_get() throws TIOError, org.apache.thrift.TException
291 {
292 get_result result = new get_result();
293 receiveBase(result, "get");
294 if (result.isSetSuccess()) {
295 return result.success;
296 }
297 if (result.io != null) {
298 throw result.io;
299 }
300 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get failed: unknown result");
301 }
302
303 public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException
304 {
305 send_getMultiple(table, gets);
306 return recv_getMultiple();
307 }
308
309 public void send_getMultiple(ByteBuffer table, List<TGet> gets) throws org.apache.thrift.TException
310 {
311 getMultiple_args args = new getMultiple_args();
312 args.setTable(table);
313 args.setGets(gets);
314 sendBase("getMultiple", args);
315 }
316
317 public List<TResult> recv_getMultiple() throws TIOError, org.apache.thrift.TException
318 {
319 getMultiple_result result = new getMultiple_result();
320 receiveBase(result, "getMultiple");
321 if (result.isSetSuccess()) {
322 return result.success;
323 }
324 if (result.io != null) {
325 throw result.io;
326 }
327 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getMultiple failed: unknown result");
328 }
329
330 public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException
331 {
332 send_put(table, put);
333 recv_put();
334 }
335
336 public void send_put(ByteBuffer table, TPut put) throws org.apache.thrift.TException
337 {
338 put_args args = new put_args();
339 args.setTable(table);
340 args.setPut(put);
341 sendBase("put", args);
342 }
343
344 public void recv_put() throws TIOError, org.apache.thrift.TException
345 {
346 put_result result = new put_result();
347 receiveBase(result, "put");
348 if (result.io != null) {
349 throw result.io;
350 }
351 return;
352 }
353
354 public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException
355 {
356 send_checkAndPut(table, row, family, qualifier, value, put);
357 return recv_checkAndPut();
358 }
359
360 public void send_checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws org.apache.thrift.TException
361 {
362 checkAndPut_args args = new checkAndPut_args();
363 args.setTable(table);
364 args.setRow(row);
365 args.setFamily(family);
366 args.setQualifier(qualifier);
367 args.setValue(value);
368 args.setPut(put);
369 sendBase("checkAndPut", args);
370 }
371
372 public boolean recv_checkAndPut() throws TIOError, org.apache.thrift.TException
373 {
374 checkAndPut_result result = new checkAndPut_result();
375 receiveBase(result, "checkAndPut");
376 if (result.isSetSuccess()) {
377 return result.success;
378 }
379 if (result.io != null) {
380 throw result.io;
381 }
382 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndPut failed: unknown result");
383 }
384
385 public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException
386 {
387 send_putMultiple(table, puts);
388 recv_putMultiple();
389 }
390
391 public void send_putMultiple(ByteBuffer table, List<TPut> puts) throws org.apache.thrift.TException
392 {
393 putMultiple_args args = new putMultiple_args();
394 args.setTable(table);
395 args.setPuts(puts);
396 sendBase("putMultiple", args);
397 }
398
399 public void recv_putMultiple() throws TIOError, org.apache.thrift.TException
400 {
401 putMultiple_result result = new putMultiple_result();
402 receiveBase(result, "putMultiple");
403 if (result.io != null) {
404 throw result.io;
405 }
406 return;
407 }
408
409 public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
410 {
411 send_deleteSingle(table, deleteSingle);
412 recv_deleteSingle();
413 }
414
415 public void send_deleteSingle(ByteBuffer table, TDelete deleteSingle) throws org.apache.thrift.TException
416 {
417 deleteSingle_args args = new deleteSingle_args();
418 args.setTable(table);
419 args.setDeleteSingle(deleteSingle);
420 sendBase("deleteSingle", args);
421 }
422
423 public void recv_deleteSingle() throws TIOError, org.apache.thrift.TException
424 {
425 deleteSingle_result result = new deleteSingle_result();
426 receiveBase(result, "deleteSingle");
427 if (result.io != null) {
428 throw result.io;
429 }
430 return;
431 }
432
433 public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException
434 {
435 send_deleteMultiple(table, deletes);
436 return recv_deleteMultiple();
437 }
438
439 public void send_deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws org.apache.thrift.TException
440 {
441 deleteMultiple_args args = new deleteMultiple_args();
442 args.setTable(table);
443 args.setDeletes(deletes);
444 sendBase("deleteMultiple", args);
445 }
446
447 public List<TDelete> recv_deleteMultiple() throws TIOError, org.apache.thrift.TException
448 {
449 deleteMultiple_result result = new deleteMultiple_result();
450 receiveBase(result, "deleteMultiple");
451 if (result.isSetSuccess()) {
452 return result.success;
453 }
454 if (result.io != null) {
455 throw result.io;
456 }
457 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "deleteMultiple failed: unknown result");
458 }
459
460 public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
461 {
462 send_checkAndDelete(table, row, family, qualifier, value, deleteSingle);
463 return recv_checkAndDelete();
464 }
465
466 public void send_checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws org.apache.thrift.TException
467 {
468 checkAndDelete_args args = new checkAndDelete_args();
469 args.setTable(table);
470 args.setRow(row);
471 args.setFamily(family);
472 args.setQualifier(qualifier);
473 args.setValue(value);
474 args.setDeleteSingle(deleteSingle);
475 sendBase("checkAndDelete", args);
476 }
477
478 public boolean recv_checkAndDelete() throws TIOError, org.apache.thrift.TException
479 {
480 checkAndDelete_result result = new checkAndDelete_result();
481 receiveBase(result, "checkAndDelete");
482 if (result.isSetSuccess()) {
483 return result.success;
484 }
485 if (result.io != null) {
486 throw result.io;
487 }
488 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndDelete failed: unknown result");
489 }
490
491 public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException
492 {
493 send_increment(table, increment);
494 return recv_increment();
495 }
496
497 public void send_increment(ByteBuffer table, TIncrement increment) throws org.apache.thrift.TException
498 {
499 increment_args args = new increment_args();
500 args.setTable(table);
501 args.setIncrement(increment);
502 sendBase("increment", args);
503 }
504
505 public TResult recv_increment() throws TIOError, org.apache.thrift.TException
506 {
507 increment_result result = new increment_result();
508 receiveBase(result, "increment");
509 if (result.isSetSuccess()) {
510 return result.success;
511 }
512 if (result.io != null) {
513 throw result.io;
514 }
515 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "increment failed: unknown result");
516 }
517
518 public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException
519 {
520 send_openScanner(table, scan);
521 return recv_openScanner();
522 }
523
524 public void send_openScanner(ByteBuffer table, TScan scan) throws org.apache.thrift.TException
525 {
526 openScanner_args args = new openScanner_args();
527 args.setTable(table);
528 args.setScan(scan);
529 sendBase("openScanner", args);
530 }
531
532 public int recv_openScanner() throws TIOError, org.apache.thrift.TException
533 {
534 openScanner_result result = new openScanner_result();
535 receiveBase(result, "openScanner");
536 if (result.isSetSuccess()) {
537 return result.success;
538 }
539 if (result.io != null) {
540 throw result.io;
541 }
542 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "openScanner failed: unknown result");
543 }
544
545 public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException
546 {
547 send_getScannerRows(scannerId, numRows);
548 return recv_getScannerRows();
549 }
550
551 public void send_getScannerRows(int scannerId, int numRows) throws org.apache.thrift.TException
552 {
553 getScannerRows_args args = new getScannerRows_args();
554 args.setScannerId(scannerId);
555 args.setNumRows(numRows);
556 sendBase("getScannerRows", args);
557 }
558
559 public List<TResult> recv_getScannerRows() throws TIOError, TIllegalArgument, org.apache.thrift.TException
560 {
561 getScannerRows_result result = new getScannerRows_result();
562 receiveBase(result, "getScannerRows");
563 if (result.isSetSuccess()) {
564 return result.success;
565 }
566 if (result.io != null) {
567 throw result.io;
568 }
569 if (result.ia != null) {
570 throw result.ia;
571 }
572 throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerRows failed: unknown result");
573 }
574
575 public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException
576 {
577 send_closeScanner(scannerId);
578 recv_closeScanner();
579 }
580
581 public void send_closeScanner(int scannerId) throws org.apache.thrift.TException
582 {
583 closeScanner_args args = new closeScanner_args();
584 args.setScannerId(scannerId);
585 sendBase("closeScanner", args);
586 }
587
588 public void recv_closeScanner() throws TIOError, TIllegalArgument, org.apache.thrift.TException
589 {
590 closeScanner_result result = new closeScanner_result();
591 receiveBase(result, "closeScanner");
592 if (result.io != null) {
593 throw result.io;
594 }
595 if (result.ia != null) {
596 throw result.ia;
597 }
598 return;
599 }
600
601 }
602 public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
603 public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
604 private org.apache.thrift.async.TAsyncClientManager clientManager;
605 private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
606 public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) {
607 this.clientManager = clientManager;
608 this.protocolFactory = protocolFactory;
609 }
610 public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) {
611 return new AsyncClient(protocolFactory, clientManager, transport);
612 }
613 }
614
615 public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) {
616 super(protocolFactory, clientManager, transport);
617 }
618
619 public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<exists_call> resultHandler) throws org.apache.thrift.TException {
620 checkReady();
621 exists_call method_call = new exists_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
622 this.___currentMethod = method_call;
623 ___manager.call(method_call);
624 }
625
626 public static class exists_call extends org.apache.thrift.async.TAsyncMethodCall {
627 private ByteBuffer table;
628 private TGet get;
629 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 {
630 super(client, protocolFactory, transport, resultHandler, false);
631 this.table = table;
632 this.get = get;
633 }
634
635 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
636 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("exists", org.apache.thrift.protocol.TMessageType.CALL, 0));
637 exists_args args = new exists_args();
638 args.setTable(table);
639 args.setGet(get);
640 args.write(prot);
641 prot.writeMessageEnd();
642 }
643
644 public boolean getResult() throws TIOError, org.apache.thrift.TException {
645 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
646 throw new IllegalStateException("Method call not finished!");
647 }
648 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
649 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
650 return (new Client(prot)).recv_exists();
651 }
652 }
653
654 public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<get_call> resultHandler) throws org.apache.thrift.TException {
655 checkReady();
656 get_call method_call = new get_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
657 this.___currentMethod = method_call;
658 ___manager.call(method_call);
659 }
660
661 public static class get_call extends org.apache.thrift.async.TAsyncMethodCall {
662 private ByteBuffer table;
663 private TGet get;
664 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 {
665 super(client, protocolFactory, transport, resultHandler, false);
666 this.table = table;
667 this.get = get;
668 }
669
670 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
671 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.CALL, 0));
672 get_args args = new get_args();
673 args.setTable(table);
674 args.setGet(get);
675 args.write(prot);
676 prot.writeMessageEnd();
677 }
678
679 public TResult getResult() throws TIOError, org.apache.thrift.TException {
680 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
681 throw new IllegalStateException("Method call not finished!");
682 }
683 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
684 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
685 return (new Client(prot)).recv_get();
686 }
687 }
688
689 public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<getMultiple_call> resultHandler) throws org.apache.thrift.TException {
690 checkReady();
691 getMultiple_call method_call = new getMultiple_call(table, gets, resultHandler, this, ___protocolFactory, ___transport);
692 this.___currentMethod = method_call;
693 ___manager.call(method_call);
694 }
695
696 public static class getMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
697 private ByteBuffer table;
698 private List<TGet> gets;
699 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 {
700 super(client, protocolFactory, transport, resultHandler, false);
701 this.table = table;
702 this.gets = gets;
703 }
704
705 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
706 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
707 getMultiple_args args = new getMultiple_args();
708 args.setTable(table);
709 args.setGets(gets);
710 args.write(prot);
711 prot.writeMessageEnd();
712 }
713
714 public List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
715 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
716 throw new IllegalStateException("Method call not finished!");
717 }
718 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
719 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
720 return (new Client(prot)).recv_getMultiple();
721 }
722 }
723
724 public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<put_call> resultHandler) throws org.apache.thrift.TException {
725 checkReady();
726 put_call method_call = new put_call(table, put, resultHandler, this, ___protocolFactory, ___transport);
727 this.___currentMethod = method_call;
728 ___manager.call(method_call);
729 }
730
731 public static class put_call extends org.apache.thrift.async.TAsyncMethodCall {
732 private ByteBuffer table;
733 private TPut put;
734 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 {
735 super(client, protocolFactory, transport, resultHandler, false);
736 this.table = table;
737 this.put = put;
738 }
739
740 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
741 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("put", org.apache.thrift.protocol.TMessageType.CALL, 0));
742 put_args args = new put_args();
743 args.setTable(table);
744 args.setPut(put);
745 args.write(prot);
746 prot.writeMessageEnd();
747 }
748
749 public void getResult() throws TIOError, org.apache.thrift.TException {
750 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
751 throw new IllegalStateException("Method call not finished!");
752 }
753 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
754 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
755 (new Client(prot)).recv_put();
756 }
757 }
758
759 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 {
760 checkReady();
761 checkAndPut_call method_call = new checkAndPut_call(table, row, family, qualifier, value, put, resultHandler, this, ___protocolFactory, ___transport);
762 this.___currentMethod = method_call;
763 ___manager.call(method_call);
764 }
765
766 public static class checkAndPut_call extends org.apache.thrift.async.TAsyncMethodCall {
767 private ByteBuffer table;
768 private ByteBuffer row;
769 private ByteBuffer family;
770 private ByteBuffer qualifier;
771 private ByteBuffer value;
772 private TPut put;
773 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 {
774 super(client, protocolFactory, transport, resultHandler, false);
775 this.table = table;
776 this.row = row;
777 this.family = family;
778 this.qualifier = qualifier;
779 this.value = value;
780 this.put = put;
781 }
782
783 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
784 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndPut", org.apache.thrift.protocol.TMessageType.CALL, 0));
785 checkAndPut_args args = new checkAndPut_args();
786 args.setTable(table);
787 args.setRow(row);
788 args.setFamily(family);
789 args.setQualifier(qualifier);
790 args.setValue(value);
791 args.setPut(put);
792 args.write(prot);
793 prot.writeMessageEnd();
794 }
795
796 public boolean getResult() throws TIOError, org.apache.thrift.TException {
797 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
798 throw new IllegalStateException("Method call not finished!");
799 }
800 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
801 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
802 return (new Client(prot)).recv_checkAndPut();
803 }
804 }
805
806 public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<putMultiple_call> resultHandler) throws org.apache.thrift.TException {
807 checkReady();
808 putMultiple_call method_call = new putMultiple_call(table, puts, resultHandler, this, ___protocolFactory, ___transport);
809 this.___currentMethod = method_call;
810 ___manager.call(method_call);
811 }
812
813 public static class putMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
814 private ByteBuffer table;
815 private List<TPut> puts;
816 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 {
817 super(client, protocolFactory, transport, resultHandler, false);
818 this.table = table;
819 this.puts = puts;
820 }
821
822 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
823 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("putMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
824 putMultiple_args args = new putMultiple_args();
825 args.setTable(table);
826 args.setPuts(puts);
827 args.write(prot);
828 prot.writeMessageEnd();
829 }
830
831 public void getResult() throws TIOError, org.apache.thrift.TException {
832 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
833 throw new IllegalStateException("Method call not finished!");
834 }
835 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
836 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
837 (new Client(prot)).recv_putMultiple();
838 }
839 }
840
841 public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<deleteSingle_call> resultHandler) throws org.apache.thrift.TException {
842 checkReady();
843 deleteSingle_call method_call = new deleteSingle_call(table, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
844 this.___currentMethod = method_call;
845 ___manager.call(method_call);
846 }
847
848 public static class deleteSingle_call extends org.apache.thrift.async.TAsyncMethodCall {
849 private ByteBuffer table;
850 private TDelete deleteSingle;
851 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 {
852 super(client, protocolFactory, transport, resultHandler, false);
853 this.table = table;
854 this.deleteSingle = deleteSingle;
855 }
856
857 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
858 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteSingle", org.apache.thrift.protocol.TMessageType.CALL, 0));
859 deleteSingle_args args = new deleteSingle_args();
860 args.setTable(table);
861 args.setDeleteSingle(deleteSingle);
862 args.write(prot);
863 prot.writeMessageEnd();
864 }
865
866 public void getResult() throws TIOError, org.apache.thrift.TException {
867 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
868 throw new IllegalStateException("Method call not finished!");
869 }
870 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
871 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
872 (new Client(prot)).recv_deleteSingle();
873 }
874 }
875
876 public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<deleteMultiple_call> resultHandler) throws org.apache.thrift.TException {
877 checkReady();
878 deleteMultiple_call method_call = new deleteMultiple_call(table, deletes, resultHandler, this, ___protocolFactory, ___transport);
879 this.___currentMethod = method_call;
880 ___manager.call(method_call);
881 }
882
883 public static class deleteMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
884 private ByteBuffer table;
885 private List<TDelete> deletes;
886 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 {
887 super(client, protocolFactory, transport, resultHandler, false);
888 this.table = table;
889 this.deletes = deletes;
890 }
891
892 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
893 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
894 deleteMultiple_args args = new deleteMultiple_args();
895 args.setTable(table);
896 args.setDeletes(deletes);
897 args.write(prot);
898 prot.writeMessageEnd();
899 }
900
901 public List<TDelete> getResult() throws TIOError, org.apache.thrift.TException {
902 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
903 throw new IllegalStateException("Method call not finished!");
904 }
905 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
906 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
907 return (new Client(prot)).recv_deleteMultiple();
908 }
909 }
910
911 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 {
912 checkReady();
913 checkAndDelete_call method_call = new checkAndDelete_call(table, row, family, qualifier, value, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
914 this.___currentMethod = method_call;
915 ___manager.call(method_call);
916 }
917
918 public static class checkAndDelete_call extends org.apache.thrift.async.TAsyncMethodCall {
919 private ByteBuffer table;
920 private ByteBuffer row;
921 private ByteBuffer family;
922 private ByteBuffer qualifier;
923 private ByteBuffer value;
924 private TDelete deleteSingle;
925 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 {
926 super(client, protocolFactory, transport, resultHandler, false);
927 this.table = table;
928 this.row = row;
929 this.family = family;
930 this.qualifier = qualifier;
931 this.value = value;
932 this.deleteSingle = deleteSingle;
933 }
934
935 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
936 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndDelete", org.apache.thrift.protocol.TMessageType.CALL, 0));
937 checkAndDelete_args args = new checkAndDelete_args();
938 args.setTable(table);
939 args.setRow(row);
940 args.setFamily(family);
941 args.setQualifier(qualifier);
942 args.setValue(value);
943 args.setDeleteSingle(deleteSingle);
944 args.write(prot);
945 prot.writeMessageEnd();
946 }
947
948 public boolean getResult() throws TIOError, org.apache.thrift.TException {
949 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
950 throw new IllegalStateException("Method call not finished!");
951 }
952 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
953 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
954 return (new Client(prot)).recv_checkAndDelete();
955 }
956 }
957
958 public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<increment_call> resultHandler) throws org.apache.thrift.TException {
959 checkReady();
960 increment_call method_call = new increment_call(table, increment, resultHandler, this, ___protocolFactory, ___transport);
961 this.___currentMethod = method_call;
962 ___manager.call(method_call);
963 }
964
965 public static class increment_call extends org.apache.thrift.async.TAsyncMethodCall {
966 private ByteBuffer table;
967 private TIncrement increment;
968 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 {
969 super(client, protocolFactory, transport, resultHandler, false);
970 this.table = table;
971 this.increment = increment;
972 }
973
974 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
975 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("increment", org.apache.thrift.protocol.TMessageType.CALL, 0));
976 increment_args args = new increment_args();
977 args.setTable(table);
978 args.setIncrement(increment);
979 args.write(prot);
980 prot.writeMessageEnd();
981 }
982
983 public TResult getResult() throws TIOError, org.apache.thrift.TException {
984 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
985 throw new IllegalStateException("Method call not finished!");
986 }
987 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
988 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
989 return (new Client(prot)).recv_increment();
990 }
991 }
992
993 public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<openScanner_call> resultHandler) throws org.apache.thrift.TException {
994 checkReady();
995 openScanner_call method_call = new openScanner_call(table, scan, resultHandler, this, ___protocolFactory, ___transport);
996 this.___currentMethod = method_call;
997 ___manager.call(method_call);
998 }
999
1000 public static class openScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1001 private ByteBuffer table;
1002 private TScan scan;
1003 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 {
1004 super(client, protocolFactory, transport, resultHandler, false);
1005 this.table = table;
1006 this.scan = scan;
1007 }
1008
1009 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1010 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("openScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1011 openScanner_args args = new openScanner_args();
1012 args.setTable(table);
1013 args.setScan(scan);
1014 args.write(prot);
1015 prot.writeMessageEnd();
1016 }
1017
1018 public int getResult() throws TIOError, org.apache.thrift.TException {
1019 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1020 throw new IllegalStateException("Method call not finished!");
1021 }
1022 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1023 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1024 return (new Client(prot)).recv_openScanner();
1025 }
1026 }
1027
1028 public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerRows_call> resultHandler) throws org.apache.thrift.TException {
1029 checkReady();
1030 getScannerRows_call method_call = new getScannerRows_call(scannerId, numRows, resultHandler, this, ___protocolFactory, ___transport);
1031 this.___currentMethod = method_call;
1032 ___manager.call(method_call);
1033 }
1034
1035 public static class getScannerRows_call extends org.apache.thrift.async.TAsyncMethodCall {
1036 private int scannerId;
1037 private int numRows;
1038 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 {
1039 super(client, protocolFactory, transport, resultHandler, false);
1040 this.scannerId = scannerId;
1041 this.numRows = numRows;
1042 }
1043
1044 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1045 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerRows", org.apache.thrift.protocol.TMessageType.CALL, 0));
1046 getScannerRows_args args = new getScannerRows_args();
1047 args.setScannerId(scannerId);
1048 args.setNumRows(numRows);
1049 args.write(prot);
1050 prot.writeMessageEnd();
1051 }
1052
1053 public List<TResult> getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1054 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1055 throw new IllegalStateException("Method call not finished!");
1056 }
1057 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1058 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1059 return (new Client(prot)).recv_getScannerRows();
1060 }
1061 }
1062
1063 public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<closeScanner_call> resultHandler) throws org.apache.thrift.TException {
1064 checkReady();
1065 closeScanner_call method_call = new closeScanner_call(scannerId, resultHandler, this, ___protocolFactory, ___transport);
1066 this.___currentMethod = method_call;
1067 ___manager.call(method_call);
1068 }
1069
1070 public static class closeScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1071 private int scannerId;
1072 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 {
1073 super(client, protocolFactory, transport, resultHandler, false);
1074 this.scannerId = scannerId;
1075 }
1076
1077 public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1078 prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1079 closeScanner_args args = new closeScanner_args();
1080 args.setScannerId(scannerId);
1081 args.write(prot);
1082 prot.writeMessageEnd();
1083 }
1084
1085 public void getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1086 if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1087 throw new IllegalStateException("Method call not finished!");
1088 }
1089 org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1090 org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1091 (new Client(prot)).recv_closeScanner();
1092 }
1093 }
1094
1095 }
1096
1097 public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
1098 private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1099 public Processor(I iface) {
1100 super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
1101 }
1102
1103 protected Processor(I iface, Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) {
1104 super(iface, getProcessMap(processMap));
1105 }
1106
1107 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) {
1108 processMap.put("exists", new exists());
1109 processMap.put("get", new get());
1110 processMap.put("getMultiple", new getMultiple());
1111 processMap.put("put", new put());
1112 processMap.put("checkAndPut", new checkAndPut());
1113 processMap.put("putMultiple", new putMultiple());
1114 processMap.put("deleteSingle", new deleteSingle());
1115 processMap.put("deleteMultiple", new deleteMultiple());
1116 processMap.put("checkAndDelete", new checkAndDelete());
1117 processMap.put("increment", new increment());
1118 processMap.put("openScanner", new openScanner());
1119 processMap.put("getScannerRows", new getScannerRows());
1120 processMap.put("closeScanner", new closeScanner());
1121 return processMap;
1122 }
1123
1124 private static class exists<I extends Iface> extends org.apache.thrift.ProcessFunction<I, exists_args> {
1125 public exists() {
1126 super("exists");
1127 }
1128
1129 protected exists_args getEmptyArgsInstance() {
1130 return new exists_args();
1131 }
1132
1133 protected exists_result getResult(I iface, exists_args args) throws org.apache.thrift.TException {
1134 exists_result result = new exists_result();
1135 try {
1136 result.success = iface.exists(args.table, args.get);
1137 result.setSuccessIsSet(true);
1138 } catch (TIOError io) {
1139 result.io = io;
1140 }
1141 return result;
1142 }
1143 }
1144
1145 private static class get<I extends Iface> extends org.apache.thrift.ProcessFunction<I, get_args> {
1146 public get() {
1147 super("get");
1148 }
1149
1150 protected get_args getEmptyArgsInstance() {
1151 return new get_args();
1152 }
1153
1154 protected get_result getResult(I iface, get_args args) throws org.apache.thrift.TException {
1155 get_result result = new get_result();
1156 try {
1157 result.success = iface.get(args.table, args.get);
1158 } catch (TIOError io) {
1159 result.io = io;
1160 }
1161 return result;
1162 }
1163 }
1164
1165 private static class getMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getMultiple_args> {
1166 public getMultiple() {
1167 super("getMultiple");
1168 }
1169
1170 protected getMultiple_args getEmptyArgsInstance() {
1171 return new getMultiple_args();
1172 }
1173
1174 protected getMultiple_result getResult(I iface, getMultiple_args args) throws org.apache.thrift.TException {
1175 getMultiple_result result = new getMultiple_result();
1176 try {
1177 result.success = iface.getMultiple(args.table, args.gets);
1178 } catch (TIOError io) {
1179 result.io = io;
1180 }
1181 return result;
1182 }
1183 }
1184
1185 private static class put<I extends Iface> extends org.apache.thrift.ProcessFunction<I, put_args> {
1186 public put() {
1187 super("put");
1188 }
1189
1190 protected put_args getEmptyArgsInstance() {
1191 return new put_args();
1192 }
1193
1194 protected put_result getResult(I iface, put_args args) throws org.apache.thrift.TException {
1195 put_result result = new put_result();
1196 try {
1197 iface.put(args.table, args.put);
1198 } catch (TIOError io) {
1199 result.io = io;
1200 }
1201 return result;
1202 }
1203 }
1204
1205 private static class checkAndPut<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndPut_args> {
1206 public checkAndPut() {
1207 super("checkAndPut");
1208 }
1209
1210 protected checkAndPut_args getEmptyArgsInstance() {
1211 return new checkAndPut_args();
1212 }
1213
1214 protected checkAndPut_result getResult(I iface, checkAndPut_args args) throws org.apache.thrift.TException {
1215 checkAndPut_result result = new checkAndPut_result();
1216 try {
1217 result.success = iface.checkAndPut(args.table, args.row, args.family, args.qualifier, args.value, args.put);
1218 result.setSuccessIsSet(true);
1219 } catch (TIOError io) {
1220 result.io = io;
1221 }
1222 return result;
1223 }
1224 }
1225
1226 private static class putMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, putMultiple_args> {
1227 public putMultiple() {
1228 super("putMultiple");
1229 }
1230
1231 protected putMultiple_args getEmptyArgsInstance() {
1232 return new putMultiple_args();
1233 }
1234
1235 protected putMultiple_result getResult(I iface, putMultiple_args args) throws org.apache.thrift.TException {
1236 putMultiple_result result = new putMultiple_result();
1237 try {
1238 iface.putMultiple(args.table, args.puts);
1239 } catch (TIOError io) {
1240 result.io = io;
1241 }
1242 return result;
1243 }
1244 }
1245
1246 private static class deleteSingle<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteSingle_args> {
1247 public deleteSingle() {
1248 super("deleteSingle");
1249 }
1250
1251 protected deleteSingle_args getEmptyArgsInstance() {
1252 return new deleteSingle_args();
1253 }
1254
1255 protected deleteSingle_result getResult(I iface, deleteSingle_args args) throws org.apache.thrift.TException {
1256 deleteSingle_result result = new deleteSingle_result();
1257 try {
1258 iface.deleteSingle(args.table, args.deleteSingle);
1259 } catch (TIOError io) {
1260 result.io = io;
1261 }
1262 return result;
1263 }
1264 }
1265
1266 private static class deleteMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteMultiple_args> {
1267 public deleteMultiple() {
1268 super("deleteMultiple");
1269 }
1270
1271 protected deleteMultiple_args getEmptyArgsInstance() {
1272 return new deleteMultiple_args();
1273 }
1274
1275 protected deleteMultiple_result getResult(I iface, deleteMultiple_args args) throws org.apache.thrift.TException {
1276 deleteMultiple_result result = new deleteMultiple_result();
1277 try {
1278 result.success = iface.deleteMultiple(args.table, args.deletes);
1279 } catch (TIOError io) {
1280 result.io = io;
1281 }
1282 return result;
1283 }
1284 }
1285
1286 private static class checkAndDelete<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndDelete_args> {
1287 public checkAndDelete() {
1288 super("checkAndDelete");
1289 }
1290
1291 protected checkAndDelete_args getEmptyArgsInstance() {
1292 return new checkAndDelete_args();
1293 }
1294
1295 protected checkAndDelete_result getResult(I iface, checkAndDelete_args args) throws org.apache.thrift.TException {
1296 checkAndDelete_result result = new checkAndDelete_result();
1297 try {
1298 result.success = iface.checkAndDelete(args.table, args.row, args.family, args.qualifier, args.value, args.deleteSingle);
1299 result.setSuccessIsSet(true);
1300 } catch (TIOError io) {
1301 result.io = io;
1302 }
1303 return result;
1304 }
1305 }
1306
1307 private static class increment<I extends Iface> extends org.apache.thrift.ProcessFunction<I, increment_args> {
1308 public increment() {
1309 super("increment");
1310 }
1311
1312 protected increment_args getEmptyArgsInstance() {
1313 return new increment_args();
1314 }
1315
1316 protected increment_result getResult(I iface, increment_args args) throws org.apache.thrift.TException {
1317 increment_result result = new increment_result();
1318 try {
1319 result.success = iface.increment(args.table, args.increment);
1320 } catch (TIOError io) {
1321 result.io = io;
1322 }
1323 return result;
1324 }
1325 }
1326
1327 private static class openScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, openScanner_args> {
1328 public openScanner() {
1329 super("openScanner");
1330 }
1331
1332 protected openScanner_args getEmptyArgsInstance() {
1333 return new openScanner_args();
1334 }
1335
1336 protected openScanner_result getResult(I iface, openScanner_args args) throws org.apache.thrift.TException {
1337 openScanner_result result = new openScanner_result();
1338 try {
1339 result.success = iface.openScanner(args.table, args.scan);
1340 result.setSuccessIsSet(true);
1341 } catch (TIOError io) {
1342 result.io = io;
1343 }
1344 return result;
1345 }
1346 }
1347
1348 private static class getScannerRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerRows_args> {
1349 public getScannerRows() {
1350 super("getScannerRows");
1351 }
1352
1353 protected getScannerRows_args getEmptyArgsInstance() {
1354 return new getScannerRows_args();
1355 }
1356
1357 protected getScannerRows_result getResult(I iface, getScannerRows_args args) throws org.apache.thrift.TException {
1358 getScannerRows_result result = new getScannerRows_result();
1359 try {
1360 result.success = iface.getScannerRows(args.scannerId, args.numRows);
1361 } catch (TIOError io) {
1362 result.io = io;
1363 } catch (TIllegalArgument ia) {
1364 result.ia = ia;
1365 }
1366 return result;
1367 }
1368 }
1369
1370 private static class closeScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeScanner_args> {
1371 public closeScanner() {
1372 super("closeScanner");
1373 }
1374
1375 protected closeScanner_args getEmptyArgsInstance() {
1376 return new closeScanner_args();
1377 }
1378
1379 protected closeScanner_result getResult(I iface, closeScanner_args args) throws org.apache.thrift.TException {
1380 closeScanner_result result = new closeScanner_result();
1381 try {
1382 iface.closeScanner(args.scannerId);
1383 } catch (TIOError io) {
1384 result.io = io;
1385 } catch (TIllegalArgument ia) {
1386 result.ia = ia;
1387 }
1388 return result;
1389 }
1390 }
1391
1392 }
1393
1394 public static class exists_args implements org.apache.thrift.TBase<exists_args, exists_args._Fields>, java.io.Serializable, Cloneable {
1395 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_args");
1396
1397 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);
1398 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);
1399
1400 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
1401 static {
1402 schemes.put(StandardScheme.class, new exists_argsStandardSchemeFactory());
1403 schemes.put(TupleScheme.class, new exists_argsTupleSchemeFactory());
1404 }
1405
1406
1407
1408
1409 public ByteBuffer table;
1410
1411
1412
1413 public TGet get;
1414
1415
1416 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
1417
1418
1419
1420 TABLE((short)1, "table"),
1421
1422
1423
1424 GET((short)2, "get");
1425
1426 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
1427
1428 static {
1429 for (_Fields field : EnumSet.allOf(_Fields.class)) {
1430 byName.put(field.getFieldName(), field);
1431 }
1432 }
1433
1434
1435
1436
1437 public static _Fields findByThriftId(int fieldId) {
1438 switch(fieldId) {
1439 case 1:
1440 return TABLE;
1441 case 2:
1442 return GET;
1443 default:
1444 return null;
1445 }
1446 }
1447
1448
1449
1450
1451
1452 public static _Fields findByThriftIdOrThrow(int fieldId) {
1453 _Fields fields = findByThriftId(fieldId);
1454 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
1455 return fields;
1456 }
1457
1458
1459
1460
1461 public static _Fields findByName(String name) {
1462 return byName.get(name);
1463 }
1464
1465 private final short _thriftId;
1466 private final String _fieldName;
1467
1468 _Fields(short thriftId, String fieldName) {
1469 _thriftId = thriftId;
1470 _fieldName = fieldName;
1471 }
1472
1473 public short getThriftFieldId() {
1474 return _thriftId;
1475 }
1476
1477 public String getFieldName() {
1478 return _fieldName;
1479 }
1480 }
1481
1482
1483 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
1484 static {
1485 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
1486 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
1487 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
1488 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
1489 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
1490 metaDataMap = Collections.unmodifiableMap(tmpMap);
1491 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_args.class, metaDataMap);
1492 }
1493
1494 public exists_args() {
1495 }
1496
1497 public exists_args(
1498 ByteBuffer table,
1499 TGet get)
1500 {
1501 this();
1502 this.table = table;
1503 this.get = get;
1504 }
1505
1506
1507
1508
1509 public exists_args(exists_args other) {
1510 if (other.isSetTable()) {
1511 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
1512 ;
1513 }
1514 if (other.isSetGet()) {
1515 this.get = new TGet(other.get);
1516 }
1517 }
1518
1519 public exists_args deepCopy() {
1520 return new exists_args(this);
1521 }
1522
1523 @Override
1524 public void clear() {
1525 this.table = null;
1526 this.get = null;
1527 }
1528
1529
1530
1531
1532 public byte[] getTable() {
1533 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
1534 return table == null ? null : table.array();
1535 }
1536
1537 public ByteBuffer bufferForTable() {
1538 return table;
1539 }
1540
1541
1542
1543
1544 public exists_args setTable(byte[] table) {
1545 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
1546 return this;
1547 }
1548
1549 public exists_args setTable(ByteBuffer table) {
1550 this.table = table;
1551 return this;
1552 }
1553
1554 public void unsetTable() {
1555 this.table = null;
1556 }
1557
1558
1559 public boolean isSetTable() {
1560 return this.table != null;
1561 }
1562
1563 public void setTableIsSet(boolean value) {
1564 if (!value) {
1565 this.table = null;
1566 }
1567 }
1568
1569
1570
1571
1572 public TGet getGet() {
1573 return this.get;
1574 }
1575
1576
1577
1578
1579 public exists_args setGet(TGet get) {
1580 this.get = get;
1581 return this;
1582 }
1583
1584 public void unsetGet() {
1585 this.get = null;
1586 }
1587
1588
1589 public boolean isSetGet() {
1590 return this.get != null;
1591 }
1592
1593 public void setGetIsSet(boolean value) {
1594 if (!value) {
1595 this.get = null;
1596 }
1597 }
1598
1599 public void setFieldValue(_Fields field, Object value) {
1600 switch (field) {
1601 case TABLE:
1602 if (value == null) {
1603 unsetTable();
1604 } else {
1605 setTable((ByteBuffer)value);
1606 }
1607 break;
1608
1609 case GET:
1610 if (value == null) {
1611 unsetGet();
1612 } else {
1613 setGet((TGet)value);
1614 }
1615 break;
1616
1617 }
1618 }
1619
1620 public Object getFieldValue(_Fields field) {
1621 switch (field) {
1622 case TABLE:
1623 return getTable();
1624
1625 case GET:
1626 return getGet();
1627
1628 }
1629 throw new IllegalStateException();
1630 }
1631
1632
1633 public boolean isSet(_Fields field) {
1634 if (field == null) {
1635 throw new IllegalArgumentException();
1636 }
1637
1638 switch (field) {
1639 case TABLE:
1640 return isSetTable();
1641 case GET:
1642 return isSetGet();
1643 }
1644 throw new IllegalStateException();
1645 }
1646
1647 @Override
1648 public boolean equals(Object that) {
1649 if (that == null)
1650 return false;
1651 if (that instanceof exists_args)
1652 return this.equals((exists_args)that);
1653 return false;
1654 }
1655
1656 public boolean equals(exists_args that) {
1657 if (that == null)
1658 return false;
1659
1660 boolean this_present_table = true && this.isSetTable();
1661 boolean that_present_table = true && that.isSetTable();
1662 if (this_present_table || that_present_table) {
1663 if (!(this_present_table && that_present_table))
1664 return false;
1665 if (!this.table.equals(that.table))
1666 return false;
1667 }
1668
1669 boolean this_present_get = true && this.isSetGet();
1670 boolean that_present_get = true && that.isSetGet();
1671 if (this_present_get || that_present_get) {
1672 if (!(this_present_get && that_present_get))
1673 return false;
1674 if (!this.get.equals(that.get))
1675 return false;
1676 }
1677
1678 return true;
1679 }
1680
1681 @Override
1682 public int hashCode() {
1683 return 0;
1684 }
1685
1686 public int compareTo(exists_args other) {
1687 if (!getClass().equals(other.getClass())) {
1688 return getClass().getName().compareTo(other.getClass().getName());
1689 }
1690
1691 int lastComparison = 0;
1692 exists_args typedOther = (exists_args)other;
1693
1694 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
1695 if (lastComparison != 0) {
1696 return lastComparison;
1697 }
1698 if (isSetTable()) {
1699 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
1700 if (lastComparison != 0) {
1701 return lastComparison;
1702 }
1703 }
1704 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
1705 if (lastComparison != 0) {
1706 return lastComparison;
1707 }
1708 if (isSetGet()) {
1709 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
1710 if (lastComparison != 0) {
1711 return lastComparison;
1712 }
1713 }
1714 return 0;
1715 }
1716
1717 public _Fields fieldForId(int fieldId) {
1718 return _Fields.findByThriftId(fieldId);
1719 }
1720
1721 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
1722 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
1723 }
1724
1725 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
1726 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
1727 }
1728
1729 @Override
1730 public String toString() {
1731 StringBuilder sb = new StringBuilder("exists_args(");
1732 boolean first = true;
1733
1734 sb.append("table:");
1735 if (this.table == null) {
1736 sb.append("null");
1737 } else {
1738 org.apache.thrift.TBaseHelper.toString(this.table, sb);
1739 }
1740 first = false;
1741 if (!first) sb.append(", ");
1742 sb.append("get:");
1743 if (this.get == null) {
1744 sb.append("null");
1745 } else {
1746 sb.append(this.get);
1747 }
1748 first = false;
1749 sb.append(")");
1750 return sb.toString();
1751 }
1752
1753 public void validate() throws org.apache.thrift.TException {
1754
1755 if (table == null) {
1756 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
1757 }
1758 if (get == null) {
1759 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
1760 }
1761 }
1762
1763 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
1764 try {
1765 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
1766 } catch (org.apache.thrift.TException te) {
1767 throw new java.io.IOException(te);
1768 }
1769 }
1770
1771 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
1772 try {
1773 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
1774 } catch (org.apache.thrift.TException te) {
1775 throw new java.io.IOException(te);
1776 }
1777 }
1778
1779 private static class exists_argsStandardSchemeFactory implements SchemeFactory {
1780 public exists_argsStandardScheme getScheme() {
1781 return new exists_argsStandardScheme();
1782 }
1783 }
1784
1785 private static class exists_argsStandardScheme extends StandardScheme<exists_args> {
1786
1787 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_args struct) throws org.apache.thrift.TException {
1788 org.apache.thrift.protocol.TField schemeField;
1789 iprot.readStructBegin();
1790 while (true)
1791 {
1792 schemeField = iprot.readFieldBegin();
1793 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
1794 break;
1795 }
1796 switch (schemeField.id) {
1797 case 1:
1798 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
1799 struct.table = iprot.readBinary();
1800 struct.setTableIsSet(true);
1801 } else {
1802 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1803 }
1804 break;
1805 case 2:
1806 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
1807 struct.get = new TGet();
1808 struct.get.read(iprot);
1809 struct.setGetIsSet(true);
1810 } else {
1811 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1812 }
1813 break;
1814 default:
1815 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1816 }
1817 iprot.readFieldEnd();
1818 }
1819 iprot.readStructEnd();
1820
1821
1822 struct.validate();
1823 }
1824
1825 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_args struct) throws org.apache.thrift.TException {
1826 struct.validate();
1827
1828 oprot.writeStructBegin(STRUCT_DESC);
1829 if (struct.table != null) {
1830 oprot.writeFieldBegin(TABLE_FIELD_DESC);
1831 oprot.writeBinary(struct.table);
1832 oprot.writeFieldEnd();
1833 }
1834 if (struct.get != null) {
1835 oprot.writeFieldBegin(GET_FIELD_DESC);
1836 struct.get.write(oprot);
1837 oprot.writeFieldEnd();
1838 }
1839 oprot.writeFieldStop();
1840 oprot.writeStructEnd();
1841 }
1842
1843 }
1844
1845 private static class exists_argsTupleSchemeFactory implements SchemeFactory {
1846 public exists_argsTupleScheme getScheme() {
1847 return new exists_argsTupleScheme();
1848 }
1849 }
1850
1851 private static class exists_argsTupleScheme extends TupleScheme<exists_args> {
1852
1853 @Override
1854 public void write(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
1855 TTupleProtocol oprot = (TTupleProtocol) prot;
1856 oprot.writeBinary(struct.table);
1857 struct.get.write(oprot);
1858 }
1859
1860 @Override
1861 public void read(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
1862 TTupleProtocol iprot = (TTupleProtocol) prot;
1863 struct.table = iprot.readBinary();
1864 struct.setTableIsSet(true);
1865 struct.get = new TGet();
1866 struct.get.read(iprot);
1867 struct.setGetIsSet(true);
1868 }
1869 }
1870
1871 }
1872
1873 public static class exists_result implements org.apache.thrift.TBase<exists_result, exists_result._Fields>, java.io.Serializable, Cloneable {
1874 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_result");
1875
1876 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);
1877 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);
1878
1879 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
1880 static {
1881 schemes.put(StandardScheme.class, new exists_resultStandardSchemeFactory());
1882 schemes.put(TupleScheme.class, new exists_resultTupleSchemeFactory());
1883 }
1884
1885 public boolean success;
1886 public TIOError io;
1887
1888
1889 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
1890 SUCCESS((short)0, "success"),
1891 IO((short)1, "io");
1892
1893 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
1894
1895 static {
1896 for (_Fields field : EnumSet.allOf(_Fields.class)) {
1897 byName.put(field.getFieldName(), field);
1898 }
1899 }
1900
1901
1902
1903
1904 public static _Fields findByThriftId(int fieldId) {
1905 switch(fieldId) {
1906 case 0:
1907 return SUCCESS;
1908 case 1:
1909 return IO;
1910 default:
1911 return null;
1912 }
1913 }
1914
1915
1916
1917
1918
1919 public static _Fields findByThriftIdOrThrow(int fieldId) {
1920 _Fields fields = findByThriftId(fieldId);
1921 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
1922 return fields;
1923 }
1924
1925
1926
1927
1928 public static _Fields findByName(String name) {
1929 return byName.get(name);
1930 }
1931
1932 private final short _thriftId;
1933 private final String _fieldName;
1934
1935 _Fields(short thriftId, String fieldName) {
1936 _thriftId = thriftId;
1937 _fieldName = fieldName;
1938 }
1939
1940 public short getThriftFieldId() {
1941 return _thriftId;
1942 }
1943
1944 public String getFieldName() {
1945 return _fieldName;
1946 }
1947 }
1948
1949
1950 private static final int __SUCCESS_ISSET_ID = 0;
1951 private BitSet __isset_bit_vector = new BitSet(1);
1952 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
1953 static {
1954 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
1955 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
1956 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
1957 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
1958 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
1959 metaDataMap = Collections.unmodifiableMap(tmpMap);
1960 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_result.class, metaDataMap);
1961 }
1962
1963 public exists_result() {
1964 }
1965
1966 public exists_result(
1967 boolean success,
1968 TIOError io)
1969 {
1970 this();
1971 this.success = success;
1972 setSuccessIsSet(true);
1973 this.io = io;
1974 }
1975
1976
1977
1978
1979 public exists_result(exists_result other) {
1980 __isset_bit_vector.clear();
1981 __isset_bit_vector.or(other.__isset_bit_vector);
1982 this.success = other.success;
1983 if (other.isSetIo()) {
1984 this.io = new TIOError(other.io);
1985 }
1986 }
1987
1988 public exists_result deepCopy() {
1989 return new exists_result(this);
1990 }
1991
1992 @Override
1993 public void clear() {
1994 setSuccessIsSet(false);
1995 this.success = false;
1996 this.io = null;
1997 }
1998
1999 public boolean isSuccess() {
2000 return this.success;
2001 }
2002
2003 public exists_result setSuccess(boolean success) {
2004 this.success = success;
2005 setSuccessIsSet(true);
2006 return this;
2007 }
2008
2009 public void unsetSuccess() {
2010 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
2011 }
2012
2013
2014 public boolean isSetSuccess() {
2015 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
2016 }
2017
2018 public void setSuccessIsSet(boolean value) {
2019 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
2020 }
2021
2022 public TIOError getIo() {
2023 return this.io;
2024 }
2025
2026 public exists_result setIo(TIOError io) {
2027 this.io = io;
2028 return this;
2029 }
2030
2031 public void unsetIo() {
2032 this.io = null;
2033 }
2034
2035
2036 public boolean isSetIo() {
2037 return this.io != null;
2038 }
2039
2040 public void setIoIsSet(boolean value) {
2041 if (!value) {
2042 this.io = null;
2043 }
2044 }
2045
2046 public void setFieldValue(_Fields field, Object value) {
2047 switch (field) {
2048 case SUCCESS:
2049 if (value == null) {
2050 unsetSuccess();
2051 } else {
2052 setSuccess((Boolean)value);
2053 }
2054 break;
2055
2056 case IO:
2057 if (value == null) {
2058 unsetIo();
2059 } else {
2060 setIo((TIOError)value);
2061 }
2062 break;
2063
2064 }
2065 }
2066
2067 public Object getFieldValue(_Fields field) {
2068 switch (field) {
2069 case SUCCESS:
2070 return Boolean.valueOf(isSuccess());
2071
2072 case IO:
2073 return getIo();
2074
2075 }
2076 throw new IllegalStateException();
2077 }
2078
2079
2080 public boolean isSet(_Fields field) {
2081 if (field == null) {
2082 throw new IllegalArgumentException();
2083 }
2084
2085 switch (field) {
2086 case SUCCESS:
2087 return isSetSuccess();
2088 case IO:
2089 return isSetIo();
2090 }
2091 throw new IllegalStateException();
2092 }
2093
2094 @Override
2095 public boolean equals(Object that) {
2096 if (that == null)
2097 return false;
2098 if (that instanceof exists_result)
2099 return this.equals((exists_result)that);
2100 return false;
2101 }
2102
2103 public boolean equals(exists_result that) {
2104 if (that == null)
2105 return false;
2106
2107 boolean this_present_success = true;
2108 boolean that_present_success = true;
2109 if (this_present_success || that_present_success) {
2110 if (!(this_present_success && that_present_success))
2111 return false;
2112 if (this.success != that.success)
2113 return false;
2114 }
2115
2116 boolean this_present_io = true && this.isSetIo();
2117 boolean that_present_io = true && that.isSetIo();
2118 if (this_present_io || that_present_io) {
2119 if (!(this_present_io && that_present_io))
2120 return false;
2121 if (!this.io.equals(that.io))
2122 return false;
2123 }
2124
2125 return true;
2126 }
2127
2128 @Override
2129 public int hashCode() {
2130 return 0;
2131 }
2132
2133 public int compareTo(exists_result other) {
2134 if (!getClass().equals(other.getClass())) {
2135 return getClass().getName().compareTo(other.getClass().getName());
2136 }
2137
2138 int lastComparison = 0;
2139 exists_result typedOther = (exists_result)other;
2140
2141 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
2142 if (lastComparison != 0) {
2143 return lastComparison;
2144 }
2145 if (isSetSuccess()) {
2146 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
2147 if (lastComparison != 0) {
2148 return lastComparison;
2149 }
2150 }
2151 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
2152 if (lastComparison != 0) {
2153 return lastComparison;
2154 }
2155 if (isSetIo()) {
2156 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
2157 if (lastComparison != 0) {
2158 return lastComparison;
2159 }
2160 }
2161 return 0;
2162 }
2163
2164 public _Fields fieldForId(int fieldId) {
2165 return _Fields.findByThriftId(fieldId);
2166 }
2167
2168 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2169 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2170 }
2171
2172 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2173 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2174 }
2175
2176 @Override
2177 public String toString() {
2178 StringBuilder sb = new StringBuilder("exists_result(");
2179 boolean first = true;
2180
2181 sb.append("success:");
2182 sb.append(this.success);
2183 first = false;
2184 if (!first) sb.append(", ");
2185 sb.append("io:");
2186 if (this.io == null) {
2187 sb.append("null");
2188 } else {
2189 sb.append(this.io);
2190 }
2191 first = false;
2192 sb.append(")");
2193 return sb.toString();
2194 }
2195
2196 public void validate() throws org.apache.thrift.TException {
2197
2198 }
2199
2200 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2201 try {
2202 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2203 } catch (org.apache.thrift.TException te) {
2204 throw new java.io.IOException(te);
2205 }
2206 }
2207
2208 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2209 try {
2210 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2211 } catch (org.apache.thrift.TException te) {
2212 throw new java.io.IOException(te);
2213 }
2214 }
2215
2216 private static class exists_resultStandardSchemeFactory implements SchemeFactory {
2217 public exists_resultStandardScheme getScheme() {
2218 return new exists_resultStandardScheme();
2219 }
2220 }
2221
2222 private static class exists_resultStandardScheme extends StandardScheme<exists_result> {
2223
2224 public void read(org.apache.thrift.protocol.TProtocol iprot, exists_result struct) throws org.apache.thrift.TException {
2225 org.apache.thrift.protocol.TField schemeField;
2226 iprot.readStructBegin();
2227 while (true)
2228 {
2229 schemeField = iprot.readFieldBegin();
2230 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2231 break;
2232 }
2233 switch (schemeField.id) {
2234 case 0:
2235 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
2236 struct.success = iprot.readBool();
2237 struct.setSuccessIsSet(true);
2238 } else {
2239 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2240 }
2241 break;
2242 case 1:
2243 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2244 struct.io = new TIOError();
2245 struct.io.read(iprot);
2246 struct.setIoIsSet(true);
2247 } else {
2248 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2249 }
2250 break;
2251 default:
2252 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2253 }
2254 iprot.readFieldEnd();
2255 }
2256 iprot.readStructEnd();
2257
2258
2259 struct.validate();
2260 }
2261
2262 public void write(org.apache.thrift.protocol.TProtocol oprot, exists_result struct) throws org.apache.thrift.TException {
2263 struct.validate();
2264
2265 oprot.writeStructBegin(STRUCT_DESC);
2266 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
2267 oprot.writeBool(struct.success);
2268 oprot.writeFieldEnd();
2269 if (struct.io != null) {
2270 oprot.writeFieldBegin(IO_FIELD_DESC);
2271 struct.io.write(oprot);
2272 oprot.writeFieldEnd();
2273 }
2274 oprot.writeFieldStop();
2275 oprot.writeStructEnd();
2276 }
2277
2278 }
2279
2280 private static class exists_resultTupleSchemeFactory implements SchemeFactory {
2281 public exists_resultTupleScheme getScheme() {
2282 return new exists_resultTupleScheme();
2283 }
2284 }
2285
2286 private static class exists_resultTupleScheme extends TupleScheme<exists_result> {
2287
2288 @Override
2289 public void write(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2290 TTupleProtocol oprot = (TTupleProtocol) prot;
2291 BitSet optionals = new BitSet();
2292 if (struct.isSetSuccess()) {
2293 optionals.set(0);
2294 }
2295 if (struct.isSetIo()) {
2296 optionals.set(1);
2297 }
2298 oprot.writeBitSet(optionals, 2);
2299 if (struct.isSetSuccess()) {
2300 oprot.writeBool(struct.success);
2301 }
2302 if (struct.isSetIo()) {
2303 struct.io.write(oprot);
2304 }
2305 }
2306
2307 @Override
2308 public void read(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2309 TTupleProtocol iprot = (TTupleProtocol) prot;
2310 BitSet incoming = iprot.readBitSet(2);
2311 if (incoming.get(0)) {
2312 struct.success = iprot.readBool();
2313 struct.setSuccessIsSet(true);
2314 }
2315 if (incoming.get(1)) {
2316 struct.io = new TIOError();
2317 struct.io.read(iprot);
2318 struct.setIoIsSet(true);
2319 }
2320 }
2321 }
2322
2323 }
2324
2325 public static class get_args implements org.apache.thrift.TBase<get_args, get_args._Fields>, java.io.Serializable, Cloneable {
2326 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_args");
2327
2328 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);
2329 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);
2330
2331 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2332 static {
2333 schemes.put(StandardScheme.class, new get_argsStandardSchemeFactory());
2334 schemes.put(TupleScheme.class, new get_argsTupleSchemeFactory());
2335 }
2336
2337
2338
2339
2340 public ByteBuffer table;
2341
2342
2343
2344 public TGet get;
2345
2346
2347 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2348
2349
2350
2351 TABLE((short)1, "table"),
2352
2353
2354
2355 GET((short)2, "get");
2356
2357 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2358
2359 static {
2360 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2361 byName.put(field.getFieldName(), field);
2362 }
2363 }
2364
2365
2366
2367
2368 public static _Fields findByThriftId(int fieldId) {
2369 switch(fieldId) {
2370 case 1:
2371 return TABLE;
2372 case 2:
2373 return GET;
2374 default:
2375 return null;
2376 }
2377 }
2378
2379
2380
2381
2382
2383 public static _Fields findByThriftIdOrThrow(int fieldId) {
2384 _Fields fields = findByThriftId(fieldId);
2385 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2386 return fields;
2387 }
2388
2389
2390
2391
2392 public static _Fields findByName(String name) {
2393 return byName.get(name);
2394 }
2395
2396 private final short _thriftId;
2397 private final String _fieldName;
2398
2399 _Fields(short thriftId, String fieldName) {
2400 _thriftId = thriftId;
2401 _fieldName = fieldName;
2402 }
2403
2404 public short getThriftFieldId() {
2405 return _thriftId;
2406 }
2407
2408 public String getFieldName() {
2409 return _fieldName;
2410 }
2411 }
2412
2413
2414 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2415 static {
2416 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2417 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
2418 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
2419 tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED,
2420 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
2421 metaDataMap = Collections.unmodifiableMap(tmpMap);
2422 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
2423 }
2424
2425 public get_args() {
2426 }
2427
2428 public get_args(
2429 ByteBuffer table,
2430 TGet get)
2431 {
2432 this();
2433 this.table = table;
2434 this.get = get;
2435 }
2436
2437
2438
2439
2440 public get_args(get_args other) {
2441 if (other.isSetTable()) {
2442 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
2443 ;
2444 }
2445 if (other.isSetGet()) {
2446 this.get = new TGet(other.get);
2447 }
2448 }
2449
2450 public get_args deepCopy() {
2451 return new get_args(this);
2452 }
2453
2454 @Override
2455 public void clear() {
2456 this.table = null;
2457 this.get = null;
2458 }
2459
2460
2461
2462
2463 public byte[] getTable() {
2464 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
2465 return table == null ? null : table.array();
2466 }
2467
2468 public ByteBuffer bufferForTable() {
2469 return table;
2470 }
2471
2472
2473
2474
2475 public get_args setTable(byte[] table) {
2476 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
2477 return this;
2478 }
2479
2480 public get_args setTable(ByteBuffer table) {
2481 this.table = table;
2482 return this;
2483 }
2484
2485 public void unsetTable() {
2486 this.table = null;
2487 }
2488
2489
2490 public boolean isSetTable() {
2491 return this.table != null;
2492 }
2493
2494 public void setTableIsSet(boolean value) {
2495 if (!value) {
2496 this.table = null;
2497 }
2498 }
2499
2500
2501
2502
2503 public TGet getGet() {
2504 return this.get;
2505 }
2506
2507
2508
2509
2510 public get_args setGet(TGet get) {
2511 this.get = get;
2512 return this;
2513 }
2514
2515 public void unsetGet() {
2516 this.get = null;
2517 }
2518
2519
2520 public boolean isSetGet() {
2521 return this.get != null;
2522 }
2523
2524 public void setGetIsSet(boolean value) {
2525 if (!value) {
2526 this.get = null;
2527 }
2528 }
2529
2530 public void setFieldValue(_Fields field, Object value) {
2531 switch (field) {
2532 case TABLE:
2533 if (value == null) {
2534 unsetTable();
2535 } else {
2536 setTable((ByteBuffer)value);
2537 }
2538 break;
2539
2540 case GET:
2541 if (value == null) {
2542 unsetGet();
2543 } else {
2544 setGet((TGet)value);
2545 }
2546 break;
2547
2548 }
2549 }
2550
2551 public Object getFieldValue(_Fields field) {
2552 switch (field) {
2553 case TABLE:
2554 return getTable();
2555
2556 case GET:
2557 return getGet();
2558
2559 }
2560 throw new IllegalStateException();
2561 }
2562
2563
2564 public boolean isSet(_Fields field) {
2565 if (field == null) {
2566 throw new IllegalArgumentException();
2567 }
2568
2569 switch (field) {
2570 case TABLE:
2571 return isSetTable();
2572 case GET:
2573 return isSetGet();
2574 }
2575 throw new IllegalStateException();
2576 }
2577
2578 @Override
2579 public boolean equals(Object that) {
2580 if (that == null)
2581 return false;
2582 if (that instanceof get_args)
2583 return this.equals((get_args)that);
2584 return false;
2585 }
2586
2587 public boolean equals(get_args that) {
2588 if (that == null)
2589 return false;
2590
2591 boolean this_present_table = true && this.isSetTable();
2592 boolean that_present_table = true && that.isSetTable();
2593 if (this_present_table || that_present_table) {
2594 if (!(this_present_table && that_present_table))
2595 return false;
2596 if (!this.table.equals(that.table))
2597 return false;
2598 }
2599
2600 boolean this_present_get = true && this.isSetGet();
2601 boolean that_present_get = true && that.isSetGet();
2602 if (this_present_get || that_present_get) {
2603 if (!(this_present_get && that_present_get))
2604 return false;
2605 if (!this.get.equals(that.get))
2606 return false;
2607 }
2608
2609 return true;
2610 }
2611
2612 @Override
2613 public int hashCode() {
2614 return 0;
2615 }
2616
2617 public int compareTo(get_args other) {
2618 if (!getClass().equals(other.getClass())) {
2619 return getClass().getName().compareTo(other.getClass().getName());
2620 }
2621
2622 int lastComparison = 0;
2623 get_args typedOther = (get_args)other;
2624
2625 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
2626 if (lastComparison != 0) {
2627 return lastComparison;
2628 }
2629 if (isSetTable()) {
2630 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
2631 if (lastComparison != 0) {
2632 return lastComparison;
2633 }
2634 }
2635 lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
2636 if (lastComparison != 0) {
2637 return lastComparison;
2638 }
2639 if (isSetGet()) {
2640 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
2641 if (lastComparison != 0) {
2642 return lastComparison;
2643 }
2644 }
2645 return 0;
2646 }
2647
2648 public _Fields fieldForId(int fieldId) {
2649 return _Fields.findByThriftId(fieldId);
2650 }
2651
2652 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2653 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2654 }
2655
2656 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2657 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2658 }
2659
2660 @Override
2661 public String toString() {
2662 StringBuilder sb = new StringBuilder("get_args(");
2663 boolean first = true;
2664
2665 sb.append("table:");
2666 if (this.table == null) {
2667 sb.append("null");
2668 } else {
2669 org.apache.thrift.TBaseHelper.toString(this.table, sb);
2670 }
2671 first = false;
2672 if (!first) sb.append(", ");
2673 sb.append("get:");
2674 if (this.get == null) {
2675 sb.append("null");
2676 } else {
2677 sb.append(this.get);
2678 }
2679 first = false;
2680 sb.append(")");
2681 return sb.toString();
2682 }
2683
2684 public void validate() throws org.apache.thrift.TException {
2685
2686 if (table == null) {
2687 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
2688 }
2689 if (get == null) {
2690 throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
2691 }
2692 }
2693
2694 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2695 try {
2696 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2697 } catch (org.apache.thrift.TException te) {
2698 throw new java.io.IOException(te);
2699 }
2700 }
2701
2702 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2703 try {
2704 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2705 } catch (org.apache.thrift.TException te) {
2706 throw new java.io.IOException(te);
2707 }
2708 }
2709
2710 private static class get_argsStandardSchemeFactory implements SchemeFactory {
2711 public get_argsStandardScheme getScheme() {
2712 return new get_argsStandardScheme();
2713 }
2714 }
2715
2716 private static class get_argsStandardScheme extends StandardScheme<get_args> {
2717
2718 public void read(org.apache.thrift.protocol.TProtocol iprot, get_args struct) throws org.apache.thrift.TException {
2719 org.apache.thrift.protocol.TField schemeField;
2720 iprot.readStructBegin();
2721 while (true)
2722 {
2723 schemeField = iprot.readFieldBegin();
2724 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
2725 break;
2726 }
2727 switch (schemeField.id) {
2728 case 1:
2729 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
2730 struct.table = iprot.readBinary();
2731 struct.setTableIsSet(true);
2732 } else {
2733 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2734 }
2735 break;
2736 case 2:
2737 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2738 struct.get = new TGet();
2739 struct.get.read(iprot);
2740 struct.setGetIsSet(true);
2741 } else {
2742 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2743 }
2744 break;
2745 default:
2746 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2747 }
2748 iprot.readFieldEnd();
2749 }
2750 iprot.readStructEnd();
2751
2752
2753 struct.validate();
2754 }
2755
2756 public void write(org.apache.thrift.protocol.TProtocol oprot, get_args struct) throws org.apache.thrift.TException {
2757 struct.validate();
2758
2759 oprot.writeStructBegin(STRUCT_DESC);
2760 if (struct.table != null) {
2761 oprot.writeFieldBegin(TABLE_FIELD_DESC);
2762 oprot.writeBinary(struct.table);
2763 oprot.writeFieldEnd();
2764 }
2765 if (struct.get != null) {
2766 oprot.writeFieldBegin(GET_FIELD_DESC);
2767 struct.get.write(oprot);
2768 oprot.writeFieldEnd();
2769 }
2770 oprot.writeFieldStop();
2771 oprot.writeStructEnd();
2772 }
2773
2774 }
2775
2776 private static class get_argsTupleSchemeFactory implements SchemeFactory {
2777 public get_argsTupleScheme getScheme() {
2778 return new get_argsTupleScheme();
2779 }
2780 }
2781
2782 private static class get_argsTupleScheme extends TupleScheme<get_args> {
2783
2784 @Override
2785 public void write(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2786 TTupleProtocol oprot = (TTupleProtocol) prot;
2787 oprot.writeBinary(struct.table);
2788 struct.get.write(oprot);
2789 }
2790
2791 @Override
2792 public void read(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2793 TTupleProtocol iprot = (TTupleProtocol) prot;
2794 struct.table = iprot.readBinary();
2795 struct.setTableIsSet(true);
2796 struct.get = new TGet();
2797 struct.get.read(iprot);
2798 struct.setGetIsSet(true);
2799 }
2800 }
2801
2802 }
2803
2804 public static class get_result implements org.apache.thrift.TBase<get_result, get_result._Fields>, java.io.Serializable, Cloneable {
2805 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_result");
2806
2807 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);
2808 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);
2809
2810 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2811 static {
2812 schemes.put(StandardScheme.class, new get_resultStandardSchemeFactory());
2813 schemes.put(TupleScheme.class, new get_resultTupleSchemeFactory());
2814 }
2815
2816 public TResult success;
2817 public TIOError io;
2818
2819
2820 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2821 SUCCESS((short)0, "success"),
2822 IO((short)1, "io");
2823
2824 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2825
2826 static {
2827 for (_Fields field : EnumSet.allOf(_Fields.class)) {
2828 byName.put(field.getFieldName(), field);
2829 }
2830 }
2831
2832
2833
2834
2835 public static _Fields findByThriftId(int fieldId) {
2836 switch(fieldId) {
2837 case 0:
2838 return SUCCESS;
2839 case 1:
2840 return IO;
2841 default:
2842 return null;
2843 }
2844 }
2845
2846
2847
2848
2849
2850 public static _Fields findByThriftIdOrThrow(int fieldId) {
2851 _Fields fields = findByThriftId(fieldId);
2852 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2853 return fields;
2854 }
2855
2856
2857
2858
2859 public static _Fields findByName(String name) {
2860 return byName.get(name);
2861 }
2862
2863 private final short _thriftId;
2864 private final String _fieldName;
2865
2866 _Fields(short thriftId, String fieldName) {
2867 _thriftId = thriftId;
2868 _fieldName = fieldName;
2869 }
2870
2871 public short getThriftFieldId() {
2872 return _thriftId;
2873 }
2874
2875 public String getFieldName() {
2876 return _fieldName;
2877 }
2878 }
2879
2880
2881 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2882 static {
2883 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2884 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
2885 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
2886 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
2887 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
2888 metaDataMap = Collections.unmodifiableMap(tmpMap);
2889 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
2890 }
2891
2892 public get_result() {
2893 }
2894
2895 public get_result(
2896 TResult success,
2897 TIOError io)
2898 {
2899 this();
2900 this.success = success;
2901 this.io = io;
2902 }
2903
2904
2905
2906
2907 public get_result(get_result other) {
2908 if (other.isSetSuccess()) {
2909 this.success = new TResult(other.success);
2910 }
2911 if (other.isSetIo()) {
2912 this.io = new TIOError(other.io);
2913 }
2914 }
2915
2916 public get_result deepCopy() {
2917 return new get_result(this);
2918 }
2919
2920 @Override
2921 public void clear() {
2922 this.success = null;
2923 this.io = null;
2924 }
2925
2926 public TResult getSuccess() {
2927 return this.success;
2928 }
2929
2930 public get_result setSuccess(TResult success) {
2931 this.success = success;
2932 return this;
2933 }
2934
2935 public void unsetSuccess() {
2936 this.success = null;
2937 }
2938
2939
2940 public boolean isSetSuccess() {
2941 return this.success != null;
2942 }
2943
2944 public void setSuccessIsSet(boolean value) {
2945 if (!value) {
2946 this.success = null;
2947 }
2948 }
2949
2950 public TIOError getIo() {
2951 return this.io;
2952 }
2953
2954 public get_result setIo(TIOError io) {
2955 this.io = io;
2956 return this;
2957 }
2958
2959 public void unsetIo() {
2960 this.io = null;
2961 }
2962
2963
2964 public boolean isSetIo() {
2965 return this.io != null;
2966 }
2967
2968 public void setIoIsSet(boolean value) {
2969 if (!value) {
2970 this.io = null;
2971 }
2972 }
2973
2974 public void setFieldValue(_Fields field, Object value) {
2975 switch (field) {
2976 case SUCCESS:
2977 if (value == null) {
2978 unsetSuccess();
2979 } else {
2980 setSuccess((TResult)value);
2981 }
2982 break;
2983
2984 case IO:
2985 if (value == null) {
2986 unsetIo();
2987 } else {
2988 setIo((TIOError)value);
2989 }
2990 break;
2991
2992 }
2993 }
2994
2995 public Object getFieldValue(_Fields field) {
2996 switch (field) {
2997 case SUCCESS:
2998 return getSuccess();
2999
3000 case IO:
3001 return getIo();
3002
3003 }
3004 throw new IllegalStateException();
3005 }
3006
3007
3008 public boolean isSet(_Fields field) {
3009 if (field == null) {
3010 throw new IllegalArgumentException();
3011 }
3012
3013 switch (field) {
3014 case SUCCESS:
3015 return isSetSuccess();
3016 case IO:
3017 return isSetIo();
3018 }
3019 throw new IllegalStateException();
3020 }
3021
3022 @Override
3023 public boolean equals(Object that) {
3024 if (that == null)
3025 return false;
3026 if (that instanceof get_result)
3027 return this.equals((get_result)that);
3028 return false;
3029 }
3030
3031 public boolean equals(get_result that) {
3032 if (that == null)
3033 return false;
3034
3035 boolean this_present_success = true && this.isSetSuccess();
3036 boolean that_present_success = true && that.isSetSuccess();
3037 if (this_present_success || that_present_success) {
3038 if (!(this_present_success && that_present_success))
3039 return false;
3040 if (!this.success.equals(that.success))
3041 return false;
3042 }
3043
3044 boolean this_present_io = true && this.isSetIo();
3045 boolean that_present_io = true && that.isSetIo();
3046 if (this_present_io || that_present_io) {
3047 if (!(this_present_io && that_present_io))
3048 return false;
3049 if (!this.io.equals(that.io))
3050 return false;
3051 }
3052
3053 return true;
3054 }
3055
3056 @Override
3057 public int hashCode() {
3058 return 0;
3059 }
3060
3061 public int compareTo(get_result other) {
3062 if (!getClass().equals(other.getClass())) {
3063 return getClass().getName().compareTo(other.getClass().getName());
3064 }
3065
3066 int lastComparison = 0;
3067 get_result typedOther = (get_result)other;
3068
3069 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
3070 if (lastComparison != 0) {
3071 return lastComparison;
3072 }
3073 if (isSetSuccess()) {
3074 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
3075 if (lastComparison != 0) {
3076 return lastComparison;
3077 }
3078 }
3079 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
3080 if (lastComparison != 0) {
3081 return lastComparison;
3082 }
3083 if (isSetIo()) {
3084 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
3085 if (lastComparison != 0) {
3086 return lastComparison;
3087 }
3088 }
3089 return 0;
3090 }
3091
3092 public _Fields fieldForId(int fieldId) {
3093 return _Fields.findByThriftId(fieldId);
3094 }
3095
3096 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3097 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3098 }
3099
3100 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3101 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3102 }
3103
3104 @Override
3105 public String toString() {
3106 StringBuilder sb = new StringBuilder("get_result(");
3107 boolean first = true;
3108
3109 sb.append("success:");
3110 if (this.success == null) {
3111 sb.append("null");
3112 } else {
3113 sb.append(this.success);
3114 }
3115 first = false;
3116 if (!first) sb.append(", ");
3117 sb.append("io:");
3118 if (this.io == null) {
3119 sb.append("null");
3120 } else {
3121 sb.append(this.io);
3122 }
3123 first = false;
3124 sb.append(")");
3125 return sb.toString();
3126 }
3127
3128 public void validate() throws org.apache.thrift.TException {
3129
3130 }
3131
3132 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3133 try {
3134 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3135 } catch (org.apache.thrift.TException te) {
3136 throw new java.io.IOException(te);
3137 }
3138 }
3139
3140 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3141 try {
3142 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3143 } catch (org.apache.thrift.TException te) {
3144 throw new java.io.IOException(te);
3145 }
3146 }
3147
3148 private static class get_resultStandardSchemeFactory implements SchemeFactory {
3149 public get_resultStandardScheme getScheme() {
3150 return new get_resultStandardScheme();
3151 }
3152 }
3153
3154 private static class get_resultStandardScheme extends StandardScheme<get_result> {
3155
3156 public void read(org.apache.thrift.protocol.TProtocol iprot, get_result struct) throws org.apache.thrift.TException {
3157 org.apache.thrift.protocol.TField schemeField;
3158 iprot.readStructBegin();
3159 while (true)
3160 {
3161 schemeField = iprot.readFieldBegin();
3162 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3163 break;
3164 }
3165 switch (schemeField.id) {
3166 case 0:
3167 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3168 struct.success = new TResult();
3169 struct.success.read(iprot);
3170 struct.setSuccessIsSet(true);
3171 } else {
3172 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3173 }
3174 break;
3175 case 1:
3176 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3177 struct.io = new TIOError();
3178 struct.io.read(iprot);
3179 struct.setIoIsSet(true);
3180 } else {
3181 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3182 }
3183 break;
3184 default:
3185 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3186 }
3187 iprot.readFieldEnd();
3188 }
3189 iprot.readStructEnd();
3190
3191
3192 struct.validate();
3193 }
3194
3195 public void write(org.apache.thrift.protocol.TProtocol oprot, get_result struct) throws org.apache.thrift.TException {
3196 struct.validate();
3197
3198 oprot.writeStructBegin(STRUCT_DESC);
3199 if (struct.success != null) {
3200 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3201 struct.success.write(oprot);
3202 oprot.writeFieldEnd();
3203 }
3204 if (struct.io != null) {
3205 oprot.writeFieldBegin(IO_FIELD_DESC);
3206 struct.io.write(oprot);
3207 oprot.writeFieldEnd();
3208 }
3209 oprot.writeFieldStop();
3210 oprot.writeStructEnd();
3211 }
3212
3213 }
3214
3215 private static class get_resultTupleSchemeFactory implements SchemeFactory {
3216 public get_resultTupleScheme getScheme() {
3217 return new get_resultTupleScheme();
3218 }
3219 }
3220
3221 private static class get_resultTupleScheme extends TupleScheme<get_result> {
3222
3223 @Override
3224 public void write(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3225 TTupleProtocol oprot = (TTupleProtocol) prot;
3226 BitSet optionals = new BitSet();
3227 if (struct.isSetSuccess()) {
3228 optionals.set(0);
3229 }
3230 if (struct.isSetIo()) {
3231 optionals.set(1);
3232 }
3233 oprot.writeBitSet(optionals, 2);
3234 if (struct.isSetSuccess()) {
3235 struct.success.write(oprot);
3236 }
3237 if (struct.isSetIo()) {
3238 struct.io.write(oprot);
3239 }
3240 }
3241
3242 @Override
3243 public void read(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3244 TTupleProtocol iprot = (TTupleProtocol) prot;
3245 BitSet incoming = iprot.readBitSet(2);
3246 if (incoming.get(0)) {
3247 struct.success = new TResult();
3248 struct.success.read(iprot);
3249 struct.setSuccessIsSet(true);
3250 }
3251 if (incoming.get(1)) {
3252 struct.io = new TIOError();
3253 struct.io.read(iprot);
3254 struct.setIoIsSet(true);
3255 }
3256 }
3257 }
3258
3259 }
3260
3261 public static class getMultiple_args implements org.apache.thrift.TBase<getMultiple_args, getMultiple_args._Fields>, java.io.Serializable, Cloneable {
3262 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_args");
3263
3264 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);
3265 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);
3266
3267 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3268 static {
3269 schemes.put(StandardScheme.class, new getMultiple_argsStandardSchemeFactory());
3270 schemes.put(TupleScheme.class, new getMultiple_argsTupleSchemeFactory());
3271 }
3272
3273
3274
3275
3276 public ByteBuffer table;
3277
3278
3279
3280
3281
3282 public List<TGet> gets;
3283
3284
3285 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3286
3287
3288
3289 TABLE((short)1, "table"),
3290
3291
3292
3293
3294
3295 GETS((short)2, "gets");
3296
3297 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3298
3299 static {
3300 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3301 byName.put(field.getFieldName(), field);
3302 }
3303 }
3304
3305
3306
3307
3308 public static _Fields findByThriftId(int fieldId) {
3309 switch(fieldId) {
3310 case 1:
3311 return TABLE;
3312 case 2:
3313 return GETS;
3314 default:
3315 return null;
3316 }
3317 }
3318
3319
3320
3321
3322
3323 public static _Fields findByThriftIdOrThrow(int fieldId) {
3324 _Fields fields = findByThriftId(fieldId);
3325 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3326 return fields;
3327 }
3328
3329
3330
3331
3332 public static _Fields findByName(String name) {
3333 return byName.get(name);
3334 }
3335
3336 private final short _thriftId;
3337 private final String _fieldName;
3338
3339 _Fields(short thriftId, String fieldName) {
3340 _thriftId = thriftId;
3341 _fieldName = fieldName;
3342 }
3343
3344 public short getThriftFieldId() {
3345 return _thriftId;
3346 }
3347
3348 public String getFieldName() {
3349 return _fieldName;
3350 }
3351 }
3352
3353
3354 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3355 static {
3356 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3357 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
3358 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
3359 tmpMap.put(_Fields.GETS, new org.apache.thrift.meta_data.FieldMetaData("gets", org.apache.thrift.TFieldRequirementType.REQUIRED,
3360 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
3361 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class))));
3362 metaDataMap = Collections.unmodifiableMap(tmpMap);
3363 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_args.class, metaDataMap);
3364 }
3365
3366 public getMultiple_args() {
3367 }
3368
3369 public getMultiple_args(
3370 ByteBuffer table,
3371 List<TGet> gets)
3372 {
3373 this();
3374 this.table = table;
3375 this.gets = gets;
3376 }
3377
3378
3379
3380
3381 public getMultiple_args(getMultiple_args other) {
3382 if (other.isSetTable()) {
3383 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
3384 ;
3385 }
3386 if (other.isSetGets()) {
3387 List<TGet> __this__gets = new ArrayList<TGet>();
3388 for (TGet other_element : other.gets) {
3389 __this__gets.add(new TGet(other_element));
3390 }
3391 this.gets = __this__gets;
3392 }
3393 }
3394
3395 public getMultiple_args deepCopy() {
3396 return new getMultiple_args(this);
3397 }
3398
3399 @Override
3400 public void clear() {
3401 this.table = null;
3402 this.gets = null;
3403 }
3404
3405
3406
3407
3408 public byte[] getTable() {
3409 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
3410 return table == null ? null : table.array();
3411 }
3412
3413 public ByteBuffer bufferForTable() {
3414 return table;
3415 }
3416
3417
3418
3419
3420 public getMultiple_args setTable(byte[] table) {
3421 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
3422 return this;
3423 }
3424
3425 public getMultiple_args setTable(ByteBuffer table) {
3426 this.table = table;
3427 return this;
3428 }
3429
3430 public void unsetTable() {
3431 this.table = null;
3432 }
3433
3434
3435 public boolean isSetTable() {
3436 return this.table != null;
3437 }
3438
3439 public void setTableIsSet(boolean value) {
3440 if (!value) {
3441 this.table = null;
3442 }
3443 }
3444
3445 public int getGetsSize() {
3446 return (this.gets == null) ? 0 : this.gets.size();
3447 }
3448
3449 public java.util.Iterator<TGet> getGetsIterator() {
3450 return (this.gets == null) ? null : this.gets.iterator();
3451 }
3452
3453 public void addToGets(TGet elem) {
3454 if (this.gets == null) {
3455 this.gets = new ArrayList<TGet>();
3456 }
3457 this.gets.add(elem);
3458 }
3459
3460
3461
3462
3463
3464
3465 public List<TGet> getGets() {
3466 return this.gets;
3467 }
3468
3469
3470
3471
3472
3473
3474 public getMultiple_args setGets(List<TGet> gets) {
3475 this.gets = gets;
3476 return this;
3477 }
3478
3479 public void unsetGets() {
3480 this.gets = null;
3481 }
3482
3483
3484 public boolean isSetGets() {
3485 return this.gets != null;
3486 }
3487
3488 public void setGetsIsSet(boolean value) {
3489 if (!value) {
3490 this.gets = null;
3491 }
3492 }
3493
3494 public void setFieldValue(_Fields field, Object value) {
3495 switch (field) {
3496 case TABLE:
3497 if (value == null) {
3498 unsetTable();
3499 } else {
3500 setTable((ByteBuffer)value);
3501 }
3502 break;
3503
3504 case GETS:
3505 if (value == null) {
3506 unsetGets();
3507 } else {
3508 setGets((List<TGet>)value);
3509 }
3510 break;
3511
3512 }
3513 }
3514
3515 public Object getFieldValue(_Fields field) {
3516 switch (field) {
3517 case TABLE:
3518 return getTable();
3519
3520 case GETS:
3521 return getGets();
3522
3523 }
3524 throw new IllegalStateException();
3525 }
3526
3527
3528 public boolean isSet(_Fields field) {
3529 if (field == null) {
3530 throw new IllegalArgumentException();
3531 }
3532
3533 switch (field) {
3534 case TABLE:
3535 return isSetTable();
3536 case GETS:
3537 return isSetGets();
3538 }
3539 throw new IllegalStateException();
3540 }
3541
3542 @Override
3543 public boolean equals(Object that) {
3544 if (that == null)
3545 return false;
3546 if (that instanceof getMultiple_args)
3547 return this.equals((getMultiple_args)that);
3548 return false;
3549 }
3550
3551 public boolean equals(getMultiple_args that) {
3552 if (that == null)
3553 return false;
3554
3555 boolean this_present_table = true && this.isSetTable();
3556 boolean that_present_table = true && that.isSetTable();
3557 if (this_present_table || that_present_table) {
3558 if (!(this_present_table && that_present_table))
3559 return false;
3560 if (!this.table.equals(that.table))
3561 return false;
3562 }
3563
3564 boolean this_present_gets = true && this.isSetGets();
3565 boolean that_present_gets = true && that.isSetGets();
3566 if (this_present_gets || that_present_gets) {
3567 if (!(this_present_gets && that_present_gets))
3568 return false;
3569 if (!this.gets.equals(that.gets))
3570 return false;
3571 }
3572
3573 return true;
3574 }
3575
3576 @Override
3577 public int hashCode() {
3578 return 0;
3579 }
3580
3581 public int compareTo(getMultiple_args other) {
3582 if (!getClass().equals(other.getClass())) {
3583 return getClass().getName().compareTo(other.getClass().getName());
3584 }
3585
3586 int lastComparison = 0;
3587 getMultiple_args typedOther = (getMultiple_args)other;
3588
3589 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
3590 if (lastComparison != 0) {
3591 return lastComparison;
3592 }
3593 if (isSetTable()) {
3594 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
3595 if (lastComparison != 0) {
3596 return lastComparison;
3597 }
3598 }
3599 lastComparison = Boolean.valueOf(isSetGets()).compareTo(typedOther.isSetGets());
3600 if (lastComparison != 0) {
3601 return lastComparison;
3602 }
3603 if (isSetGets()) {
3604 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gets, typedOther.gets);
3605 if (lastComparison != 0) {
3606 return lastComparison;
3607 }
3608 }
3609 return 0;
3610 }
3611
3612 public _Fields fieldForId(int fieldId) {
3613 return _Fields.findByThriftId(fieldId);
3614 }
3615
3616 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3617 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3618 }
3619
3620 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3621 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3622 }
3623
3624 @Override
3625 public String toString() {
3626 StringBuilder sb = new StringBuilder("getMultiple_args(");
3627 boolean first = true;
3628
3629 sb.append("table:");
3630 if (this.table == null) {
3631 sb.append("null");
3632 } else {
3633 org.apache.thrift.TBaseHelper.toString(this.table, sb);
3634 }
3635 first = false;
3636 if (!first) sb.append(", ");
3637 sb.append("gets:");
3638 if (this.gets == null) {
3639 sb.append("null");
3640 } else {
3641 sb.append(this.gets);
3642 }
3643 first = false;
3644 sb.append(")");
3645 return sb.toString();
3646 }
3647
3648 public void validate() throws org.apache.thrift.TException {
3649
3650 if (table == null) {
3651 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
3652 }
3653 if (gets == null) {
3654 throw new org.apache.thrift.protocol.TProtocolException("Required field 'gets' was not present! Struct: " + toString());
3655 }
3656 }
3657
3658 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3659 try {
3660 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3661 } catch (org.apache.thrift.TException te) {
3662 throw new java.io.IOException(te);
3663 }
3664 }
3665
3666 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3667 try {
3668 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3669 } catch (org.apache.thrift.TException te) {
3670 throw new java.io.IOException(te);
3671 }
3672 }
3673
3674 private static class getMultiple_argsStandardSchemeFactory implements SchemeFactory {
3675 public getMultiple_argsStandardScheme getScheme() {
3676 return new getMultiple_argsStandardScheme();
3677 }
3678 }
3679
3680 private static class getMultiple_argsStandardScheme extends StandardScheme<getMultiple_args> {
3681
3682 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_args struct) throws org.apache.thrift.TException {
3683 org.apache.thrift.protocol.TField schemeField;
3684 iprot.readStructBegin();
3685 while (true)
3686 {
3687 schemeField = iprot.readFieldBegin();
3688 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
3689 break;
3690 }
3691 switch (schemeField.id) {
3692 case 1:
3693 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
3694 struct.table = iprot.readBinary();
3695 struct.setTableIsSet(true);
3696 } else {
3697 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3698 }
3699 break;
3700 case 2:
3701 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
3702 {
3703 org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
3704 struct.gets = new ArrayList<TGet>(_list48.size);
3705 for (int _i49 = 0; _i49 < _list48.size; ++_i49)
3706 {
3707 TGet _elem50;
3708 _elem50 = new TGet();
3709 _elem50.read(iprot);
3710 struct.gets.add(_elem50);
3711 }
3712 iprot.readListEnd();
3713 }
3714 struct.setGetsIsSet(true);
3715 } else {
3716 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3717 }
3718 break;
3719 default:
3720 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3721 }
3722 iprot.readFieldEnd();
3723 }
3724 iprot.readStructEnd();
3725
3726
3727 struct.validate();
3728 }
3729
3730 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_args struct) throws org.apache.thrift.TException {
3731 struct.validate();
3732
3733 oprot.writeStructBegin(STRUCT_DESC);
3734 if (struct.table != null) {
3735 oprot.writeFieldBegin(TABLE_FIELD_DESC);
3736 oprot.writeBinary(struct.table);
3737 oprot.writeFieldEnd();
3738 }
3739 if (struct.gets != null) {
3740 oprot.writeFieldBegin(GETS_FIELD_DESC);
3741 {
3742 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.gets.size()));
3743 for (TGet _iter51 : struct.gets)
3744 {
3745 _iter51.write(oprot);
3746 }
3747 oprot.writeListEnd();
3748 }
3749 oprot.writeFieldEnd();
3750 }
3751 oprot.writeFieldStop();
3752 oprot.writeStructEnd();
3753 }
3754
3755 }
3756
3757 private static class getMultiple_argsTupleSchemeFactory implements SchemeFactory {
3758 public getMultiple_argsTupleScheme getScheme() {
3759 return new getMultiple_argsTupleScheme();
3760 }
3761 }
3762
3763 private static class getMultiple_argsTupleScheme extends TupleScheme<getMultiple_args> {
3764
3765 @Override
3766 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3767 TTupleProtocol oprot = (TTupleProtocol) prot;
3768 oprot.writeBinary(struct.table);
3769 {
3770 oprot.writeI32(struct.gets.size());
3771 for (TGet _iter52 : struct.gets)
3772 {
3773 _iter52.write(oprot);
3774 }
3775 }
3776 }
3777
3778 @Override
3779 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3780 TTupleProtocol iprot = (TTupleProtocol) prot;
3781 struct.table = iprot.readBinary();
3782 struct.setTableIsSet(true);
3783 {
3784 org.apache.thrift.protocol.TList _list53 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
3785 struct.gets = new ArrayList<TGet>(_list53.size);
3786 for (int _i54 = 0; _i54 < _list53.size; ++_i54)
3787 {
3788 TGet _elem55;
3789 _elem55 = new TGet();
3790 _elem55.read(iprot);
3791 struct.gets.add(_elem55);
3792 }
3793 }
3794 struct.setGetsIsSet(true);
3795 }
3796 }
3797
3798 }
3799
3800 public static class getMultiple_result implements org.apache.thrift.TBase<getMultiple_result, getMultiple_result._Fields>, java.io.Serializable, Cloneable {
3801 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_result");
3802
3803 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);
3804 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);
3805
3806 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3807 static {
3808 schemes.put(StandardScheme.class, new getMultiple_resultStandardSchemeFactory());
3809 schemes.put(TupleScheme.class, new getMultiple_resultTupleSchemeFactory());
3810 }
3811
3812 public List<TResult> success;
3813 public TIOError io;
3814
3815
3816 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3817 SUCCESS((short)0, "success"),
3818 IO((short)1, "io");
3819
3820 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3821
3822 static {
3823 for (_Fields field : EnumSet.allOf(_Fields.class)) {
3824 byName.put(field.getFieldName(), field);
3825 }
3826 }
3827
3828
3829
3830
3831 public static _Fields findByThriftId(int fieldId) {
3832 switch(fieldId) {
3833 case 0:
3834 return SUCCESS;
3835 case 1:
3836 return IO;
3837 default:
3838 return null;
3839 }
3840 }
3841
3842
3843
3844
3845
3846 public static _Fields findByThriftIdOrThrow(int fieldId) {
3847 _Fields fields = findByThriftId(fieldId);
3848 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3849 return fields;
3850 }
3851
3852
3853
3854
3855 public static _Fields findByName(String name) {
3856 return byName.get(name);
3857 }
3858
3859 private final short _thriftId;
3860 private final String _fieldName;
3861
3862 _Fields(short thriftId, String fieldName) {
3863 _thriftId = thriftId;
3864 _fieldName = fieldName;
3865 }
3866
3867 public short getThriftFieldId() {
3868 return _thriftId;
3869 }
3870
3871 public String getFieldName() {
3872 return _fieldName;
3873 }
3874 }
3875
3876
3877 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3878 static {
3879 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3880 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
3881 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
3882 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
3883 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
3884 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
3885 metaDataMap = Collections.unmodifiableMap(tmpMap);
3886 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_result.class, metaDataMap);
3887 }
3888
3889 public getMultiple_result() {
3890 }
3891
3892 public getMultiple_result(
3893 List<TResult> success,
3894 TIOError io)
3895 {
3896 this();
3897 this.success = success;
3898 this.io = io;
3899 }
3900
3901
3902
3903
3904 public getMultiple_result(getMultiple_result other) {
3905 if (other.isSetSuccess()) {
3906 List<TResult> __this__success = new ArrayList<TResult>();
3907 for (TResult other_element : other.success) {
3908 __this__success.add(new TResult(other_element));
3909 }
3910 this.success = __this__success;
3911 }
3912 if (other.isSetIo()) {
3913 this.io = new TIOError(other.io);
3914 }
3915 }
3916
3917 public getMultiple_result deepCopy() {
3918 return new getMultiple_result(this);
3919 }
3920
3921 @Override
3922 public void clear() {
3923 this.success = null;
3924 this.io = null;
3925 }
3926
3927 public int getSuccessSize() {
3928 return (this.success == null) ? 0 : this.success.size();
3929 }
3930
3931 public java.util.Iterator<TResult> getSuccessIterator() {
3932 return (this.success == null) ? null : this.success.iterator();
3933 }
3934
3935 public void addToSuccess(TResult elem) {
3936 if (this.success == null) {
3937 this.success = new ArrayList<TResult>();
3938 }
3939 this.success.add(elem);
3940 }
3941
3942 public List<TResult> getSuccess() {
3943 return this.success;
3944 }
3945
3946 public getMultiple_result setSuccess(List<TResult> success) {
3947 this.success = success;
3948 return this;
3949 }
3950
3951 public void unsetSuccess() {
3952 this.success = null;
3953 }
3954
3955
3956 public boolean isSetSuccess() {
3957 return this.success != null;
3958 }
3959
3960 public void setSuccessIsSet(boolean value) {
3961 if (!value) {
3962 this.success = null;
3963 }
3964 }
3965
3966 public TIOError getIo() {
3967 return this.io;
3968 }
3969
3970 public getMultiple_result setIo(TIOError io) {
3971 this.io = io;
3972 return this;
3973 }
3974
3975 public void unsetIo() {
3976 this.io = null;
3977 }
3978
3979
3980 public boolean isSetIo() {
3981 return this.io != null;
3982 }
3983
3984 public void setIoIsSet(boolean value) {
3985 if (!value) {
3986 this.io = null;
3987 }
3988 }
3989
3990 public void setFieldValue(_Fields field, Object value) {
3991 switch (field) {
3992 case SUCCESS:
3993 if (value == null) {
3994 unsetSuccess();
3995 } else {
3996 setSuccess((List<TResult>)value);
3997 }
3998 break;
3999
4000 case IO:
4001 if (value == null) {
4002 unsetIo();
4003 } else {
4004 setIo((TIOError)value);
4005 }
4006 break;
4007
4008 }
4009 }
4010
4011 public Object getFieldValue(_Fields field) {
4012 switch (field) {
4013 case SUCCESS:
4014 return getSuccess();
4015
4016 case IO:
4017 return getIo();
4018
4019 }
4020 throw new IllegalStateException();
4021 }
4022
4023
4024 public boolean isSet(_Fields field) {
4025 if (field == null) {
4026 throw new IllegalArgumentException();
4027 }
4028
4029 switch (field) {
4030 case SUCCESS:
4031 return isSetSuccess();
4032 case IO:
4033 return isSetIo();
4034 }
4035 throw new IllegalStateException();
4036 }
4037
4038 @Override
4039 public boolean equals(Object that) {
4040 if (that == null)
4041 return false;
4042 if (that instanceof getMultiple_result)
4043 return this.equals((getMultiple_result)that);
4044 return false;
4045 }
4046
4047 public boolean equals(getMultiple_result that) {
4048 if (that == null)
4049 return false;
4050
4051 boolean this_present_success = true && this.isSetSuccess();
4052 boolean that_present_success = true && that.isSetSuccess();
4053 if (this_present_success || that_present_success) {
4054 if (!(this_present_success && that_present_success))
4055 return false;
4056 if (!this.success.equals(that.success))
4057 return false;
4058 }
4059
4060 boolean this_present_io = true && this.isSetIo();
4061 boolean that_present_io = true && that.isSetIo();
4062 if (this_present_io || that_present_io) {
4063 if (!(this_present_io && that_present_io))
4064 return false;
4065 if (!this.io.equals(that.io))
4066 return false;
4067 }
4068
4069 return true;
4070 }
4071
4072 @Override
4073 public int hashCode() {
4074 return 0;
4075 }
4076
4077 public int compareTo(getMultiple_result other) {
4078 if (!getClass().equals(other.getClass())) {
4079 return getClass().getName().compareTo(other.getClass().getName());
4080 }
4081
4082 int lastComparison = 0;
4083 getMultiple_result typedOther = (getMultiple_result)other;
4084
4085 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
4086 if (lastComparison != 0) {
4087 return lastComparison;
4088 }
4089 if (isSetSuccess()) {
4090 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
4091 if (lastComparison != 0) {
4092 return lastComparison;
4093 }
4094 }
4095 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
4096 if (lastComparison != 0) {
4097 return lastComparison;
4098 }
4099 if (isSetIo()) {
4100 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
4101 if (lastComparison != 0) {
4102 return lastComparison;
4103 }
4104 }
4105 return 0;
4106 }
4107
4108 public _Fields fieldForId(int fieldId) {
4109 return _Fields.findByThriftId(fieldId);
4110 }
4111
4112 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4113 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4114 }
4115
4116 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4117 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4118 }
4119
4120 @Override
4121 public String toString() {
4122 StringBuilder sb = new StringBuilder("getMultiple_result(");
4123 boolean first = true;
4124
4125 sb.append("success:");
4126 if (this.success == null) {
4127 sb.append("null");
4128 } else {
4129 sb.append(this.success);
4130 }
4131 first = false;
4132 if (!first) sb.append(", ");
4133 sb.append("io:");
4134 if (this.io == null) {
4135 sb.append("null");
4136 } else {
4137 sb.append(this.io);
4138 }
4139 first = false;
4140 sb.append(")");
4141 return sb.toString();
4142 }
4143
4144 public void validate() throws org.apache.thrift.TException {
4145
4146 }
4147
4148 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4149 try {
4150 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4151 } catch (org.apache.thrift.TException te) {
4152 throw new java.io.IOException(te);
4153 }
4154 }
4155
4156 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4157 try {
4158 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4159 } catch (org.apache.thrift.TException te) {
4160 throw new java.io.IOException(te);
4161 }
4162 }
4163
4164 private static class getMultiple_resultStandardSchemeFactory implements SchemeFactory {
4165 public getMultiple_resultStandardScheme getScheme() {
4166 return new getMultiple_resultStandardScheme();
4167 }
4168 }
4169
4170 private static class getMultiple_resultStandardScheme extends StandardScheme<getMultiple_result> {
4171
4172 public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_result struct) throws org.apache.thrift.TException {
4173 org.apache.thrift.protocol.TField schemeField;
4174 iprot.readStructBegin();
4175 while (true)
4176 {
4177 schemeField = iprot.readFieldBegin();
4178 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4179 break;
4180 }
4181 switch (schemeField.id) {
4182 case 0:
4183 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
4184 {
4185 org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
4186 struct.success = new ArrayList<TResult>(_list56.size);
4187 for (int _i57 = 0; _i57 < _list56.size; ++_i57)
4188 {
4189 TResult _elem58;
4190 _elem58 = new TResult();
4191 _elem58.read(iprot);
4192 struct.success.add(_elem58);
4193 }
4194 iprot.readListEnd();
4195 }
4196 struct.setSuccessIsSet(true);
4197 } else {
4198 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4199 }
4200 break;
4201 case 1:
4202 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4203 struct.io = new TIOError();
4204 struct.io.read(iprot);
4205 struct.setIoIsSet(true);
4206 } else {
4207 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4208 }
4209 break;
4210 default:
4211 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4212 }
4213 iprot.readFieldEnd();
4214 }
4215 iprot.readStructEnd();
4216
4217
4218 struct.validate();
4219 }
4220
4221 public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_result struct) throws org.apache.thrift.TException {
4222 struct.validate();
4223
4224 oprot.writeStructBegin(STRUCT_DESC);
4225 if (struct.success != null) {
4226 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4227 {
4228 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
4229 for (TResult _iter59 : struct.success)
4230 {
4231 _iter59.write(oprot);
4232 }
4233 oprot.writeListEnd();
4234 }
4235 oprot.writeFieldEnd();
4236 }
4237 if (struct.io != null) {
4238 oprot.writeFieldBegin(IO_FIELD_DESC);
4239 struct.io.write(oprot);
4240 oprot.writeFieldEnd();
4241 }
4242 oprot.writeFieldStop();
4243 oprot.writeStructEnd();
4244 }
4245
4246 }
4247
4248 private static class getMultiple_resultTupleSchemeFactory implements SchemeFactory {
4249 public getMultiple_resultTupleScheme getScheme() {
4250 return new getMultiple_resultTupleScheme();
4251 }
4252 }
4253
4254 private static class getMultiple_resultTupleScheme extends TupleScheme<getMultiple_result> {
4255
4256 @Override
4257 public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4258 TTupleProtocol oprot = (TTupleProtocol) prot;
4259 BitSet optionals = new BitSet();
4260 if (struct.isSetSuccess()) {
4261 optionals.set(0);
4262 }
4263 if (struct.isSetIo()) {
4264 optionals.set(1);
4265 }
4266 oprot.writeBitSet(optionals, 2);
4267 if (struct.isSetSuccess()) {
4268 {
4269 oprot.writeI32(struct.success.size());
4270 for (TResult _iter60 : struct.success)
4271 {
4272 _iter60.write(oprot);
4273 }
4274 }
4275 }
4276 if (struct.isSetIo()) {
4277 struct.io.write(oprot);
4278 }
4279 }
4280
4281 @Override
4282 public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4283 TTupleProtocol iprot = (TTupleProtocol) prot;
4284 BitSet incoming = iprot.readBitSet(2);
4285 if (incoming.get(0)) {
4286 {
4287 org.apache.thrift.protocol.TList _list61 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
4288 struct.success = new ArrayList<TResult>(_list61.size);
4289 for (int _i62 = 0; _i62 < _list61.size; ++_i62)
4290 {
4291 TResult _elem63;
4292 _elem63 = new TResult();
4293 _elem63.read(iprot);
4294 struct.success.add(_elem63);
4295 }
4296 }
4297 struct.setSuccessIsSet(true);
4298 }
4299 if (incoming.get(1)) {
4300 struct.io = new TIOError();
4301 struct.io.read(iprot);
4302 struct.setIoIsSet(true);
4303 }
4304 }
4305 }
4306
4307 }
4308
4309 public static class put_args implements org.apache.thrift.TBase<put_args, put_args._Fields>, java.io.Serializable, Cloneable {
4310 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_args");
4311
4312 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);
4313 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);
4314
4315 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4316 static {
4317 schemes.put(StandardScheme.class, new put_argsStandardSchemeFactory());
4318 schemes.put(TupleScheme.class, new put_argsTupleSchemeFactory());
4319 }
4320
4321
4322
4323
4324 public ByteBuffer table;
4325
4326
4327
4328 public TPut put;
4329
4330
4331 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4332
4333
4334
4335 TABLE((short)1, "table"),
4336
4337
4338
4339 PUT((short)2, "put");
4340
4341 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4342
4343 static {
4344 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4345 byName.put(field.getFieldName(), field);
4346 }
4347 }
4348
4349
4350
4351
4352 public static _Fields findByThriftId(int fieldId) {
4353 switch(fieldId) {
4354 case 1:
4355 return TABLE;
4356 case 2:
4357 return PUT;
4358 default:
4359 return null;
4360 }
4361 }
4362
4363
4364
4365
4366
4367 public static _Fields findByThriftIdOrThrow(int fieldId) {
4368 _Fields fields = findByThriftId(fieldId);
4369 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4370 return fields;
4371 }
4372
4373
4374
4375
4376 public static _Fields findByName(String name) {
4377 return byName.get(name);
4378 }
4379
4380 private final short _thriftId;
4381 private final String _fieldName;
4382
4383 _Fields(short thriftId, String fieldName) {
4384 _thriftId = thriftId;
4385 _fieldName = fieldName;
4386 }
4387
4388 public short getThriftFieldId() {
4389 return _thriftId;
4390 }
4391
4392 public String getFieldName() {
4393 return _fieldName;
4394 }
4395 }
4396
4397
4398 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4399 static {
4400 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4401 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
4402 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
4403 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
4404 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
4405 metaDataMap = Collections.unmodifiableMap(tmpMap);
4406 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_args.class, metaDataMap);
4407 }
4408
4409 public put_args() {
4410 }
4411
4412 public put_args(
4413 ByteBuffer table,
4414 TPut put)
4415 {
4416 this();
4417 this.table = table;
4418 this.put = put;
4419 }
4420
4421
4422
4423
4424 public put_args(put_args other) {
4425 if (other.isSetTable()) {
4426 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
4427 ;
4428 }
4429 if (other.isSetPut()) {
4430 this.put = new TPut(other.put);
4431 }
4432 }
4433
4434 public put_args deepCopy() {
4435 return new put_args(this);
4436 }
4437
4438 @Override
4439 public void clear() {
4440 this.table = null;
4441 this.put = null;
4442 }
4443
4444
4445
4446
4447 public byte[] getTable() {
4448 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
4449 return table == null ? null : table.array();
4450 }
4451
4452 public ByteBuffer bufferForTable() {
4453 return table;
4454 }
4455
4456
4457
4458
4459 public put_args setTable(byte[] table) {
4460 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
4461 return this;
4462 }
4463
4464 public put_args setTable(ByteBuffer table) {
4465 this.table = table;
4466 return this;
4467 }
4468
4469 public void unsetTable() {
4470 this.table = null;
4471 }
4472
4473
4474 public boolean isSetTable() {
4475 return this.table != null;
4476 }
4477
4478 public void setTableIsSet(boolean value) {
4479 if (!value) {
4480 this.table = null;
4481 }
4482 }
4483
4484
4485
4486
4487 public TPut getPut() {
4488 return this.put;
4489 }
4490
4491
4492
4493
4494 public put_args setPut(TPut put) {
4495 this.put = put;
4496 return this;
4497 }
4498
4499 public void unsetPut() {
4500 this.put = null;
4501 }
4502
4503
4504 public boolean isSetPut() {
4505 return this.put != null;
4506 }
4507
4508 public void setPutIsSet(boolean value) {
4509 if (!value) {
4510 this.put = null;
4511 }
4512 }
4513
4514 public void setFieldValue(_Fields field, Object value) {
4515 switch (field) {
4516 case TABLE:
4517 if (value == null) {
4518 unsetTable();
4519 } else {
4520 setTable((ByteBuffer)value);
4521 }
4522 break;
4523
4524 case PUT:
4525 if (value == null) {
4526 unsetPut();
4527 } else {
4528 setPut((TPut)value);
4529 }
4530 break;
4531
4532 }
4533 }
4534
4535 public Object getFieldValue(_Fields field) {
4536 switch (field) {
4537 case TABLE:
4538 return getTable();
4539
4540 case PUT:
4541 return getPut();
4542
4543 }
4544 throw new IllegalStateException();
4545 }
4546
4547
4548 public boolean isSet(_Fields field) {
4549 if (field == null) {
4550 throw new IllegalArgumentException();
4551 }
4552
4553 switch (field) {
4554 case TABLE:
4555 return isSetTable();
4556 case PUT:
4557 return isSetPut();
4558 }
4559 throw new IllegalStateException();
4560 }
4561
4562 @Override
4563 public boolean equals(Object that) {
4564 if (that == null)
4565 return false;
4566 if (that instanceof put_args)
4567 return this.equals((put_args)that);
4568 return false;
4569 }
4570
4571 public boolean equals(put_args that) {
4572 if (that == null)
4573 return false;
4574
4575 boolean this_present_table = true && this.isSetTable();
4576 boolean that_present_table = true && that.isSetTable();
4577 if (this_present_table || that_present_table) {
4578 if (!(this_present_table && that_present_table))
4579 return false;
4580 if (!this.table.equals(that.table))
4581 return false;
4582 }
4583
4584 boolean this_present_put = true && this.isSetPut();
4585 boolean that_present_put = true && that.isSetPut();
4586 if (this_present_put || that_present_put) {
4587 if (!(this_present_put && that_present_put))
4588 return false;
4589 if (!this.put.equals(that.put))
4590 return false;
4591 }
4592
4593 return true;
4594 }
4595
4596 @Override
4597 public int hashCode() {
4598 return 0;
4599 }
4600
4601 public int compareTo(put_args other) {
4602 if (!getClass().equals(other.getClass())) {
4603 return getClass().getName().compareTo(other.getClass().getName());
4604 }
4605
4606 int lastComparison = 0;
4607 put_args typedOther = (put_args)other;
4608
4609 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
4610 if (lastComparison != 0) {
4611 return lastComparison;
4612 }
4613 if (isSetTable()) {
4614 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
4615 if (lastComparison != 0) {
4616 return lastComparison;
4617 }
4618 }
4619 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
4620 if (lastComparison != 0) {
4621 return lastComparison;
4622 }
4623 if (isSetPut()) {
4624 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
4625 if (lastComparison != 0) {
4626 return lastComparison;
4627 }
4628 }
4629 return 0;
4630 }
4631
4632 public _Fields fieldForId(int fieldId) {
4633 return _Fields.findByThriftId(fieldId);
4634 }
4635
4636 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4637 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4638 }
4639
4640 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4641 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4642 }
4643
4644 @Override
4645 public String toString() {
4646 StringBuilder sb = new StringBuilder("put_args(");
4647 boolean first = true;
4648
4649 sb.append("table:");
4650 if (this.table == null) {
4651 sb.append("null");
4652 } else {
4653 org.apache.thrift.TBaseHelper.toString(this.table, sb);
4654 }
4655 first = false;
4656 if (!first) sb.append(", ");
4657 sb.append("put:");
4658 if (this.put == null) {
4659 sb.append("null");
4660 } else {
4661 sb.append(this.put);
4662 }
4663 first = false;
4664 sb.append(")");
4665 return sb.toString();
4666 }
4667
4668 public void validate() throws org.apache.thrift.TException {
4669
4670 if (table == null) {
4671 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
4672 }
4673 if (put == null) {
4674 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
4675 }
4676 }
4677
4678 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4679 try {
4680 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4681 } catch (org.apache.thrift.TException te) {
4682 throw new java.io.IOException(te);
4683 }
4684 }
4685
4686 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4687 try {
4688 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4689 } catch (org.apache.thrift.TException te) {
4690 throw new java.io.IOException(te);
4691 }
4692 }
4693
4694 private static class put_argsStandardSchemeFactory implements SchemeFactory {
4695 public put_argsStandardScheme getScheme() {
4696 return new put_argsStandardScheme();
4697 }
4698 }
4699
4700 private static class put_argsStandardScheme extends StandardScheme<put_args> {
4701
4702 public void read(org.apache.thrift.protocol.TProtocol iprot, put_args struct) throws org.apache.thrift.TException {
4703 org.apache.thrift.protocol.TField schemeField;
4704 iprot.readStructBegin();
4705 while (true)
4706 {
4707 schemeField = iprot.readFieldBegin();
4708 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
4709 break;
4710 }
4711 switch (schemeField.id) {
4712 case 1:
4713 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
4714 struct.table = iprot.readBinary();
4715 struct.setTableIsSet(true);
4716 } else {
4717 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4718 }
4719 break;
4720 case 2:
4721 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4722 struct.put = new TPut();
4723 struct.put.read(iprot);
4724 struct.setPutIsSet(true);
4725 } else {
4726 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4727 }
4728 break;
4729 default:
4730 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4731 }
4732 iprot.readFieldEnd();
4733 }
4734 iprot.readStructEnd();
4735
4736
4737 struct.validate();
4738 }
4739
4740 public void write(org.apache.thrift.protocol.TProtocol oprot, put_args struct) throws org.apache.thrift.TException {
4741 struct.validate();
4742
4743 oprot.writeStructBegin(STRUCT_DESC);
4744 if (struct.table != null) {
4745 oprot.writeFieldBegin(TABLE_FIELD_DESC);
4746 oprot.writeBinary(struct.table);
4747 oprot.writeFieldEnd();
4748 }
4749 if (struct.put != null) {
4750 oprot.writeFieldBegin(PUT_FIELD_DESC);
4751 struct.put.write(oprot);
4752 oprot.writeFieldEnd();
4753 }
4754 oprot.writeFieldStop();
4755 oprot.writeStructEnd();
4756 }
4757
4758 }
4759
4760 private static class put_argsTupleSchemeFactory implements SchemeFactory {
4761 public put_argsTupleScheme getScheme() {
4762 return new put_argsTupleScheme();
4763 }
4764 }
4765
4766 private static class put_argsTupleScheme extends TupleScheme<put_args> {
4767
4768 @Override
4769 public void write(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4770 TTupleProtocol oprot = (TTupleProtocol) prot;
4771 oprot.writeBinary(struct.table);
4772 struct.put.write(oprot);
4773 }
4774
4775 @Override
4776 public void read(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4777 TTupleProtocol iprot = (TTupleProtocol) prot;
4778 struct.table = iprot.readBinary();
4779 struct.setTableIsSet(true);
4780 struct.put = new TPut();
4781 struct.put.read(iprot);
4782 struct.setPutIsSet(true);
4783 }
4784 }
4785
4786 }
4787
4788 public static class put_result implements org.apache.thrift.TBase<put_result, put_result._Fields>, java.io.Serializable, Cloneable {
4789 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_result");
4790
4791 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);
4792
4793 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4794 static {
4795 schemes.put(StandardScheme.class, new put_resultStandardSchemeFactory());
4796 schemes.put(TupleScheme.class, new put_resultTupleSchemeFactory());
4797 }
4798
4799 public TIOError io;
4800
4801
4802 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4803 IO((short)1, "io");
4804
4805 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4806
4807 static {
4808 for (_Fields field : EnumSet.allOf(_Fields.class)) {
4809 byName.put(field.getFieldName(), field);
4810 }
4811 }
4812
4813
4814
4815
4816 public static _Fields findByThriftId(int fieldId) {
4817 switch(fieldId) {
4818 case 1:
4819 return IO;
4820 default:
4821 return null;
4822 }
4823 }
4824
4825
4826
4827
4828
4829 public static _Fields findByThriftIdOrThrow(int fieldId) {
4830 _Fields fields = findByThriftId(fieldId);
4831 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4832 return fields;
4833 }
4834
4835
4836
4837
4838 public static _Fields findByName(String name) {
4839 return byName.get(name);
4840 }
4841
4842 private final short _thriftId;
4843 private final String _fieldName;
4844
4845 _Fields(short thriftId, String fieldName) {
4846 _thriftId = thriftId;
4847 _fieldName = fieldName;
4848 }
4849
4850 public short getThriftFieldId() {
4851 return _thriftId;
4852 }
4853
4854 public String getFieldName() {
4855 return _fieldName;
4856 }
4857 }
4858
4859
4860 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4861 static {
4862 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4863 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
4864 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
4865 metaDataMap = Collections.unmodifiableMap(tmpMap);
4866 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_result.class, metaDataMap);
4867 }
4868
4869 public put_result() {
4870 }
4871
4872 public put_result(
4873 TIOError io)
4874 {
4875 this();
4876 this.io = io;
4877 }
4878
4879
4880
4881
4882 public put_result(put_result other) {
4883 if (other.isSetIo()) {
4884 this.io = new TIOError(other.io);
4885 }
4886 }
4887
4888 public put_result deepCopy() {
4889 return new put_result(this);
4890 }
4891
4892 @Override
4893 public void clear() {
4894 this.io = null;
4895 }
4896
4897 public TIOError getIo() {
4898 return this.io;
4899 }
4900
4901 public put_result setIo(TIOError io) {
4902 this.io = io;
4903 return this;
4904 }
4905
4906 public void unsetIo() {
4907 this.io = null;
4908 }
4909
4910
4911 public boolean isSetIo() {
4912 return this.io != null;
4913 }
4914
4915 public void setIoIsSet(boolean value) {
4916 if (!value) {
4917 this.io = null;
4918 }
4919 }
4920
4921 public void setFieldValue(_Fields field, Object value) {
4922 switch (field) {
4923 case IO:
4924 if (value == null) {
4925 unsetIo();
4926 } else {
4927 setIo((TIOError)value);
4928 }
4929 break;
4930
4931 }
4932 }
4933
4934 public Object getFieldValue(_Fields field) {
4935 switch (field) {
4936 case IO:
4937 return getIo();
4938
4939 }
4940 throw new IllegalStateException();
4941 }
4942
4943
4944 public boolean isSet(_Fields field) {
4945 if (field == null) {
4946 throw new IllegalArgumentException();
4947 }
4948
4949 switch (field) {
4950 case IO:
4951 return isSetIo();
4952 }
4953 throw new IllegalStateException();
4954 }
4955
4956 @Override
4957 public boolean equals(Object that) {
4958 if (that == null)
4959 return false;
4960 if (that instanceof put_result)
4961 return this.equals((put_result)that);
4962 return false;
4963 }
4964
4965 public boolean equals(put_result that) {
4966 if (that == null)
4967 return false;
4968
4969 boolean this_present_io = true && this.isSetIo();
4970 boolean that_present_io = true && that.isSetIo();
4971 if (this_present_io || that_present_io) {
4972 if (!(this_present_io && that_present_io))
4973 return false;
4974 if (!this.io.equals(that.io))
4975 return false;
4976 }
4977
4978 return true;
4979 }
4980
4981 @Override
4982 public int hashCode() {
4983 return 0;
4984 }
4985
4986 public int compareTo(put_result other) {
4987 if (!getClass().equals(other.getClass())) {
4988 return getClass().getName().compareTo(other.getClass().getName());
4989 }
4990
4991 int lastComparison = 0;
4992 put_result typedOther = (put_result)other;
4993
4994 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
4995 if (lastComparison != 0) {
4996 return lastComparison;
4997 }
4998 if (isSetIo()) {
4999 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
5000 if (lastComparison != 0) {
5001 return lastComparison;
5002 }
5003 }
5004 return 0;
5005 }
5006
5007 public _Fields fieldForId(int fieldId) {
5008 return _Fields.findByThriftId(fieldId);
5009 }
5010
5011 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
5012 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
5013 }
5014
5015 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
5016 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
5017 }
5018
5019 @Override
5020 public String toString() {
5021 StringBuilder sb = new StringBuilder("put_result(");
5022 boolean first = true;
5023
5024 sb.append("io:");
5025 if (this.io == null) {
5026 sb.append("null");
5027 } else {
5028 sb.append(this.io);
5029 }
5030 first = false;
5031 sb.append(")");
5032 return sb.toString();
5033 }
5034
5035 public void validate() throws org.apache.thrift.TException {
5036
5037 }
5038
5039 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
5040 try {
5041 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
5042 } catch (org.apache.thrift.TException te) {
5043 throw new java.io.IOException(te);
5044 }
5045 }
5046
5047 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
5048 try {
5049 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
5050 } catch (org.apache.thrift.TException te) {
5051 throw new java.io.IOException(te);
5052 }
5053 }
5054
5055 private static class put_resultStandardSchemeFactory implements SchemeFactory {
5056 public put_resultStandardScheme getScheme() {
5057 return new put_resultStandardScheme();
5058 }
5059 }
5060
5061 private static class put_resultStandardScheme extends StandardScheme<put_result> {
5062
5063 public void read(org.apache.thrift.protocol.TProtocol iprot, put_result struct) throws org.apache.thrift.TException {
5064 org.apache.thrift.protocol.TField schemeField;
5065 iprot.readStructBegin();
5066 while (true)
5067 {
5068 schemeField = iprot.readFieldBegin();
5069 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
5070 break;
5071 }
5072 switch (schemeField.id) {
5073 case 1:
5074 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
5075 struct.io = new TIOError();
5076 struct.io.read(iprot);
5077 struct.setIoIsSet(true);
5078 } else {
5079 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5080 }
5081 break;
5082 default:
5083 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5084 }
5085 iprot.readFieldEnd();
5086 }
5087 iprot.readStructEnd();
5088
5089
5090 struct.validate();
5091 }
5092
5093 public void write(org.apache.thrift.protocol.TProtocol oprot, put_result struct) throws org.apache.thrift.TException {
5094 struct.validate();
5095
5096 oprot.writeStructBegin(STRUCT_DESC);
5097 if (struct.io != null) {
5098 oprot.writeFieldBegin(IO_FIELD_DESC);
5099 struct.io.write(oprot);
5100 oprot.writeFieldEnd();
5101 }
5102 oprot.writeFieldStop();
5103 oprot.writeStructEnd();
5104 }
5105
5106 }
5107
5108 private static class put_resultTupleSchemeFactory implements SchemeFactory {
5109 public put_resultTupleScheme getScheme() {
5110 return new put_resultTupleScheme();
5111 }
5112 }
5113
5114 private static class put_resultTupleScheme extends TupleScheme<put_result> {
5115
5116 @Override
5117 public void write(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5118 TTupleProtocol oprot = (TTupleProtocol) prot;
5119 BitSet optionals = new BitSet();
5120 if (struct.isSetIo()) {
5121 optionals.set(0);
5122 }
5123 oprot.writeBitSet(optionals, 1);
5124 if (struct.isSetIo()) {
5125 struct.io.write(oprot);
5126 }
5127 }
5128
5129 @Override
5130 public void read(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5131 TTupleProtocol iprot = (TTupleProtocol) prot;
5132 BitSet incoming = iprot.readBitSet(1);
5133 if (incoming.get(0)) {
5134 struct.io = new TIOError();
5135 struct.io.read(iprot);
5136 struct.setIoIsSet(true);
5137 }
5138 }
5139 }
5140
5141 }
5142
5143 public static class checkAndPut_args implements org.apache.thrift.TBase<checkAndPut_args, checkAndPut_args._Fields>, java.io.Serializable, Cloneable {
5144 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_args");
5145
5146 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);
5147 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);
5148 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);
5149 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);
5150 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);
5151 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);
5152
5153 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
5154 static {
5155 schemes.put(StandardScheme.class, new checkAndPut_argsStandardSchemeFactory());
5156 schemes.put(TupleScheme.class, new checkAndPut_argsTupleSchemeFactory());
5157 }
5158
5159
5160
5161
5162 public ByteBuffer table;
5163
5164
5165
5166 public ByteBuffer row;
5167
5168
5169
5170 public ByteBuffer family;
5171
5172
5173
5174 public ByteBuffer qualifier;
5175
5176
5177
5178
5179
5180 public ByteBuffer value;
5181
5182
5183
5184 public TPut put;
5185
5186
5187 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
5188
5189
5190
5191 TABLE((short)1, "table"),
5192
5193
5194
5195 ROW((short)2, "row"),
5196
5197
5198
5199 FAMILY((short)3, "family"),
5200
5201
5202
5203 QUALIFIER((short)4, "qualifier"),
5204
5205
5206
5207
5208
5209 VALUE((short)5, "value"),
5210
5211
5212
5213 PUT((short)6, "put");
5214
5215 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5216
5217 static {
5218 for (_Fields field : EnumSet.allOf(_Fields.class)) {
5219 byName.put(field.getFieldName(), field);
5220 }
5221 }
5222
5223
5224
5225
5226 public static _Fields findByThriftId(int fieldId) {
5227 switch(fieldId) {
5228 case 1:
5229 return TABLE;
5230 case 2:
5231 return ROW;
5232 case 3:
5233 return FAMILY;
5234 case 4:
5235 return QUALIFIER;
5236 case 5:
5237 return VALUE;
5238 case 6:
5239 return PUT;
5240 default:
5241 return null;
5242 }
5243 }
5244
5245
5246
5247
5248
5249 public static _Fields findByThriftIdOrThrow(int fieldId) {
5250 _Fields fields = findByThriftId(fieldId);
5251 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5252 return fields;
5253 }
5254
5255
5256
5257
5258 public static _Fields findByName(String name) {
5259 return byName.get(name);
5260 }
5261
5262 private final short _thriftId;
5263 private final String _fieldName;
5264
5265 _Fields(short thriftId, String fieldName) {
5266 _thriftId = thriftId;
5267 _fieldName = fieldName;
5268 }
5269
5270 public short getThriftFieldId() {
5271 return _thriftId;
5272 }
5273
5274 public String getFieldName() {
5275 return _fieldName;
5276 }
5277 }
5278
5279
5280 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
5281 static {
5282 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
5283 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
5284 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5285 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
5286 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5287 tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
5288 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5289 tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
5290 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5291 tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT,
5292 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
5293 tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED,
5294 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
5295 metaDataMap = Collections.unmodifiableMap(tmpMap);
5296 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_args.class, metaDataMap);
5297 }
5298
5299 public checkAndPut_args() {
5300 }
5301
5302 public checkAndPut_args(
5303 ByteBuffer table,
5304 ByteBuffer row,
5305 ByteBuffer family,
5306 ByteBuffer qualifier,
5307 ByteBuffer value,
5308 TPut put)
5309 {
5310 this();
5311 this.table = table;
5312 this.row = row;
5313 this.family = family;
5314 this.qualifier = qualifier;
5315 this.value = value;
5316 this.put = put;
5317 }
5318
5319
5320
5321
5322 public checkAndPut_args(checkAndPut_args other) {
5323 if (other.isSetTable()) {
5324 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
5325 ;
5326 }
5327 if (other.isSetRow()) {
5328 this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
5329 ;
5330 }
5331 if (other.isSetFamily()) {
5332 this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
5333 ;
5334 }
5335 if (other.isSetQualifier()) {
5336 this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
5337 ;
5338 }
5339 if (other.isSetValue()) {
5340 this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
5341 ;
5342 }
5343 if (other.isSetPut()) {
5344 this.put = new TPut(other.put);
5345 }
5346 }
5347
5348 public checkAndPut_args deepCopy() {
5349 return new checkAndPut_args(this);
5350 }
5351
5352 @Override
5353 public void clear() {
5354 this.table = null;
5355 this.row = null;
5356 this.family = null;
5357 this.qualifier = null;
5358 this.value = null;
5359 this.put = null;
5360 }
5361
5362
5363
5364
5365 public byte[] getTable() {
5366 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
5367 return table == null ? null : table.array();
5368 }
5369
5370 public ByteBuffer bufferForTable() {
5371 return table;
5372 }
5373
5374
5375
5376
5377 public checkAndPut_args setTable(byte[] table) {
5378 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
5379 return this;
5380 }
5381
5382 public checkAndPut_args setTable(ByteBuffer table) {
5383 this.table = table;
5384 return this;
5385 }
5386
5387 public void unsetTable() {
5388 this.table = null;
5389 }
5390
5391
5392 public boolean isSetTable() {
5393 return this.table != null;
5394 }
5395
5396 public void setTableIsSet(boolean value) {
5397 if (!value) {
5398 this.table = null;
5399 }
5400 }
5401
5402
5403
5404
5405 public byte[] getRow() {
5406 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
5407 return row == null ? null : row.array();
5408 }
5409
5410 public ByteBuffer bufferForRow() {
5411 return row;
5412 }
5413
5414
5415
5416
5417 public checkAndPut_args setRow(byte[] row) {
5418 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
5419 return this;
5420 }
5421
5422 public checkAndPut_args setRow(ByteBuffer row) {
5423 this.row = row;
5424 return this;
5425 }
5426
5427 public void unsetRow() {
5428 this.row = null;
5429 }
5430
5431
5432 public boolean isSetRow() {
5433 return this.row != null;
5434 }
5435
5436 public void setRowIsSet(boolean value) {
5437 if (!value) {
5438 this.row = null;
5439 }
5440 }
5441
5442
5443
5444
5445 public byte[] getFamily() {
5446 setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
5447 return family == null ? null : family.array();
5448 }
5449
5450 public ByteBuffer bufferForFamily() {
5451 return family;
5452 }
5453
5454
5455
5456
5457 public checkAndPut_args setFamily(byte[] family) {
5458 setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
5459 return this;
5460 }
5461
5462 public checkAndPut_args setFamily(ByteBuffer family) {
5463 this.family = family;
5464 return this;
5465 }
5466
5467 public void unsetFamily() {
5468 this.family = null;
5469 }
5470
5471
5472 public boolean isSetFamily() {
5473 return this.family != null;
5474 }
5475
5476 public void setFamilyIsSet(boolean value) {
5477 if (!value) {
5478 this.family = null;
5479 }
5480 }
5481
5482
5483
5484
5485 public byte[] getQualifier() {
5486 setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
5487 return qualifier == null ? null : qualifier.array();
5488 }
5489
5490 public ByteBuffer bufferForQualifier() {
5491 return qualifier;
5492 }
5493
5494
5495
5496
5497 public checkAndPut_args setQualifier(byte[] qualifier) {
5498 setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
5499 return this;
5500 }
5501
5502 public checkAndPut_args setQualifier(ByteBuffer qualifier) {
5503 this.qualifier = qualifier;
5504 return this;
5505 }
5506
5507 public void unsetQualifier() {
5508 this.qualifier = null;
5509 }
5510
5511
5512 public boolean isSetQualifier() {
5513 return this.qualifier != null;
5514 }
5515
5516 public void setQualifierIsSet(boolean value) {
5517 if (!value) {
5518 this.qualifier = null;
5519 }
5520 }
5521
5522
5523
5524
5525
5526
5527 public byte[] getValue() {
5528 setValue(org.apache.thrift.TBaseHelper.rightSize(value));
5529 return value == null ? null : value.array();
5530 }
5531
5532 public ByteBuffer bufferForValue() {
5533 return value;
5534 }
5535
5536
5537
5538
5539
5540
5541 public checkAndPut_args setValue(byte[] value) {
5542 setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
5543 return this;
5544 }
5545
5546 public checkAndPut_args setValue(ByteBuffer value) {
5547 this.value = value;
5548 return this;
5549 }
5550
5551 public void unsetValue() {
5552 this.value = null;
5553 }
5554
5555
5556 public boolean isSetValue() {
5557 return this.value != null;
5558 }
5559
5560 public void setValueIsSet(boolean value) {
5561 if (!value) {
5562 this.value = null;
5563 }
5564 }
5565
5566
5567
5568
5569 public TPut getPut() {
5570 return this.put;
5571 }
5572
5573
5574
5575
5576 public checkAndPut_args setPut(TPut put) {
5577 this.put = put;
5578 return this;
5579 }
5580
5581 public void unsetPut() {
5582 this.put = null;
5583 }
5584
5585
5586 public boolean isSetPut() {
5587 return this.put != null;
5588 }
5589
5590 public void setPutIsSet(boolean value) {
5591 if (!value) {
5592 this.put = null;
5593 }
5594 }
5595
5596 public void setFieldValue(_Fields field, Object value) {
5597 switch (field) {
5598 case TABLE:
5599 if (value == null) {
5600 unsetTable();
5601 } else {
5602 setTable((ByteBuffer)value);
5603 }
5604 break;
5605
5606 case ROW:
5607 if (value == null) {
5608 unsetRow();
5609 } else {
5610 setRow((ByteBuffer)value);
5611 }
5612 break;
5613
5614 case FAMILY:
5615 if (value == null) {
5616 unsetFamily();
5617 } else {
5618 setFamily((ByteBuffer)value);
5619 }
5620 break;
5621
5622 case QUALIFIER:
5623 if (value == null) {
5624 unsetQualifier();
5625 } else {
5626 setQualifier((ByteBuffer)value);
5627 }
5628 break;
5629
5630 case VALUE:
5631 if (value == null) {
5632 unsetValue();
5633 } else {
5634 setValue((ByteBuffer)value);
5635 }
5636 break;
5637
5638 case PUT:
5639 if (value == null) {
5640 unsetPut();
5641 } else {
5642 setPut((TPut)value);
5643 }
5644 break;
5645
5646 }
5647 }
5648
5649 public Object getFieldValue(_Fields field) {
5650 switch (field) {
5651 case TABLE:
5652 return getTable();
5653
5654 case ROW:
5655 return getRow();
5656
5657 case FAMILY:
5658 return getFamily();
5659
5660 case QUALIFIER:
5661 return getQualifier();
5662
5663 case VALUE:
5664 return getValue();
5665
5666 case PUT:
5667 return getPut();
5668
5669 }
5670 throw new IllegalStateException();
5671 }
5672
5673
5674 public boolean isSet(_Fields field) {
5675 if (field == null) {
5676 throw new IllegalArgumentException();
5677 }
5678
5679 switch (field) {
5680 case TABLE:
5681 return isSetTable();
5682 case ROW:
5683 return isSetRow();
5684 case FAMILY:
5685 return isSetFamily();
5686 case QUALIFIER:
5687 return isSetQualifier();
5688 case VALUE:
5689 return isSetValue();
5690 case PUT:
5691 return isSetPut();
5692 }
5693 throw new IllegalStateException();
5694 }
5695
5696 @Override
5697 public boolean equals(Object that) {
5698 if (that == null)
5699 return false;
5700 if (that instanceof checkAndPut_args)
5701 return this.equals((checkAndPut_args)that);
5702 return false;
5703 }
5704
5705 public boolean equals(checkAndPut_args that) {
5706 if (that == null)
5707 return false;
5708
5709 boolean this_present_table = true && this.isSetTable();
5710 boolean that_present_table = true && that.isSetTable();
5711 if (this_present_table || that_present_table) {
5712 if (!(this_present_table && that_present_table))
5713 return false;
5714 if (!this.table.equals(that.table))
5715 return false;
5716 }
5717
5718 boolean this_present_row = true && this.isSetRow();
5719 boolean that_present_row = true && that.isSetRow();
5720 if (this_present_row || that_present_row) {
5721 if (!(this_present_row && that_present_row))
5722 return false;
5723 if (!this.row.equals(that.row))
5724 return false;
5725 }
5726
5727 boolean this_present_family = true && this.isSetFamily();
5728 boolean that_present_family = true && that.isSetFamily();
5729 if (this_present_family || that_present_family) {
5730 if (!(this_present_family && that_present_family))
5731 return false;
5732 if (!this.family.equals(that.family))
5733 return false;
5734 }
5735
5736 boolean this_present_qualifier = true && this.isSetQualifier();
5737 boolean that_present_qualifier = true && that.isSetQualifier();
5738 if (this_present_qualifier || that_present_qualifier) {
5739 if (!(this_present_qualifier && that_present_qualifier))
5740 return false;
5741 if (!this.qualifier.equals(that.qualifier))
5742 return false;
5743 }
5744
5745 boolean this_present_value = true && this.isSetValue();
5746 boolean that_present_value = true && that.isSetValue();
5747 if (this_present_value || that_present_value) {
5748 if (!(this_present_value && that_present_value))
5749 return false;
5750 if (!this.value.equals(that.value))
5751 return false;
5752 }
5753
5754 boolean this_present_put = true && this.isSetPut();
5755 boolean that_present_put = true && that.isSetPut();
5756 if (this_present_put || that_present_put) {
5757 if (!(this_present_put && that_present_put))
5758 return false;
5759 if (!this.put.equals(that.put))
5760 return false;
5761 }
5762
5763 return true;
5764 }
5765
5766 @Override
5767 public int hashCode() {
5768 return 0;
5769 }
5770
5771 public int compareTo(checkAndPut_args other) {
5772 if (!getClass().equals(other.getClass())) {
5773 return getClass().getName().compareTo(other.getClass().getName());
5774 }
5775
5776 int lastComparison = 0;
5777 checkAndPut_args typedOther = (checkAndPut_args)other;
5778
5779 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
5780 if (lastComparison != 0) {
5781 return lastComparison;
5782 }
5783 if (isSetTable()) {
5784 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
5785 if (lastComparison != 0) {
5786 return lastComparison;
5787 }
5788 }
5789 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
5790 if (lastComparison != 0) {
5791 return lastComparison;
5792 }
5793 if (isSetRow()) {
5794 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
5795 if (lastComparison != 0) {
5796 return lastComparison;
5797 }
5798 }
5799 lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
5800 if (lastComparison != 0) {
5801 return lastComparison;
5802 }
5803 if (isSetFamily()) {
5804 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
5805 if (lastComparison != 0) {
5806 return lastComparison;
5807 }
5808 }
5809 lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
5810 if (lastComparison != 0) {
5811 return lastComparison;
5812 }
5813 if (isSetQualifier()) {
5814 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
5815 if (lastComparison != 0) {
5816 return lastComparison;
5817 }
5818 }
5819 lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
5820 if (lastComparison != 0) {
5821 return lastComparison;
5822 }
5823 if (isSetValue()) {
5824 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
5825 if (lastComparison != 0) {
5826 return lastComparison;
5827 }
5828 }
5829 lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
5830 if (lastComparison != 0) {
5831 return lastComparison;
5832 }
5833 if (isSetPut()) {
5834 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
5835 if (lastComparison != 0) {
5836 return lastComparison;
5837 }
5838 }
5839 return 0;
5840 }
5841
5842 public _Fields fieldForId(int fieldId) {
5843 return _Fields.findByThriftId(fieldId);
5844 }
5845
5846 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
5847 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
5848 }
5849
5850 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
5851 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
5852 }
5853
5854 @Override
5855 public String toString() {
5856 StringBuilder sb = new StringBuilder("checkAndPut_args(");
5857 boolean first = true;
5858
5859 sb.append("table:");
5860 if (this.table == null) {
5861 sb.append("null");
5862 } else {
5863 org.apache.thrift.TBaseHelper.toString(this.table, sb);
5864 }
5865 first = false;
5866 if (!first) sb.append(", ");
5867 sb.append("row:");
5868 if (this.row == null) {
5869 sb.append("null");
5870 } else {
5871 org.apache.thrift.TBaseHelper.toString(this.row, sb);
5872 }
5873 first = false;
5874 if (!first) sb.append(", ");
5875 sb.append("family:");
5876 if (this.family == null) {
5877 sb.append("null");
5878 } else {
5879 org.apache.thrift.TBaseHelper.toString(this.family, sb);
5880 }
5881 first = false;
5882 if (!first) sb.append(", ");
5883 sb.append("qualifier:");
5884 if (this.qualifier == null) {
5885 sb.append("null");
5886 } else {
5887 org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
5888 }
5889 first = false;
5890 if (!first) sb.append(", ");
5891 sb.append("value:");
5892 if (this.value == null) {
5893 sb.append("null");
5894 } else {
5895 org.apache.thrift.TBaseHelper.toString(this.value, sb);
5896 }
5897 first = false;
5898 if (!first) sb.append(", ");
5899 sb.append("put:");
5900 if (this.put == null) {
5901 sb.append("null");
5902 } else {
5903 sb.append(this.put);
5904 }
5905 first = false;
5906 sb.append(")");
5907 return sb.toString();
5908 }
5909
5910 public void validate() throws org.apache.thrift.TException {
5911
5912 if (table == null) {
5913 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
5914 }
5915 if (row == null) {
5916 throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
5917 }
5918 if (family == null) {
5919 throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
5920 }
5921 if (qualifier == null) {
5922 throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
5923 }
5924 if (put == null) {
5925 throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
5926 }
5927 }
5928
5929 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
5930 try {
5931 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
5932 } catch (org.apache.thrift.TException te) {
5933 throw new java.io.IOException(te);
5934 }
5935 }
5936
5937 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
5938 try {
5939 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
5940 } catch (org.apache.thrift.TException te) {
5941 throw new java.io.IOException(te);
5942 }
5943 }
5944
5945 private static class checkAndPut_argsStandardSchemeFactory implements SchemeFactory {
5946 public checkAndPut_argsStandardScheme getScheme() {
5947 return new checkAndPut_argsStandardScheme();
5948 }
5949 }
5950
5951 private static class checkAndPut_argsStandardScheme extends StandardScheme<checkAndPut_args> {
5952
5953 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_args struct) throws org.apache.thrift.TException {
5954 org.apache.thrift.protocol.TField schemeField;
5955 iprot.readStructBegin();
5956 while (true)
5957 {
5958 schemeField = iprot.readFieldBegin();
5959 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
5960 break;
5961 }
5962 switch (schemeField.id) {
5963 case 1:
5964 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
5965 struct.table = iprot.readBinary();
5966 struct.setTableIsSet(true);
5967 } else {
5968 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5969 }
5970 break;
5971 case 2:
5972 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
5973 struct.row = iprot.readBinary();
5974 struct.setRowIsSet(true);
5975 } else {
5976 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5977 }
5978 break;
5979 case 3:
5980 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
5981 struct.family = iprot.readBinary();
5982 struct.setFamilyIsSet(true);
5983 } else {
5984 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5985 }
5986 break;
5987 case 4:
5988 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
5989 struct.qualifier = iprot.readBinary();
5990 struct.setQualifierIsSet(true);
5991 } else {
5992 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5993 }
5994 break;
5995 case 5:
5996 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
5997 struct.value = iprot.readBinary();
5998 struct.setValueIsSet(true);
5999 } else {
6000 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6001 }
6002 break;
6003 case 6:
6004 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6005 struct.put = new TPut();
6006 struct.put.read(iprot);
6007 struct.setPutIsSet(true);
6008 } else {
6009 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6010 }
6011 break;
6012 default:
6013 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6014 }
6015 iprot.readFieldEnd();
6016 }
6017 iprot.readStructEnd();
6018
6019
6020 struct.validate();
6021 }
6022
6023 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6024 struct.validate();
6025
6026 oprot.writeStructBegin(STRUCT_DESC);
6027 if (struct.table != null) {
6028 oprot.writeFieldBegin(TABLE_FIELD_DESC);
6029 oprot.writeBinary(struct.table);
6030 oprot.writeFieldEnd();
6031 }
6032 if (struct.row != null) {
6033 oprot.writeFieldBegin(ROW_FIELD_DESC);
6034 oprot.writeBinary(struct.row);
6035 oprot.writeFieldEnd();
6036 }
6037 if (struct.family != null) {
6038 oprot.writeFieldBegin(FAMILY_FIELD_DESC);
6039 oprot.writeBinary(struct.family);
6040 oprot.writeFieldEnd();
6041 }
6042 if (struct.qualifier != null) {
6043 oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
6044 oprot.writeBinary(struct.qualifier);
6045 oprot.writeFieldEnd();
6046 }
6047 if (struct.value != null) {
6048 oprot.writeFieldBegin(VALUE_FIELD_DESC);
6049 oprot.writeBinary(struct.value);
6050 oprot.writeFieldEnd();
6051 }
6052 if (struct.put != null) {
6053 oprot.writeFieldBegin(PUT_FIELD_DESC);
6054 struct.put.write(oprot);
6055 oprot.writeFieldEnd();
6056 }
6057 oprot.writeFieldStop();
6058 oprot.writeStructEnd();
6059 }
6060
6061 }
6062
6063 private static class checkAndPut_argsTupleSchemeFactory implements SchemeFactory {
6064 public checkAndPut_argsTupleScheme getScheme() {
6065 return new checkAndPut_argsTupleScheme();
6066 }
6067 }
6068
6069 private static class checkAndPut_argsTupleScheme extends TupleScheme<checkAndPut_args> {
6070
6071 @Override
6072 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6073 TTupleProtocol oprot = (TTupleProtocol) prot;
6074 oprot.writeBinary(struct.table);
6075 oprot.writeBinary(struct.row);
6076 oprot.writeBinary(struct.family);
6077 oprot.writeBinary(struct.qualifier);
6078 struct.put.write(oprot);
6079 BitSet optionals = new BitSet();
6080 if (struct.isSetValue()) {
6081 optionals.set(0);
6082 }
6083 oprot.writeBitSet(optionals, 1);
6084 if (struct.isSetValue()) {
6085 oprot.writeBinary(struct.value);
6086 }
6087 }
6088
6089 @Override
6090 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6091 TTupleProtocol iprot = (TTupleProtocol) prot;
6092 struct.table = iprot.readBinary();
6093 struct.setTableIsSet(true);
6094 struct.row = iprot.readBinary();
6095 struct.setRowIsSet(true);
6096 struct.family = iprot.readBinary();
6097 struct.setFamilyIsSet(true);
6098 struct.qualifier = iprot.readBinary();
6099 struct.setQualifierIsSet(true);
6100 struct.put = new TPut();
6101 struct.put.read(iprot);
6102 struct.setPutIsSet(true);
6103 BitSet incoming = iprot.readBitSet(1);
6104 if (incoming.get(0)) {
6105 struct.value = iprot.readBinary();
6106 struct.setValueIsSet(true);
6107 }
6108 }
6109 }
6110
6111 }
6112
6113 public static class checkAndPut_result implements org.apache.thrift.TBase<checkAndPut_result, checkAndPut_result._Fields>, java.io.Serializable, Cloneable {
6114 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_result");
6115
6116 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);
6117 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);
6118
6119 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6120 static {
6121 schemes.put(StandardScheme.class, new checkAndPut_resultStandardSchemeFactory());
6122 schemes.put(TupleScheme.class, new checkAndPut_resultTupleSchemeFactory());
6123 }
6124
6125 public boolean success;
6126 public TIOError io;
6127
6128
6129 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6130 SUCCESS((short)0, "success"),
6131 IO((short)1, "io");
6132
6133 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6134
6135 static {
6136 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6137 byName.put(field.getFieldName(), field);
6138 }
6139 }
6140
6141
6142
6143
6144 public static _Fields findByThriftId(int fieldId) {
6145 switch(fieldId) {
6146 case 0:
6147 return SUCCESS;
6148 case 1:
6149 return IO;
6150 default:
6151 return null;
6152 }
6153 }
6154
6155
6156
6157
6158
6159 public static _Fields findByThriftIdOrThrow(int fieldId) {
6160 _Fields fields = findByThriftId(fieldId);
6161 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6162 return fields;
6163 }
6164
6165
6166
6167
6168 public static _Fields findByName(String name) {
6169 return byName.get(name);
6170 }
6171
6172 private final short _thriftId;
6173 private final String _fieldName;
6174
6175 _Fields(short thriftId, String fieldName) {
6176 _thriftId = thriftId;
6177 _fieldName = fieldName;
6178 }
6179
6180 public short getThriftFieldId() {
6181 return _thriftId;
6182 }
6183
6184 public String getFieldName() {
6185 return _fieldName;
6186 }
6187 }
6188
6189
6190 private static final int __SUCCESS_ISSET_ID = 0;
6191 private BitSet __isset_bit_vector = new BitSet(1);
6192 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6193 static {
6194 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6195 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
6196 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
6197 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
6198 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
6199 metaDataMap = Collections.unmodifiableMap(tmpMap);
6200 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_result.class, metaDataMap);
6201 }
6202
6203 public checkAndPut_result() {
6204 }
6205
6206 public checkAndPut_result(
6207 boolean success,
6208 TIOError io)
6209 {
6210 this();
6211 this.success = success;
6212 setSuccessIsSet(true);
6213 this.io = io;
6214 }
6215
6216
6217
6218
6219 public checkAndPut_result(checkAndPut_result other) {
6220 __isset_bit_vector.clear();
6221 __isset_bit_vector.or(other.__isset_bit_vector);
6222 this.success = other.success;
6223 if (other.isSetIo()) {
6224 this.io = new TIOError(other.io);
6225 }
6226 }
6227
6228 public checkAndPut_result deepCopy() {
6229 return new checkAndPut_result(this);
6230 }
6231
6232 @Override
6233 public void clear() {
6234 setSuccessIsSet(false);
6235 this.success = false;
6236 this.io = null;
6237 }
6238
6239 public boolean isSuccess() {
6240 return this.success;
6241 }
6242
6243 public checkAndPut_result setSuccess(boolean success) {
6244 this.success = success;
6245 setSuccessIsSet(true);
6246 return this;
6247 }
6248
6249 public void unsetSuccess() {
6250 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
6251 }
6252
6253
6254 public boolean isSetSuccess() {
6255 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
6256 }
6257
6258 public void setSuccessIsSet(boolean value) {
6259 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
6260 }
6261
6262 public TIOError getIo() {
6263 return this.io;
6264 }
6265
6266 public checkAndPut_result setIo(TIOError io) {
6267 this.io = io;
6268 return this;
6269 }
6270
6271 public void unsetIo() {
6272 this.io = null;
6273 }
6274
6275
6276 public boolean isSetIo() {
6277 return this.io != null;
6278 }
6279
6280 public void setIoIsSet(boolean value) {
6281 if (!value) {
6282 this.io = null;
6283 }
6284 }
6285
6286 public void setFieldValue(_Fields field, Object value) {
6287 switch (field) {
6288 case SUCCESS:
6289 if (value == null) {
6290 unsetSuccess();
6291 } else {
6292 setSuccess((Boolean)value);
6293 }
6294 break;
6295
6296 case IO:
6297 if (value == null) {
6298 unsetIo();
6299 } else {
6300 setIo((TIOError)value);
6301 }
6302 break;
6303
6304 }
6305 }
6306
6307 public Object getFieldValue(_Fields field) {
6308 switch (field) {
6309 case SUCCESS:
6310 return Boolean.valueOf(isSuccess());
6311
6312 case IO:
6313 return getIo();
6314
6315 }
6316 throw new IllegalStateException();
6317 }
6318
6319
6320 public boolean isSet(_Fields field) {
6321 if (field == null) {
6322 throw new IllegalArgumentException();
6323 }
6324
6325 switch (field) {
6326 case SUCCESS:
6327 return isSetSuccess();
6328 case IO:
6329 return isSetIo();
6330 }
6331 throw new IllegalStateException();
6332 }
6333
6334 @Override
6335 public boolean equals(Object that) {
6336 if (that == null)
6337 return false;
6338 if (that instanceof checkAndPut_result)
6339 return this.equals((checkAndPut_result)that);
6340 return false;
6341 }
6342
6343 public boolean equals(checkAndPut_result that) {
6344 if (that == null)
6345 return false;
6346
6347 boolean this_present_success = true;
6348 boolean that_present_success = true;
6349 if (this_present_success || that_present_success) {
6350 if (!(this_present_success && that_present_success))
6351 return false;
6352 if (this.success != that.success)
6353 return false;
6354 }
6355
6356 boolean this_present_io = true && this.isSetIo();
6357 boolean that_present_io = true && that.isSetIo();
6358 if (this_present_io || that_present_io) {
6359 if (!(this_present_io && that_present_io))
6360 return false;
6361 if (!this.io.equals(that.io))
6362 return false;
6363 }
6364
6365 return true;
6366 }
6367
6368 @Override
6369 public int hashCode() {
6370 return 0;
6371 }
6372
6373 public int compareTo(checkAndPut_result other) {
6374 if (!getClass().equals(other.getClass())) {
6375 return getClass().getName().compareTo(other.getClass().getName());
6376 }
6377
6378 int lastComparison = 0;
6379 checkAndPut_result typedOther = (checkAndPut_result)other;
6380
6381 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
6382 if (lastComparison != 0) {
6383 return lastComparison;
6384 }
6385 if (isSetSuccess()) {
6386 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
6387 if (lastComparison != 0) {
6388 return lastComparison;
6389 }
6390 }
6391 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
6392 if (lastComparison != 0) {
6393 return lastComparison;
6394 }
6395 if (isSetIo()) {
6396 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
6397 if (lastComparison != 0) {
6398 return lastComparison;
6399 }
6400 }
6401 return 0;
6402 }
6403
6404 public _Fields fieldForId(int fieldId) {
6405 return _Fields.findByThriftId(fieldId);
6406 }
6407
6408 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6409 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6410 }
6411
6412 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6413 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6414 }
6415
6416 @Override
6417 public String toString() {
6418 StringBuilder sb = new StringBuilder("checkAndPut_result(");
6419 boolean first = true;
6420
6421 sb.append("success:");
6422 sb.append(this.success);
6423 first = false;
6424 if (!first) sb.append(", ");
6425 sb.append("io:");
6426 if (this.io == null) {
6427 sb.append("null");
6428 } else {
6429 sb.append(this.io);
6430 }
6431 first = false;
6432 sb.append(")");
6433 return sb.toString();
6434 }
6435
6436 public void validate() throws org.apache.thrift.TException {
6437
6438 }
6439
6440 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6441 try {
6442 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6443 } catch (org.apache.thrift.TException te) {
6444 throw new java.io.IOException(te);
6445 }
6446 }
6447
6448 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6449 try {
6450 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6451 } catch (org.apache.thrift.TException te) {
6452 throw new java.io.IOException(te);
6453 }
6454 }
6455
6456 private static class checkAndPut_resultStandardSchemeFactory implements SchemeFactory {
6457 public checkAndPut_resultStandardScheme getScheme() {
6458 return new checkAndPut_resultStandardScheme();
6459 }
6460 }
6461
6462 private static class checkAndPut_resultStandardScheme extends StandardScheme<checkAndPut_result> {
6463
6464 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6465 org.apache.thrift.protocol.TField schemeField;
6466 iprot.readStructBegin();
6467 while (true)
6468 {
6469 schemeField = iprot.readFieldBegin();
6470 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6471 break;
6472 }
6473 switch (schemeField.id) {
6474 case 0:
6475 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
6476 struct.success = iprot.readBool();
6477 struct.setSuccessIsSet(true);
6478 } else {
6479 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6480 }
6481 break;
6482 case 1:
6483 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6484 struct.io = new TIOError();
6485 struct.io.read(iprot);
6486 struct.setIoIsSet(true);
6487 } else {
6488 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6489 }
6490 break;
6491 default:
6492 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6493 }
6494 iprot.readFieldEnd();
6495 }
6496 iprot.readStructEnd();
6497
6498
6499 struct.validate();
6500 }
6501
6502 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6503 struct.validate();
6504
6505 oprot.writeStructBegin(STRUCT_DESC);
6506 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6507 oprot.writeBool(struct.success);
6508 oprot.writeFieldEnd();
6509 if (struct.io != null) {
6510 oprot.writeFieldBegin(IO_FIELD_DESC);
6511 struct.io.write(oprot);
6512 oprot.writeFieldEnd();
6513 }
6514 oprot.writeFieldStop();
6515 oprot.writeStructEnd();
6516 }
6517
6518 }
6519
6520 private static class checkAndPut_resultTupleSchemeFactory implements SchemeFactory {
6521 public checkAndPut_resultTupleScheme getScheme() {
6522 return new checkAndPut_resultTupleScheme();
6523 }
6524 }
6525
6526 private static class checkAndPut_resultTupleScheme extends TupleScheme<checkAndPut_result> {
6527
6528 @Override
6529 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6530 TTupleProtocol oprot = (TTupleProtocol) prot;
6531 BitSet optionals = new BitSet();
6532 if (struct.isSetSuccess()) {
6533 optionals.set(0);
6534 }
6535 if (struct.isSetIo()) {
6536 optionals.set(1);
6537 }
6538 oprot.writeBitSet(optionals, 2);
6539 if (struct.isSetSuccess()) {
6540 oprot.writeBool(struct.success);
6541 }
6542 if (struct.isSetIo()) {
6543 struct.io.write(oprot);
6544 }
6545 }
6546
6547 @Override
6548 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6549 TTupleProtocol iprot = (TTupleProtocol) prot;
6550 BitSet incoming = iprot.readBitSet(2);
6551 if (incoming.get(0)) {
6552 struct.success = iprot.readBool();
6553 struct.setSuccessIsSet(true);
6554 }
6555 if (incoming.get(1)) {
6556 struct.io = new TIOError();
6557 struct.io.read(iprot);
6558 struct.setIoIsSet(true);
6559 }
6560 }
6561 }
6562
6563 }
6564
6565 public static class putMultiple_args implements org.apache.thrift.TBase<putMultiple_args, putMultiple_args._Fields>, java.io.Serializable, Cloneable {
6566 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_args");
6567
6568 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);
6569 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);
6570
6571 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6572 static {
6573 schemes.put(StandardScheme.class, new putMultiple_argsStandardSchemeFactory());
6574 schemes.put(TupleScheme.class, new putMultiple_argsTupleSchemeFactory());
6575 }
6576
6577
6578
6579
6580 public ByteBuffer table;
6581
6582
6583
6584 public List<TPut> puts;
6585
6586
6587 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6588
6589
6590
6591 TABLE((short)1, "table"),
6592
6593
6594
6595 PUTS((short)2, "puts");
6596
6597 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6598
6599 static {
6600 for (_Fields field : EnumSet.allOf(_Fields.class)) {
6601 byName.put(field.getFieldName(), field);
6602 }
6603 }
6604
6605
6606
6607
6608 public static _Fields findByThriftId(int fieldId) {
6609 switch(fieldId) {
6610 case 1:
6611 return TABLE;
6612 case 2:
6613 return PUTS;
6614 default:
6615 return null;
6616 }
6617 }
6618
6619
6620
6621
6622
6623 public static _Fields findByThriftIdOrThrow(int fieldId) {
6624 _Fields fields = findByThriftId(fieldId);
6625 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6626 return fields;
6627 }
6628
6629
6630
6631
6632 public static _Fields findByName(String name) {
6633 return byName.get(name);
6634 }
6635
6636 private final short _thriftId;
6637 private final String _fieldName;
6638
6639 _Fields(short thriftId, String fieldName) {
6640 _thriftId = thriftId;
6641 _fieldName = fieldName;
6642 }
6643
6644 public short getThriftFieldId() {
6645 return _thriftId;
6646 }
6647
6648 public String getFieldName() {
6649 return _fieldName;
6650 }
6651 }
6652
6653
6654 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6655 static {
6656 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6657 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
6658 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
6659 tmpMap.put(_Fields.PUTS, new org.apache.thrift.meta_data.FieldMetaData("puts", org.apache.thrift.TFieldRequirementType.REQUIRED,
6660 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
6661 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class))));
6662 metaDataMap = Collections.unmodifiableMap(tmpMap);
6663 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_args.class, metaDataMap);
6664 }
6665
6666 public putMultiple_args() {
6667 }
6668
6669 public putMultiple_args(
6670 ByteBuffer table,
6671 List<TPut> puts)
6672 {
6673 this();
6674 this.table = table;
6675 this.puts = puts;
6676 }
6677
6678
6679
6680
6681 public putMultiple_args(putMultiple_args other) {
6682 if (other.isSetTable()) {
6683 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
6684 ;
6685 }
6686 if (other.isSetPuts()) {
6687 List<TPut> __this__puts = new ArrayList<TPut>();
6688 for (TPut other_element : other.puts) {
6689 __this__puts.add(new TPut(other_element));
6690 }
6691 this.puts = __this__puts;
6692 }
6693 }
6694
6695 public putMultiple_args deepCopy() {
6696 return new putMultiple_args(this);
6697 }
6698
6699 @Override
6700 public void clear() {
6701 this.table = null;
6702 this.puts = null;
6703 }
6704
6705
6706
6707
6708 public byte[] getTable() {
6709 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
6710 return table == null ? null : table.array();
6711 }
6712
6713 public ByteBuffer bufferForTable() {
6714 return table;
6715 }
6716
6717
6718
6719
6720 public putMultiple_args setTable(byte[] table) {
6721 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
6722 return this;
6723 }
6724
6725 public putMultiple_args setTable(ByteBuffer table) {
6726 this.table = table;
6727 return this;
6728 }
6729
6730 public void unsetTable() {
6731 this.table = null;
6732 }
6733
6734
6735 public boolean isSetTable() {
6736 return this.table != null;
6737 }
6738
6739 public void setTableIsSet(boolean value) {
6740 if (!value) {
6741 this.table = null;
6742 }
6743 }
6744
6745 public int getPutsSize() {
6746 return (this.puts == null) ? 0 : this.puts.size();
6747 }
6748
6749 public java.util.Iterator<TPut> getPutsIterator() {
6750 return (this.puts == null) ? null : this.puts.iterator();
6751 }
6752
6753 public void addToPuts(TPut elem) {
6754 if (this.puts == null) {
6755 this.puts = new ArrayList<TPut>();
6756 }
6757 this.puts.add(elem);
6758 }
6759
6760
6761
6762
6763 public List<TPut> getPuts() {
6764 return this.puts;
6765 }
6766
6767
6768
6769
6770 public putMultiple_args setPuts(List<TPut> puts) {
6771 this.puts = puts;
6772 return this;
6773 }
6774
6775 public void unsetPuts() {
6776 this.puts = null;
6777 }
6778
6779
6780 public boolean isSetPuts() {
6781 return this.puts != null;
6782 }
6783
6784 public void setPutsIsSet(boolean value) {
6785 if (!value) {
6786 this.puts = null;
6787 }
6788 }
6789
6790 public void setFieldValue(_Fields field, Object value) {
6791 switch (field) {
6792 case TABLE:
6793 if (value == null) {
6794 unsetTable();
6795 } else {
6796 setTable((ByteBuffer)value);
6797 }
6798 break;
6799
6800 case PUTS:
6801 if (value == null) {
6802 unsetPuts();
6803 } else {
6804 setPuts((List<TPut>)value);
6805 }
6806 break;
6807
6808 }
6809 }
6810
6811 public Object getFieldValue(_Fields field) {
6812 switch (field) {
6813 case TABLE:
6814 return getTable();
6815
6816 case PUTS:
6817 return getPuts();
6818
6819 }
6820 throw new IllegalStateException();
6821 }
6822
6823
6824 public boolean isSet(_Fields field) {
6825 if (field == null) {
6826 throw new IllegalArgumentException();
6827 }
6828
6829 switch (field) {
6830 case TABLE:
6831 return isSetTable();
6832 case PUTS:
6833 return isSetPuts();
6834 }
6835 throw new IllegalStateException();
6836 }
6837
6838 @Override
6839 public boolean equals(Object that) {
6840 if (that == null)
6841 return false;
6842 if (that instanceof putMultiple_args)
6843 return this.equals((putMultiple_args)that);
6844 return false;
6845 }
6846
6847 public boolean equals(putMultiple_args that) {
6848 if (that == null)
6849 return false;
6850
6851 boolean this_present_table = true && this.isSetTable();
6852 boolean that_present_table = true && that.isSetTable();
6853 if (this_present_table || that_present_table) {
6854 if (!(this_present_table && that_present_table))
6855 return false;
6856 if (!this.table.equals(that.table))
6857 return false;
6858 }
6859
6860 boolean this_present_puts = true && this.isSetPuts();
6861 boolean that_present_puts = true && that.isSetPuts();
6862 if (this_present_puts || that_present_puts) {
6863 if (!(this_present_puts && that_present_puts))
6864 return false;
6865 if (!this.puts.equals(that.puts))
6866 return false;
6867 }
6868
6869 return true;
6870 }
6871
6872 @Override
6873 public int hashCode() {
6874 return 0;
6875 }
6876
6877 public int compareTo(putMultiple_args other) {
6878 if (!getClass().equals(other.getClass())) {
6879 return getClass().getName().compareTo(other.getClass().getName());
6880 }
6881
6882 int lastComparison = 0;
6883 putMultiple_args typedOther = (putMultiple_args)other;
6884
6885 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
6886 if (lastComparison != 0) {
6887 return lastComparison;
6888 }
6889 if (isSetTable()) {
6890 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
6891 if (lastComparison != 0) {
6892 return lastComparison;
6893 }
6894 }
6895 lastComparison = Boolean.valueOf(isSetPuts()).compareTo(typedOther.isSetPuts());
6896 if (lastComparison != 0) {
6897 return lastComparison;
6898 }
6899 if (isSetPuts()) {
6900 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.puts, typedOther.puts);
6901 if (lastComparison != 0) {
6902 return lastComparison;
6903 }
6904 }
6905 return 0;
6906 }
6907
6908 public _Fields fieldForId(int fieldId) {
6909 return _Fields.findByThriftId(fieldId);
6910 }
6911
6912 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6913 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6914 }
6915
6916 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6917 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6918 }
6919
6920 @Override
6921 public String toString() {
6922 StringBuilder sb = new StringBuilder("putMultiple_args(");
6923 boolean first = true;
6924
6925 sb.append("table:");
6926 if (this.table == null) {
6927 sb.append("null");
6928 } else {
6929 org.apache.thrift.TBaseHelper.toString(this.table, sb);
6930 }
6931 first = false;
6932 if (!first) sb.append(", ");
6933 sb.append("puts:");
6934 if (this.puts == null) {
6935 sb.append("null");
6936 } else {
6937 sb.append(this.puts);
6938 }
6939 first = false;
6940 sb.append(")");
6941 return sb.toString();
6942 }
6943
6944 public void validate() throws org.apache.thrift.TException {
6945
6946 if (table == null) {
6947 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
6948 }
6949 if (puts == null) {
6950 throw new org.apache.thrift.protocol.TProtocolException("Required field 'puts' was not present! Struct: " + toString());
6951 }
6952 }
6953
6954 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6955 try {
6956 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6957 } catch (org.apache.thrift.TException te) {
6958 throw new java.io.IOException(te);
6959 }
6960 }
6961
6962 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6963 try {
6964 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6965 } catch (org.apache.thrift.TException te) {
6966 throw new java.io.IOException(te);
6967 }
6968 }
6969
6970 private static class putMultiple_argsStandardSchemeFactory implements SchemeFactory {
6971 public putMultiple_argsStandardScheme getScheme() {
6972 return new putMultiple_argsStandardScheme();
6973 }
6974 }
6975
6976 private static class putMultiple_argsStandardScheme extends StandardScheme<putMultiple_args> {
6977
6978 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_args struct) throws org.apache.thrift.TException {
6979 org.apache.thrift.protocol.TField schemeField;
6980 iprot.readStructBegin();
6981 while (true)
6982 {
6983 schemeField = iprot.readFieldBegin();
6984 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
6985 break;
6986 }
6987 switch (schemeField.id) {
6988 case 1:
6989 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6990 struct.table = iprot.readBinary();
6991 struct.setTableIsSet(true);
6992 } else {
6993 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6994 }
6995 break;
6996 case 2:
6997 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
6998 {
6999 org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
7000 struct.puts = new ArrayList<TPut>(_list64.size);
7001 for (int _i65 = 0; _i65 < _list64.size; ++_i65)
7002 {
7003 TPut _elem66;
7004 _elem66 = new TPut();
7005 _elem66.read(iprot);
7006 struct.puts.add(_elem66);
7007 }
7008 iprot.readListEnd();
7009 }
7010 struct.setPutsIsSet(true);
7011 } else {
7012 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7013 }
7014 break;
7015 default:
7016 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7017 }
7018 iprot.readFieldEnd();
7019 }
7020 iprot.readStructEnd();
7021
7022
7023 struct.validate();
7024 }
7025
7026 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_args struct) throws org.apache.thrift.TException {
7027 struct.validate();
7028
7029 oprot.writeStructBegin(STRUCT_DESC);
7030 if (struct.table != null) {
7031 oprot.writeFieldBegin(TABLE_FIELD_DESC);
7032 oprot.writeBinary(struct.table);
7033 oprot.writeFieldEnd();
7034 }
7035 if (struct.puts != null) {
7036 oprot.writeFieldBegin(PUTS_FIELD_DESC);
7037 {
7038 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.puts.size()));
7039 for (TPut _iter67 : struct.puts)
7040 {
7041 _iter67.write(oprot);
7042 }
7043 oprot.writeListEnd();
7044 }
7045 oprot.writeFieldEnd();
7046 }
7047 oprot.writeFieldStop();
7048 oprot.writeStructEnd();
7049 }
7050
7051 }
7052
7053 private static class putMultiple_argsTupleSchemeFactory implements SchemeFactory {
7054 public putMultiple_argsTupleScheme getScheme() {
7055 return new putMultiple_argsTupleScheme();
7056 }
7057 }
7058
7059 private static class putMultiple_argsTupleScheme extends TupleScheme<putMultiple_args> {
7060
7061 @Override
7062 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7063 TTupleProtocol oprot = (TTupleProtocol) prot;
7064 oprot.writeBinary(struct.table);
7065 {
7066 oprot.writeI32(struct.puts.size());
7067 for (TPut _iter68 : struct.puts)
7068 {
7069 _iter68.write(oprot);
7070 }
7071 }
7072 }
7073
7074 @Override
7075 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7076 TTupleProtocol iprot = (TTupleProtocol) prot;
7077 struct.table = iprot.readBinary();
7078 struct.setTableIsSet(true);
7079 {
7080 org.apache.thrift.protocol.TList _list69 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
7081 struct.puts = new ArrayList<TPut>(_list69.size);
7082 for (int _i70 = 0; _i70 < _list69.size; ++_i70)
7083 {
7084 TPut _elem71;
7085 _elem71 = new TPut();
7086 _elem71.read(iprot);
7087 struct.puts.add(_elem71);
7088 }
7089 }
7090 struct.setPutsIsSet(true);
7091 }
7092 }
7093
7094 }
7095
7096 public static class putMultiple_result implements org.apache.thrift.TBase<putMultiple_result, putMultiple_result._Fields>, java.io.Serializable, Cloneable {
7097 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_result");
7098
7099 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);
7100
7101 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7102 static {
7103 schemes.put(StandardScheme.class, new putMultiple_resultStandardSchemeFactory());
7104 schemes.put(TupleScheme.class, new putMultiple_resultTupleSchemeFactory());
7105 }
7106
7107 public TIOError io;
7108
7109
7110 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7111 IO((short)1, "io");
7112
7113 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7114
7115 static {
7116 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7117 byName.put(field.getFieldName(), field);
7118 }
7119 }
7120
7121
7122
7123
7124 public static _Fields findByThriftId(int fieldId) {
7125 switch(fieldId) {
7126 case 1:
7127 return IO;
7128 default:
7129 return null;
7130 }
7131 }
7132
7133
7134
7135
7136
7137 public static _Fields findByThriftIdOrThrow(int fieldId) {
7138 _Fields fields = findByThriftId(fieldId);
7139 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7140 return fields;
7141 }
7142
7143
7144
7145
7146 public static _Fields findByName(String name) {
7147 return byName.get(name);
7148 }
7149
7150 private final short _thriftId;
7151 private final String _fieldName;
7152
7153 _Fields(short thriftId, String fieldName) {
7154 _thriftId = thriftId;
7155 _fieldName = fieldName;
7156 }
7157
7158 public short getThriftFieldId() {
7159 return _thriftId;
7160 }
7161
7162 public String getFieldName() {
7163 return _fieldName;
7164 }
7165 }
7166
7167
7168 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7169 static {
7170 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7171 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
7172 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
7173 metaDataMap = Collections.unmodifiableMap(tmpMap);
7174 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_result.class, metaDataMap);
7175 }
7176
7177 public putMultiple_result() {
7178 }
7179
7180 public putMultiple_result(
7181 TIOError io)
7182 {
7183 this();
7184 this.io = io;
7185 }
7186
7187
7188
7189
7190 public putMultiple_result(putMultiple_result other) {
7191 if (other.isSetIo()) {
7192 this.io = new TIOError(other.io);
7193 }
7194 }
7195
7196 public putMultiple_result deepCopy() {
7197 return new putMultiple_result(this);
7198 }
7199
7200 @Override
7201 public void clear() {
7202 this.io = null;
7203 }
7204
7205 public TIOError getIo() {
7206 return this.io;
7207 }
7208
7209 public putMultiple_result setIo(TIOError io) {
7210 this.io = io;
7211 return this;
7212 }
7213
7214 public void unsetIo() {
7215 this.io = null;
7216 }
7217
7218
7219 public boolean isSetIo() {
7220 return this.io != null;
7221 }
7222
7223 public void setIoIsSet(boolean value) {
7224 if (!value) {
7225 this.io = null;
7226 }
7227 }
7228
7229 public void setFieldValue(_Fields field, Object value) {
7230 switch (field) {
7231 case IO:
7232 if (value == null) {
7233 unsetIo();
7234 } else {
7235 setIo((TIOError)value);
7236 }
7237 break;
7238
7239 }
7240 }
7241
7242 public Object getFieldValue(_Fields field) {
7243 switch (field) {
7244 case IO:
7245 return getIo();
7246
7247 }
7248 throw new IllegalStateException();
7249 }
7250
7251
7252 public boolean isSet(_Fields field) {
7253 if (field == null) {
7254 throw new IllegalArgumentException();
7255 }
7256
7257 switch (field) {
7258 case IO:
7259 return isSetIo();
7260 }
7261 throw new IllegalStateException();
7262 }
7263
7264 @Override
7265 public boolean equals(Object that) {
7266 if (that == null)
7267 return false;
7268 if (that instanceof putMultiple_result)
7269 return this.equals((putMultiple_result)that);
7270 return false;
7271 }
7272
7273 public boolean equals(putMultiple_result that) {
7274 if (that == null)
7275 return false;
7276
7277 boolean this_present_io = true && this.isSetIo();
7278 boolean that_present_io = true && that.isSetIo();
7279 if (this_present_io || that_present_io) {
7280 if (!(this_present_io && that_present_io))
7281 return false;
7282 if (!this.io.equals(that.io))
7283 return false;
7284 }
7285
7286 return true;
7287 }
7288
7289 @Override
7290 public int hashCode() {
7291 return 0;
7292 }
7293
7294 public int compareTo(putMultiple_result other) {
7295 if (!getClass().equals(other.getClass())) {
7296 return getClass().getName().compareTo(other.getClass().getName());
7297 }
7298
7299 int lastComparison = 0;
7300 putMultiple_result typedOther = (putMultiple_result)other;
7301
7302 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
7303 if (lastComparison != 0) {
7304 return lastComparison;
7305 }
7306 if (isSetIo()) {
7307 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
7308 if (lastComparison != 0) {
7309 return lastComparison;
7310 }
7311 }
7312 return 0;
7313 }
7314
7315 public _Fields fieldForId(int fieldId) {
7316 return _Fields.findByThriftId(fieldId);
7317 }
7318
7319 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7320 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7321 }
7322
7323 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7324 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7325 }
7326
7327 @Override
7328 public String toString() {
7329 StringBuilder sb = new StringBuilder("putMultiple_result(");
7330 boolean first = true;
7331
7332 sb.append("io:");
7333 if (this.io == null) {
7334 sb.append("null");
7335 } else {
7336 sb.append(this.io);
7337 }
7338 first = false;
7339 sb.append(")");
7340 return sb.toString();
7341 }
7342
7343 public void validate() throws org.apache.thrift.TException {
7344
7345 }
7346
7347 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7348 try {
7349 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7350 } catch (org.apache.thrift.TException te) {
7351 throw new java.io.IOException(te);
7352 }
7353 }
7354
7355 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7356 try {
7357 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7358 } catch (org.apache.thrift.TException te) {
7359 throw new java.io.IOException(te);
7360 }
7361 }
7362
7363 private static class putMultiple_resultStandardSchemeFactory implements SchemeFactory {
7364 public putMultiple_resultStandardScheme getScheme() {
7365 return new putMultiple_resultStandardScheme();
7366 }
7367 }
7368
7369 private static class putMultiple_resultStandardScheme extends StandardScheme<putMultiple_result> {
7370
7371 public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_result struct) throws org.apache.thrift.TException {
7372 org.apache.thrift.protocol.TField schemeField;
7373 iprot.readStructBegin();
7374 while (true)
7375 {
7376 schemeField = iprot.readFieldBegin();
7377 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7378 break;
7379 }
7380 switch (schemeField.id) {
7381 case 1:
7382 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
7383 struct.io = new TIOError();
7384 struct.io.read(iprot);
7385 struct.setIoIsSet(true);
7386 } else {
7387 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7388 }
7389 break;
7390 default:
7391 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7392 }
7393 iprot.readFieldEnd();
7394 }
7395 iprot.readStructEnd();
7396
7397
7398 struct.validate();
7399 }
7400
7401 public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_result struct) throws org.apache.thrift.TException {
7402 struct.validate();
7403
7404 oprot.writeStructBegin(STRUCT_DESC);
7405 if (struct.io != null) {
7406 oprot.writeFieldBegin(IO_FIELD_DESC);
7407 struct.io.write(oprot);
7408 oprot.writeFieldEnd();
7409 }
7410 oprot.writeFieldStop();
7411 oprot.writeStructEnd();
7412 }
7413
7414 }
7415
7416 private static class putMultiple_resultTupleSchemeFactory implements SchemeFactory {
7417 public putMultiple_resultTupleScheme getScheme() {
7418 return new putMultiple_resultTupleScheme();
7419 }
7420 }
7421
7422 private static class putMultiple_resultTupleScheme extends TupleScheme<putMultiple_result> {
7423
7424 @Override
7425 public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7426 TTupleProtocol oprot = (TTupleProtocol) prot;
7427 BitSet optionals = new BitSet();
7428 if (struct.isSetIo()) {
7429 optionals.set(0);
7430 }
7431 oprot.writeBitSet(optionals, 1);
7432 if (struct.isSetIo()) {
7433 struct.io.write(oprot);
7434 }
7435 }
7436
7437 @Override
7438 public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7439 TTupleProtocol iprot = (TTupleProtocol) prot;
7440 BitSet incoming = iprot.readBitSet(1);
7441 if (incoming.get(0)) {
7442 struct.io = new TIOError();
7443 struct.io.read(iprot);
7444 struct.setIoIsSet(true);
7445 }
7446 }
7447 }
7448
7449 }
7450
7451 public static class deleteSingle_args implements org.apache.thrift.TBase<deleteSingle_args, deleteSingle_args._Fields>, java.io.Serializable, Cloneable {
7452 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_args");
7453
7454 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);
7455 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);
7456
7457 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7458 static {
7459 schemes.put(StandardScheme.class, new deleteSingle_argsStandardSchemeFactory());
7460 schemes.put(TupleScheme.class, new deleteSingle_argsTupleSchemeFactory());
7461 }
7462
7463
7464
7465
7466 public ByteBuffer table;
7467
7468
7469
7470 public TDelete deleteSingle;
7471
7472
7473 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7474
7475
7476
7477 TABLE((short)1, "table"),
7478
7479
7480
7481 DELETE_SINGLE((short)2, "deleteSingle");
7482
7483 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7484
7485 static {
7486 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7487 byName.put(field.getFieldName(), field);
7488 }
7489 }
7490
7491
7492
7493
7494 public static _Fields findByThriftId(int fieldId) {
7495 switch(fieldId) {
7496 case 1:
7497 return TABLE;
7498 case 2:
7499 return DELETE_SINGLE;
7500 default:
7501 return null;
7502 }
7503 }
7504
7505
7506
7507
7508
7509 public static _Fields findByThriftIdOrThrow(int fieldId) {
7510 _Fields fields = findByThriftId(fieldId);
7511 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7512 return fields;
7513 }
7514
7515
7516
7517
7518 public static _Fields findByName(String name) {
7519 return byName.get(name);
7520 }
7521
7522 private final short _thriftId;
7523 private final String _fieldName;
7524
7525 _Fields(short thriftId, String fieldName) {
7526 _thriftId = thriftId;
7527 _fieldName = fieldName;
7528 }
7529
7530 public short getThriftFieldId() {
7531 return _thriftId;
7532 }
7533
7534 public String getFieldName() {
7535 return _fieldName;
7536 }
7537 }
7538
7539
7540 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7541 static {
7542 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7543 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
7544 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
7545 tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED,
7546 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
7547 metaDataMap = Collections.unmodifiableMap(tmpMap);
7548 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_args.class, metaDataMap);
7549 }
7550
7551 public deleteSingle_args() {
7552 }
7553
7554 public deleteSingle_args(
7555 ByteBuffer table,
7556 TDelete deleteSingle)
7557 {
7558 this();
7559 this.table = table;
7560 this.deleteSingle = deleteSingle;
7561 }
7562
7563
7564
7565
7566 public deleteSingle_args(deleteSingle_args other) {
7567 if (other.isSetTable()) {
7568 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
7569 ;
7570 }
7571 if (other.isSetDeleteSingle()) {
7572 this.deleteSingle = new TDelete(other.deleteSingle);
7573 }
7574 }
7575
7576 public deleteSingle_args deepCopy() {
7577 return new deleteSingle_args(this);
7578 }
7579
7580 @Override
7581 public void clear() {
7582 this.table = null;
7583 this.deleteSingle = null;
7584 }
7585
7586
7587
7588
7589 public byte[] getTable() {
7590 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
7591 return table == null ? null : table.array();
7592 }
7593
7594 public ByteBuffer bufferForTable() {
7595 return table;
7596 }
7597
7598
7599
7600
7601 public deleteSingle_args setTable(byte[] table) {
7602 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
7603 return this;
7604 }
7605
7606 public deleteSingle_args setTable(ByteBuffer table) {
7607 this.table = table;
7608 return this;
7609 }
7610
7611 public void unsetTable() {
7612 this.table = null;
7613 }
7614
7615
7616 public boolean isSetTable() {
7617 return this.table != null;
7618 }
7619
7620 public void setTableIsSet(boolean value) {
7621 if (!value) {
7622 this.table = null;
7623 }
7624 }
7625
7626
7627
7628
7629 public TDelete getDeleteSingle() {
7630 return this.deleteSingle;
7631 }
7632
7633
7634
7635
7636 public deleteSingle_args setDeleteSingle(TDelete deleteSingle) {
7637 this.deleteSingle = deleteSingle;
7638 return this;
7639 }
7640
7641 public void unsetDeleteSingle() {
7642 this.deleteSingle = null;
7643 }
7644
7645
7646 public boolean isSetDeleteSingle() {
7647 return this.deleteSingle != null;
7648 }
7649
7650 public void setDeleteSingleIsSet(boolean value) {
7651 if (!value) {
7652 this.deleteSingle = null;
7653 }
7654 }
7655
7656 public void setFieldValue(_Fields field, Object value) {
7657 switch (field) {
7658 case TABLE:
7659 if (value == null) {
7660 unsetTable();
7661 } else {
7662 setTable((ByteBuffer)value);
7663 }
7664 break;
7665
7666 case DELETE_SINGLE:
7667 if (value == null) {
7668 unsetDeleteSingle();
7669 } else {
7670 setDeleteSingle((TDelete)value);
7671 }
7672 break;
7673
7674 }
7675 }
7676
7677 public Object getFieldValue(_Fields field) {
7678 switch (field) {
7679 case TABLE:
7680 return getTable();
7681
7682 case DELETE_SINGLE:
7683 return getDeleteSingle();
7684
7685 }
7686 throw new IllegalStateException();
7687 }
7688
7689
7690 public boolean isSet(_Fields field) {
7691 if (field == null) {
7692 throw new IllegalArgumentException();
7693 }
7694
7695 switch (field) {
7696 case TABLE:
7697 return isSetTable();
7698 case DELETE_SINGLE:
7699 return isSetDeleteSingle();
7700 }
7701 throw new IllegalStateException();
7702 }
7703
7704 @Override
7705 public boolean equals(Object that) {
7706 if (that == null)
7707 return false;
7708 if (that instanceof deleteSingle_args)
7709 return this.equals((deleteSingle_args)that);
7710 return false;
7711 }
7712
7713 public boolean equals(deleteSingle_args that) {
7714 if (that == null)
7715 return false;
7716
7717 boolean this_present_table = true && this.isSetTable();
7718 boolean that_present_table = true && that.isSetTable();
7719 if (this_present_table || that_present_table) {
7720 if (!(this_present_table && that_present_table))
7721 return false;
7722 if (!this.table.equals(that.table))
7723 return false;
7724 }
7725
7726 boolean this_present_deleteSingle = true && this.isSetDeleteSingle();
7727 boolean that_present_deleteSingle = true && that.isSetDeleteSingle();
7728 if (this_present_deleteSingle || that_present_deleteSingle) {
7729 if (!(this_present_deleteSingle && that_present_deleteSingle))
7730 return false;
7731 if (!this.deleteSingle.equals(that.deleteSingle))
7732 return false;
7733 }
7734
7735 return true;
7736 }
7737
7738 @Override
7739 public int hashCode() {
7740 return 0;
7741 }
7742
7743 public int compareTo(deleteSingle_args other) {
7744 if (!getClass().equals(other.getClass())) {
7745 return getClass().getName().compareTo(other.getClass().getName());
7746 }
7747
7748 int lastComparison = 0;
7749 deleteSingle_args typedOther = (deleteSingle_args)other;
7750
7751 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
7752 if (lastComparison != 0) {
7753 return lastComparison;
7754 }
7755 if (isSetTable()) {
7756 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
7757 if (lastComparison != 0) {
7758 return lastComparison;
7759 }
7760 }
7761 lastComparison = Boolean.valueOf(isSetDeleteSingle()).compareTo(typedOther.isSetDeleteSingle());
7762 if (lastComparison != 0) {
7763 return lastComparison;
7764 }
7765 if (isSetDeleteSingle()) {
7766 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteSingle, typedOther.deleteSingle);
7767 if (lastComparison != 0) {
7768 return lastComparison;
7769 }
7770 }
7771 return 0;
7772 }
7773
7774 public _Fields fieldForId(int fieldId) {
7775 return _Fields.findByThriftId(fieldId);
7776 }
7777
7778 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7779 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7780 }
7781
7782 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7783 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7784 }
7785
7786 @Override
7787 public String toString() {
7788 StringBuilder sb = new StringBuilder("deleteSingle_args(");
7789 boolean first = true;
7790
7791 sb.append("table:");
7792 if (this.table == null) {
7793 sb.append("null");
7794 } else {
7795 org.apache.thrift.TBaseHelper.toString(this.table, sb);
7796 }
7797 first = false;
7798 if (!first) sb.append(", ");
7799 sb.append("deleteSingle:");
7800 if (this.deleteSingle == null) {
7801 sb.append("null");
7802 } else {
7803 sb.append(this.deleteSingle);
7804 }
7805 first = false;
7806 sb.append(")");
7807 return sb.toString();
7808 }
7809
7810 public void validate() throws org.apache.thrift.TException {
7811
7812 if (table == null) {
7813 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
7814 }
7815 if (deleteSingle == null) {
7816 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deleteSingle' was not present! Struct: " + toString());
7817 }
7818 }
7819
7820 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7821 try {
7822 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7823 } catch (org.apache.thrift.TException te) {
7824 throw new java.io.IOException(te);
7825 }
7826 }
7827
7828 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7829 try {
7830 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7831 } catch (org.apache.thrift.TException te) {
7832 throw new java.io.IOException(te);
7833 }
7834 }
7835
7836 private static class deleteSingle_argsStandardSchemeFactory implements SchemeFactory {
7837 public deleteSingle_argsStandardScheme getScheme() {
7838 return new deleteSingle_argsStandardScheme();
7839 }
7840 }
7841
7842 private static class deleteSingle_argsStandardScheme extends StandardScheme<deleteSingle_args> {
7843
7844 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_args struct) throws org.apache.thrift.TException {
7845 org.apache.thrift.protocol.TField schemeField;
7846 iprot.readStructBegin();
7847 while (true)
7848 {
7849 schemeField = iprot.readFieldBegin();
7850 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
7851 break;
7852 }
7853 switch (schemeField.id) {
7854 case 1:
7855 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
7856 struct.table = iprot.readBinary();
7857 struct.setTableIsSet(true);
7858 } else {
7859 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7860 }
7861 break;
7862 case 2:
7863 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
7864 struct.deleteSingle = new TDelete();
7865 struct.deleteSingle.read(iprot);
7866 struct.setDeleteSingleIsSet(true);
7867 } else {
7868 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7869 }
7870 break;
7871 default:
7872 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7873 }
7874 iprot.readFieldEnd();
7875 }
7876 iprot.readStructEnd();
7877
7878
7879 struct.validate();
7880 }
7881
7882 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_args struct) throws org.apache.thrift.TException {
7883 struct.validate();
7884
7885 oprot.writeStructBegin(STRUCT_DESC);
7886 if (struct.table != null) {
7887 oprot.writeFieldBegin(TABLE_FIELD_DESC);
7888 oprot.writeBinary(struct.table);
7889 oprot.writeFieldEnd();
7890 }
7891 if (struct.deleteSingle != null) {
7892 oprot.writeFieldBegin(DELETE_SINGLE_FIELD_DESC);
7893 struct.deleteSingle.write(oprot);
7894 oprot.writeFieldEnd();
7895 }
7896 oprot.writeFieldStop();
7897 oprot.writeStructEnd();
7898 }
7899
7900 }
7901
7902 private static class deleteSingle_argsTupleSchemeFactory implements SchemeFactory {
7903 public deleteSingle_argsTupleScheme getScheme() {
7904 return new deleteSingle_argsTupleScheme();
7905 }
7906 }
7907
7908 private static class deleteSingle_argsTupleScheme extends TupleScheme<deleteSingle_args> {
7909
7910 @Override
7911 public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
7912 TTupleProtocol oprot = (TTupleProtocol) prot;
7913 oprot.writeBinary(struct.table);
7914 struct.deleteSingle.write(oprot);
7915 }
7916
7917 @Override
7918 public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
7919 TTupleProtocol iprot = (TTupleProtocol) prot;
7920 struct.table = iprot.readBinary();
7921 struct.setTableIsSet(true);
7922 struct.deleteSingle = new TDelete();
7923 struct.deleteSingle.read(iprot);
7924 struct.setDeleteSingleIsSet(true);
7925 }
7926 }
7927
7928 }
7929
7930 public static class deleteSingle_result implements org.apache.thrift.TBase<deleteSingle_result, deleteSingle_result._Fields>, java.io.Serializable, Cloneable {
7931 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_result");
7932
7933 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);
7934
7935 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7936 static {
7937 schemes.put(StandardScheme.class, new deleteSingle_resultStandardSchemeFactory());
7938 schemes.put(TupleScheme.class, new deleteSingle_resultTupleSchemeFactory());
7939 }
7940
7941 public TIOError io;
7942
7943
7944 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7945 IO((short)1, "io");
7946
7947 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7948
7949 static {
7950 for (_Fields field : EnumSet.allOf(_Fields.class)) {
7951 byName.put(field.getFieldName(), field);
7952 }
7953 }
7954
7955
7956
7957
7958 public static _Fields findByThriftId(int fieldId) {
7959 switch(fieldId) {
7960 case 1:
7961 return IO;
7962 default:
7963 return null;
7964 }
7965 }
7966
7967
7968
7969
7970
7971 public static _Fields findByThriftIdOrThrow(int fieldId) {
7972 _Fields fields = findByThriftId(fieldId);
7973 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7974 return fields;
7975 }
7976
7977
7978
7979
7980 public static _Fields findByName(String name) {
7981 return byName.get(name);
7982 }
7983
7984 private final short _thriftId;
7985 private final String _fieldName;
7986
7987 _Fields(short thriftId, String fieldName) {
7988 _thriftId = thriftId;
7989 _fieldName = fieldName;
7990 }
7991
7992 public short getThriftFieldId() {
7993 return _thriftId;
7994 }
7995
7996 public String getFieldName() {
7997 return _fieldName;
7998 }
7999 }
8000
8001
8002 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8003 static {
8004 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8005 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
8006 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
8007 metaDataMap = Collections.unmodifiableMap(tmpMap);
8008 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_result.class, metaDataMap);
8009 }
8010
8011 public deleteSingle_result() {
8012 }
8013
8014 public deleteSingle_result(
8015 TIOError io)
8016 {
8017 this();
8018 this.io = io;
8019 }
8020
8021
8022
8023
8024 public deleteSingle_result(deleteSingle_result other) {
8025 if (other.isSetIo()) {
8026 this.io = new TIOError(other.io);
8027 }
8028 }
8029
8030 public deleteSingle_result deepCopy() {
8031 return new deleteSingle_result(this);
8032 }
8033
8034 @Override
8035 public void clear() {
8036 this.io = null;
8037 }
8038
8039 public TIOError getIo() {
8040 return this.io;
8041 }
8042
8043 public deleteSingle_result setIo(TIOError io) {
8044 this.io = io;
8045 return this;
8046 }
8047
8048 public void unsetIo() {
8049 this.io = null;
8050 }
8051
8052
8053 public boolean isSetIo() {
8054 return this.io != null;
8055 }
8056
8057 public void setIoIsSet(boolean value) {
8058 if (!value) {
8059 this.io = null;
8060 }
8061 }
8062
8063 public void setFieldValue(_Fields field, Object value) {
8064 switch (field) {
8065 case IO:
8066 if (value == null) {
8067 unsetIo();
8068 } else {
8069 setIo((TIOError)value);
8070 }
8071 break;
8072
8073 }
8074 }
8075
8076 public Object getFieldValue(_Fields field) {
8077 switch (field) {
8078 case IO:
8079 return getIo();
8080
8081 }
8082 throw new IllegalStateException();
8083 }
8084
8085
8086 public boolean isSet(_Fields field) {
8087 if (field == null) {
8088 throw new IllegalArgumentException();
8089 }
8090
8091 switch (field) {
8092 case IO:
8093 return isSetIo();
8094 }
8095 throw new IllegalStateException();
8096 }
8097
8098 @Override
8099 public boolean equals(Object that) {
8100 if (that == null)
8101 return false;
8102 if (that instanceof deleteSingle_result)
8103 return this.equals((deleteSingle_result)that);
8104 return false;
8105 }
8106
8107 public boolean equals(deleteSingle_result that) {
8108 if (that == null)
8109 return false;
8110
8111 boolean this_present_io = true && this.isSetIo();
8112 boolean that_present_io = true && that.isSetIo();
8113 if (this_present_io || that_present_io) {
8114 if (!(this_present_io && that_present_io))
8115 return false;
8116 if (!this.io.equals(that.io))
8117 return false;
8118 }
8119
8120 return true;
8121 }
8122
8123 @Override
8124 public int hashCode() {
8125 return 0;
8126 }
8127
8128 public int compareTo(deleteSingle_result other) {
8129 if (!getClass().equals(other.getClass())) {
8130 return getClass().getName().compareTo(other.getClass().getName());
8131 }
8132
8133 int lastComparison = 0;
8134 deleteSingle_result typedOther = (deleteSingle_result)other;
8135
8136 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
8137 if (lastComparison != 0) {
8138 return lastComparison;
8139 }
8140 if (isSetIo()) {
8141 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
8142 if (lastComparison != 0) {
8143 return lastComparison;
8144 }
8145 }
8146 return 0;
8147 }
8148
8149 public _Fields fieldForId(int fieldId) {
8150 return _Fields.findByThriftId(fieldId);
8151 }
8152
8153 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8154 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8155 }
8156
8157 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8158 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8159 }
8160
8161 @Override
8162 public String toString() {
8163 StringBuilder sb = new StringBuilder("deleteSingle_result(");
8164 boolean first = true;
8165
8166 sb.append("io:");
8167 if (this.io == null) {
8168 sb.append("null");
8169 } else {
8170 sb.append(this.io);
8171 }
8172 first = false;
8173 sb.append(")");
8174 return sb.toString();
8175 }
8176
8177 public void validate() throws org.apache.thrift.TException {
8178
8179 }
8180
8181 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8182 try {
8183 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8184 } catch (org.apache.thrift.TException te) {
8185 throw new java.io.IOException(te);
8186 }
8187 }
8188
8189 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8190 try {
8191 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8192 } catch (org.apache.thrift.TException te) {
8193 throw new java.io.IOException(te);
8194 }
8195 }
8196
8197 private static class deleteSingle_resultStandardSchemeFactory implements SchemeFactory {
8198 public deleteSingle_resultStandardScheme getScheme() {
8199 return new deleteSingle_resultStandardScheme();
8200 }
8201 }
8202
8203 private static class deleteSingle_resultStandardScheme extends StandardScheme<deleteSingle_result> {
8204
8205 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8206 org.apache.thrift.protocol.TField schemeField;
8207 iprot.readStructBegin();
8208 while (true)
8209 {
8210 schemeField = iprot.readFieldBegin();
8211 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
8212 break;
8213 }
8214 switch (schemeField.id) {
8215 case 1:
8216 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
8217 struct.io = new TIOError();
8218 struct.io.read(iprot);
8219 struct.setIoIsSet(true);
8220 } else {
8221 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8222 }
8223 break;
8224 default:
8225 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8226 }
8227 iprot.readFieldEnd();
8228 }
8229 iprot.readStructEnd();
8230
8231
8232 struct.validate();
8233 }
8234
8235 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8236 struct.validate();
8237
8238 oprot.writeStructBegin(STRUCT_DESC);
8239 if (struct.io != null) {
8240 oprot.writeFieldBegin(IO_FIELD_DESC);
8241 struct.io.write(oprot);
8242 oprot.writeFieldEnd();
8243 }
8244 oprot.writeFieldStop();
8245 oprot.writeStructEnd();
8246 }
8247
8248 }
8249
8250 private static class deleteSingle_resultTupleSchemeFactory implements SchemeFactory {
8251 public deleteSingle_resultTupleScheme getScheme() {
8252 return new deleteSingle_resultTupleScheme();
8253 }
8254 }
8255
8256 private static class deleteSingle_resultTupleScheme extends TupleScheme<deleteSingle_result> {
8257
8258 @Override
8259 public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8260 TTupleProtocol oprot = (TTupleProtocol) prot;
8261 BitSet optionals = new BitSet();
8262 if (struct.isSetIo()) {
8263 optionals.set(0);
8264 }
8265 oprot.writeBitSet(optionals, 1);
8266 if (struct.isSetIo()) {
8267 struct.io.write(oprot);
8268 }
8269 }
8270
8271 @Override
8272 public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8273 TTupleProtocol iprot = (TTupleProtocol) prot;
8274 BitSet incoming = iprot.readBitSet(1);
8275 if (incoming.get(0)) {
8276 struct.io = new TIOError();
8277 struct.io.read(iprot);
8278 struct.setIoIsSet(true);
8279 }
8280 }
8281 }
8282
8283 }
8284
8285 public static class deleteMultiple_args implements org.apache.thrift.TBase<deleteMultiple_args, deleteMultiple_args._Fields>, java.io.Serializable, Cloneable {
8286 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_args");
8287
8288 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);
8289 private static final org.apache.thrift.protocol.TField DELETES_FIELD_DESC = new org.apache.thrift.protocol.TField("deletes", org.apache.thrift.protocol.TType.LIST, (short)2);
8290
8291 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8292 static {
8293 schemes.put(StandardScheme.class, new deleteMultiple_argsStandardSchemeFactory());
8294 schemes.put(TupleScheme.class, new deleteMultiple_argsTupleSchemeFactory());
8295 }
8296
8297
8298
8299
8300 public ByteBuffer table;
8301
8302
8303
8304 public List<TDelete> deletes;
8305
8306
8307 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8308
8309
8310
8311 TABLE((short)1, "table"),
8312
8313
8314
8315 DELETES((short)2, "deletes");
8316
8317 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8318
8319 static {
8320 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8321 byName.put(field.getFieldName(), field);
8322 }
8323 }
8324
8325
8326
8327
8328 public static _Fields findByThriftId(int fieldId) {
8329 switch(fieldId) {
8330 case 1:
8331 return TABLE;
8332 case 2:
8333 return DELETES;
8334 default:
8335 return null;
8336 }
8337 }
8338
8339
8340
8341
8342
8343 public static _Fields findByThriftIdOrThrow(int fieldId) {
8344 _Fields fields = findByThriftId(fieldId);
8345 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8346 return fields;
8347 }
8348
8349
8350
8351
8352 public static _Fields findByName(String name) {
8353 return byName.get(name);
8354 }
8355
8356 private final short _thriftId;
8357 private final String _fieldName;
8358
8359 _Fields(short thriftId, String fieldName) {
8360 _thriftId = thriftId;
8361 _fieldName = fieldName;
8362 }
8363
8364 public short getThriftFieldId() {
8365 return _thriftId;
8366 }
8367
8368 public String getFieldName() {
8369 return _fieldName;
8370 }
8371 }
8372
8373
8374 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8375 static {
8376 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8377 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
8378 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
8379 tmpMap.put(_Fields.DELETES, new org.apache.thrift.meta_data.FieldMetaData("deletes", org.apache.thrift.TFieldRequirementType.REQUIRED,
8380 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
8381 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
8382 metaDataMap = Collections.unmodifiableMap(tmpMap);
8383 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_args.class, metaDataMap);
8384 }
8385
8386 public deleteMultiple_args() {
8387 }
8388
8389 public deleteMultiple_args(
8390 ByteBuffer table,
8391 List<TDelete> deletes)
8392 {
8393 this();
8394 this.table = table;
8395 this.deletes = deletes;
8396 }
8397
8398
8399
8400
8401 public deleteMultiple_args(deleteMultiple_args other) {
8402 if (other.isSetTable()) {
8403 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
8404 ;
8405 }
8406 if (other.isSetDeletes()) {
8407 List<TDelete> __this__deletes = new ArrayList<TDelete>();
8408 for (TDelete other_element : other.deletes) {
8409 __this__deletes.add(new TDelete(other_element));
8410 }
8411 this.deletes = __this__deletes;
8412 }
8413 }
8414
8415 public deleteMultiple_args deepCopy() {
8416 return new deleteMultiple_args(this);
8417 }
8418
8419 @Override
8420 public void clear() {
8421 this.table = null;
8422 this.deletes = null;
8423 }
8424
8425
8426
8427
8428 public byte[] getTable() {
8429 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
8430 return table == null ? null : table.array();
8431 }
8432
8433 public ByteBuffer bufferForTable() {
8434 return table;
8435 }
8436
8437
8438
8439
8440 public deleteMultiple_args setTable(byte[] table) {
8441 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
8442 return this;
8443 }
8444
8445 public deleteMultiple_args setTable(ByteBuffer table) {
8446 this.table = table;
8447 return this;
8448 }
8449
8450 public void unsetTable() {
8451 this.table = null;
8452 }
8453
8454
8455 public boolean isSetTable() {
8456 return this.table != null;
8457 }
8458
8459 public void setTableIsSet(boolean value) {
8460 if (!value) {
8461 this.table = null;
8462 }
8463 }
8464
8465 public int getDeletesSize() {
8466 return (this.deletes == null) ? 0 : this.deletes.size();
8467 }
8468
8469 public java.util.Iterator<TDelete> getDeletesIterator() {
8470 return (this.deletes == null) ? null : this.deletes.iterator();
8471 }
8472
8473 public void addToDeletes(TDelete elem) {
8474 if (this.deletes == null) {
8475 this.deletes = new ArrayList<TDelete>();
8476 }
8477 this.deletes.add(elem);
8478 }
8479
8480
8481
8482
8483 public List<TDelete> getDeletes() {
8484 return this.deletes;
8485 }
8486
8487
8488
8489
8490 public deleteMultiple_args setDeletes(List<TDelete> deletes) {
8491 this.deletes = deletes;
8492 return this;
8493 }
8494
8495 public void unsetDeletes() {
8496 this.deletes = null;
8497 }
8498
8499
8500 public boolean isSetDeletes() {
8501 return this.deletes != null;
8502 }
8503
8504 public void setDeletesIsSet(boolean value) {
8505 if (!value) {
8506 this.deletes = null;
8507 }
8508 }
8509
8510 public void setFieldValue(_Fields field, Object value) {
8511 switch (field) {
8512 case TABLE:
8513 if (value == null) {
8514 unsetTable();
8515 } else {
8516 setTable((ByteBuffer)value);
8517 }
8518 break;
8519
8520 case DELETES:
8521 if (value == null) {
8522 unsetDeletes();
8523 } else {
8524 setDeletes((List<TDelete>)value);
8525 }
8526 break;
8527
8528 }
8529 }
8530
8531 public Object getFieldValue(_Fields field) {
8532 switch (field) {
8533 case TABLE:
8534 return getTable();
8535
8536 case DELETES:
8537 return getDeletes();
8538
8539 }
8540 throw new IllegalStateException();
8541 }
8542
8543
8544 public boolean isSet(_Fields field) {
8545 if (field == null) {
8546 throw new IllegalArgumentException();
8547 }
8548
8549 switch (field) {
8550 case TABLE:
8551 return isSetTable();
8552 case DELETES:
8553 return isSetDeletes();
8554 }
8555 throw new IllegalStateException();
8556 }
8557
8558 @Override
8559 public boolean equals(Object that) {
8560 if (that == null)
8561 return false;
8562 if (that instanceof deleteMultiple_args)
8563 return this.equals((deleteMultiple_args)that);
8564 return false;
8565 }
8566
8567 public boolean equals(deleteMultiple_args that) {
8568 if (that == null)
8569 return false;
8570
8571 boolean this_present_table = true && this.isSetTable();
8572 boolean that_present_table = true && that.isSetTable();
8573 if (this_present_table || that_present_table) {
8574 if (!(this_present_table && that_present_table))
8575 return false;
8576 if (!this.table.equals(that.table))
8577 return false;
8578 }
8579
8580 boolean this_present_deletes = true && this.isSetDeletes();
8581 boolean that_present_deletes = true && that.isSetDeletes();
8582 if (this_present_deletes || that_present_deletes) {
8583 if (!(this_present_deletes && that_present_deletes))
8584 return false;
8585 if (!this.deletes.equals(that.deletes))
8586 return false;
8587 }
8588
8589 return true;
8590 }
8591
8592 @Override
8593 public int hashCode() {
8594 return 0;
8595 }
8596
8597 public int compareTo(deleteMultiple_args other) {
8598 if (!getClass().equals(other.getClass())) {
8599 return getClass().getName().compareTo(other.getClass().getName());
8600 }
8601
8602 int lastComparison = 0;
8603 deleteMultiple_args typedOther = (deleteMultiple_args)other;
8604
8605 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
8606 if (lastComparison != 0) {
8607 return lastComparison;
8608 }
8609 if (isSetTable()) {
8610 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
8611 if (lastComparison != 0) {
8612 return lastComparison;
8613 }
8614 }
8615 lastComparison = Boolean.valueOf(isSetDeletes()).compareTo(typedOther.isSetDeletes());
8616 if (lastComparison != 0) {
8617 return lastComparison;
8618 }
8619 if (isSetDeletes()) {
8620 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deletes, typedOther.deletes);
8621 if (lastComparison != 0) {
8622 return lastComparison;
8623 }
8624 }
8625 return 0;
8626 }
8627
8628 public _Fields fieldForId(int fieldId) {
8629 return _Fields.findByThriftId(fieldId);
8630 }
8631
8632 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8633 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8634 }
8635
8636 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8637 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8638 }
8639
8640 @Override
8641 public String toString() {
8642 StringBuilder sb = new StringBuilder("deleteMultiple_args(");
8643 boolean first = true;
8644
8645 sb.append("table:");
8646 if (this.table == null) {
8647 sb.append("null");
8648 } else {
8649 org.apache.thrift.TBaseHelper.toString(this.table, sb);
8650 }
8651 first = false;
8652 if (!first) sb.append(", ");
8653 sb.append("deletes:");
8654 if (this.deletes == null) {
8655 sb.append("null");
8656 } else {
8657 sb.append(this.deletes);
8658 }
8659 first = false;
8660 sb.append(")");
8661 return sb.toString();
8662 }
8663
8664 public void validate() throws org.apache.thrift.TException {
8665
8666 if (table == null) {
8667 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
8668 }
8669 if (deletes == null) {
8670 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deletes' was not present! Struct: " + toString());
8671 }
8672 }
8673
8674 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8675 try {
8676 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8677 } catch (org.apache.thrift.TException te) {
8678 throw new java.io.IOException(te);
8679 }
8680 }
8681
8682 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8683 try {
8684 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8685 } catch (org.apache.thrift.TException te) {
8686 throw new java.io.IOException(te);
8687 }
8688 }
8689
8690 private static class deleteMultiple_argsStandardSchemeFactory implements SchemeFactory {
8691 public deleteMultiple_argsStandardScheme getScheme() {
8692 return new deleteMultiple_argsStandardScheme();
8693 }
8694 }
8695
8696 private static class deleteMultiple_argsStandardScheme extends StandardScheme<deleteMultiple_args> {
8697
8698 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8699 org.apache.thrift.protocol.TField schemeField;
8700 iprot.readStructBegin();
8701 while (true)
8702 {
8703 schemeField = iprot.readFieldBegin();
8704 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
8705 break;
8706 }
8707 switch (schemeField.id) {
8708 case 1:
8709 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
8710 struct.table = iprot.readBinary();
8711 struct.setTableIsSet(true);
8712 } else {
8713 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8714 }
8715 break;
8716 case 2:
8717 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
8718 {
8719 org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();
8720 struct.deletes = new ArrayList<TDelete>(_list72.size);
8721 for (int _i73 = 0; _i73 < _list72.size; ++_i73)
8722 {
8723 TDelete _elem74;
8724 _elem74 = new TDelete();
8725 _elem74.read(iprot);
8726 struct.deletes.add(_elem74);
8727 }
8728 iprot.readListEnd();
8729 }
8730 struct.setDeletesIsSet(true);
8731 } else {
8732 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8733 }
8734 break;
8735 default:
8736 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8737 }
8738 iprot.readFieldEnd();
8739 }
8740 iprot.readStructEnd();
8741
8742
8743 struct.validate();
8744 }
8745
8746 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8747 struct.validate();
8748
8749 oprot.writeStructBegin(STRUCT_DESC);
8750 if (struct.table != null) {
8751 oprot.writeFieldBegin(TABLE_FIELD_DESC);
8752 oprot.writeBinary(struct.table);
8753 oprot.writeFieldEnd();
8754 }
8755 if (struct.deletes != null) {
8756 oprot.writeFieldBegin(DELETES_FIELD_DESC);
8757 {
8758 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.deletes.size()));
8759 for (TDelete _iter75 : struct.deletes)
8760 {
8761 _iter75.write(oprot);
8762 }
8763 oprot.writeListEnd();
8764 }
8765 oprot.writeFieldEnd();
8766 }
8767 oprot.writeFieldStop();
8768 oprot.writeStructEnd();
8769 }
8770
8771 }
8772
8773 private static class deleteMultiple_argsTupleSchemeFactory implements SchemeFactory {
8774 public deleteMultiple_argsTupleScheme getScheme() {
8775 return new deleteMultiple_argsTupleScheme();
8776 }
8777 }
8778
8779 private static class deleteMultiple_argsTupleScheme extends TupleScheme<deleteMultiple_args> {
8780
8781 @Override
8782 public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8783 TTupleProtocol oprot = (TTupleProtocol) prot;
8784 oprot.writeBinary(struct.table);
8785 {
8786 oprot.writeI32(struct.deletes.size());
8787 for (TDelete _iter76 : struct.deletes)
8788 {
8789 _iter76.write(oprot);
8790 }
8791 }
8792 }
8793
8794 @Override
8795 public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8796 TTupleProtocol iprot = (TTupleProtocol) prot;
8797 struct.table = iprot.readBinary();
8798 struct.setTableIsSet(true);
8799 {
8800 org.apache.thrift.protocol.TList _list77 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
8801 struct.deletes = new ArrayList<TDelete>(_list77.size);
8802 for (int _i78 = 0; _i78 < _list77.size; ++_i78)
8803 {
8804 TDelete _elem79;
8805 _elem79 = new TDelete();
8806 _elem79.read(iprot);
8807 struct.deletes.add(_elem79);
8808 }
8809 }
8810 struct.setDeletesIsSet(true);
8811 }
8812 }
8813
8814 }
8815
8816 public static class deleteMultiple_result implements org.apache.thrift.TBase<deleteMultiple_result, deleteMultiple_result._Fields>, java.io.Serializable, Cloneable {
8817 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_result");
8818
8819 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);
8820 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);
8821
8822 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8823 static {
8824 schemes.put(StandardScheme.class, new deleteMultiple_resultStandardSchemeFactory());
8825 schemes.put(TupleScheme.class, new deleteMultiple_resultTupleSchemeFactory());
8826 }
8827
8828 public List<TDelete> success;
8829 public TIOError io;
8830
8831
8832 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8833 SUCCESS((short)0, "success"),
8834 IO((short)1, "io");
8835
8836 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8837
8838 static {
8839 for (_Fields field : EnumSet.allOf(_Fields.class)) {
8840 byName.put(field.getFieldName(), field);
8841 }
8842 }
8843
8844
8845
8846
8847 public static _Fields findByThriftId(int fieldId) {
8848 switch(fieldId) {
8849 case 0:
8850 return SUCCESS;
8851 case 1:
8852 return IO;
8853 default:
8854 return null;
8855 }
8856 }
8857
8858
8859
8860
8861
8862 public static _Fields findByThriftIdOrThrow(int fieldId) {
8863 _Fields fields = findByThriftId(fieldId);
8864 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8865 return fields;
8866 }
8867
8868
8869
8870
8871 public static _Fields findByName(String name) {
8872 return byName.get(name);
8873 }
8874
8875 private final short _thriftId;
8876 private final String _fieldName;
8877
8878 _Fields(short thriftId, String fieldName) {
8879 _thriftId = thriftId;
8880 _fieldName = fieldName;
8881 }
8882
8883 public short getThriftFieldId() {
8884 return _thriftId;
8885 }
8886
8887 public String getFieldName() {
8888 return _fieldName;
8889 }
8890 }
8891
8892
8893 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8894 static {
8895 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8896 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
8897 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
8898 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
8899 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
8900 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
8901 metaDataMap = Collections.unmodifiableMap(tmpMap);
8902 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_result.class, metaDataMap);
8903 }
8904
8905 public deleteMultiple_result() {
8906 }
8907
8908 public deleteMultiple_result(
8909 List<TDelete> success,
8910 TIOError io)
8911 {
8912 this();
8913 this.success = success;
8914 this.io = io;
8915 }
8916
8917
8918
8919
8920 public deleteMultiple_result(deleteMultiple_result other) {
8921 if (other.isSetSuccess()) {
8922 List<TDelete> __this__success = new ArrayList<TDelete>();
8923 for (TDelete other_element : other.success) {
8924 __this__success.add(new TDelete(other_element));
8925 }
8926 this.success = __this__success;
8927 }
8928 if (other.isSetIo()) {
8929 this.io = new TIOError(other.io);
8930 }
8931 }
8932
8933 public deleteMultiple_result deepCopy() {
8934 return new deleteMultiple_result(this);
8935 }
8936
8937 @Override
8938 public void clear() {
8939 this.success = null;
8940 this.io = null;
8941 }
8942
8943 public int getSuccessSize() {
8944 return (this.success == null) ? 0 : this.success.size();
8945 }
8946
8947 public java.util.Iterator<TDelete> getSuccessIterator() {
8948 return (this.success == null) ? null : this.success.iterator();
8949 }
8950
8951 public void addToSuccess(TDelete elem) {
8952 if (this.success == null) {
8953 this.success = new ArrayList<TDelete>();
8954 }
8955 this.success.add(elem);
8956 }
8957
8958 public List<TDelete> getSuccess() {
8959 return this.success;
8960 }
8961
8962 public deleteMultiple_result setSuccess(List<TDelete> success) {
8963 this.success = success;
8964 return this;
8965 }
8966
8967 public void unsetSuccess() {
8968 this.success = null;
8969 }
8970
8971
8972 public boolean isSetSuccess() {
8973 return this.success != null;
8974 }
8975
8976 public void setSuccessIsSet(boolean value) {
8977 if (!value) {
8978 this.success = null;
8979 }
8980 }
8981
8982 public TIOError getIo() {
8983 return this.io;
8984 }
8985
8986 public deleteMultiple_result setIo(TIOError io) {
8987 this.io = io;
8988 return this;
8989 }
8990
8991 public void unsetIo() {
8992 this.io = null;
8993 }
8994
8995
8996 public boolean isSetIo() {
8997 return this.io != null;
8998 }
8999
9000 public void setIoIsSet(boolean value) {
9001 if (!value) {
9002 this.io = null;
9003 }
9004 }
9005
9006 public void setFieldValue(_Fields field, Object value) {
9007 switch (field) {
9008 case SUCCESS:
9009 if (value == null) {
9010 unsetSuccess();
9011 } else {
9012 setSuccess((List<TDelete>)value);
9013 }
9014 break;
9015
9016 case IO:
9017 if (value == null) {
9018 unsetIo();
9019 } else {
9020 setIo((TIOError)value);
9021 }
9022 break;
9023
9024 }
9025 }
9026
9027 public Object getFieldValue(_Fields field) {
9028 switch (field) {
9029 case SUCCESS:
9030 return getSuccess();
9031
9032 case IO:
9033 return getIo();
9034
9035 }
9036 throw new IllegalStateException();
9037 }
9038
9039
9040 public boolean isSet(_Fields field) {
9041 if (field == null) {
9042 throw new IllegalArgumentException();
9043 }
9044
9045 switch (field) {
9046 case SUCCESS:
9047 return isSetSuccess();
9048 case IO:
9049 return isSetIo();
9050 }
9051 throw new IllegalStateException();
9052 }
9053
9054 @Override
9055 public boolean equals(Object that) {
9056 if (that == null)
9057 return false;
9058 if (that instanceof deleteMultiple_result)
9059 return this.equals((deleteMultiple_result)that);
9060 return false;
9061 }
9062
9063 public boolean equals(deleteMultiple_result that) {
9064 if (that == null)
9065 return false;
9066
9067 boolean this_present_success = true && this.isSetSuccess();
9068 boolean that_present_success = true && that.isSetSuccess();
9069 if (this_present_success || that_present_success) {
9070 if (!(this_present_success && that_present_success))
9071 return false;
9072 if (!this.success.equals(that.success))
9073 return false;
9074 }
9075
9076 boolean this_present_io = true && this.isSetIo();
9077 boolean that_present_io = true && that.isSetIo();
9078 if (this_present_io || that_present_io) {
9079 if (!(this_present_io && that_present_io))
9080 return false;
9081 if (!this.io.equals(that.io))
9082 return false;
9083 }
9084
9085 return true;
9086 }
9087
9088 @Override
9089 public int hashCode() {
9090 return 0;
9091 }
9092
9093 public int compareTo(deleteMultiple_result other) {
9094 if (!getClass().equals(other.getClass())) {
9095 return getClass().getName().compareTo(other.getClass().getName());
9096 }
9097
9098 int lastComparison = 0;
9099 deleteMultiple_result typedOther = (deleteMultiple_result)other;
9100
9101 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
9102 if (lastComparison != 0) {
9103 return lastComparison;
9104 }
9105 if (isSetSuccess()) {
9106 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
9107 if (lastComparison != 0) {
9108 return lastComparison;
9109 }
9110 }
9111 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
9112 if (lastComparison != 0) {
9113 return lastComparison;
9114 }
9115 if (isSetIo()) {
9116 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
9117 if (lastComparison != 0) {
9118 return lastComparison;
9119 }
9120 }
9121 return 0;
9122 }
9123
9124 public _Fields fieldForId(int fieldId) {
9125 return _Fields.findByThriftId(fieldId);
9126 }
9127
9128 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
9129 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
9130 }
9131
9132 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
9133 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
9134 }
9135
9136 @Override
9137 public String toString() {
9138 StringBuilder sb = new StringBuilder("deleteMultiple_result(");
9139 boolean first = true;
9140
9141 sb.append("success:");
9142 if (this.success == null) {
9143 sb.append("null");
9144 } else {
9145 sb.append(this.success);
9146 }
9147 first = false;
9148 if (!first) sb.append(", ");
9149 sb.append("io:");
9150 if (this.io == null) {
9151 sb.append("null");
9152 } else {
9153 sb.append(this.io);
9154 }
9155 first = false;
9156 sb.append(")");
9157 return sb.toString();
9158 }
9159
9160 public void validate() throws org.apache.thrift.TException {
9161
9162 }
9163
9164 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
9165 try {
9166 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
9167 } catch (org.apache.thrift.TException te) {
9168 throw new java.io.IOException(te);
9169 }
9170 }
9171
9172 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
9173 try {
9174 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
9175 } catch (org.apache.thrift.TException te) {
9176 throw new java.io.IOException(te);
9177 }
9178 }
9179
9180 private static class deleteMultiple_resultStandardSchemeFactory implements SchemeFactory {
9181 public deleteMultiple_resultStandardScheme getScheme() {
9182 return new deleteMultiple_resultStandardScheme();
9183 }
9184 }
9185
9186 private static class deleteMultiple_resultStandardScheme extends StandardScheme<deleteMultiple_result> {
9187
9188 public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9189 org.apache.thrift.protocol.TField schemeField;
9190 iprot.readStructBegin();
9191 while (true)
9192 {
9193 schemeField = iprot.readFieldBegin();
9194 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
9195 break;
9196 }
9197 switch (schemeField.id) {
9198 case 0:
9199 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
9200 {
9201 org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();
9202 struct.success = new ArrayList<TDelete>(_list80.size);
9203 for (int _i81 = 0; _i81 < _list80.size; ++_i81)
9204 {
9205 TDelete _elem82;
9206 _elem82 = new TDelete();
9207 _elem82.read(iprot);
9208 struct.success.add(_elem82);
9209 }
9210 iprot.readListEnd();
9211 }
9212 struct.setSuccessIsSet(true);
9213 } else {
9214 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9215 }
9216 break;
9217 case 1:
9218 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
9219 struct.io = new TIOError();
9220 struct.io.read(iprot);
9221 struct.setIoIsSet(true);
9222 } else {
9223 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9224 }
9225 break;
9226 default:
9227 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9228 }
9229 iprot.readFieldEnd();
9230 }
9231 iprot.readStructEnd();
9232
9233
9234 struct.validate();
9235 }
9236
9237 public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9238 struct.validate();
9239
9240 oprot.writeStructBegin(STRUCT_DESC);
9241 if (struct.success != null) {
9242 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
9243 {
9244 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
9245 for (TDelete _iter83 : struct.success)
9246 {
9247 _iter83.write(oprot);
9248 }
9249 oprot.writeListEnd();
9250 }
9251 oprot.writeFieldEnd();
9252 }
9253 if (struct.io != null) {
9254 oprot.writeFieldBegin(IO_FIELD_DESC);
9255 struct.io.write(oprot);
9256 oprot.writeFieldEnd();
9257 }
9258 oprot.writeFieldStop();
9259 oprot.writeStructEnd();
9260 }
9261
9262 }
9263
9264 private static class deleteMultiple_resultTupleSchemeFactory implements SchemeFactory {
9265 public deleteMultiple_resultTupleScheme getScheme() {
9266 return new deleteMultiple_resultTupleScheme();
9267 }
9268 }
9269
9270 private static class deleteMultiple_resultTupleScheme extends TupleScheme<deleteMultiple_result> {
9271
9272 @Override
9273 public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9274 TTupleProtocol oprot = (TTupleProtocol) prot;
9275 BitSet optionals = new BitSet();
9276 if (struct.isSetSuccess()) {
9277 optionals.set(0);
9278 }
9279 if (struct.isSetIo()) {
9280 optionals.set(1);
9281 }
9282 oprot.writeBitSet(optionals, 2);
9283 if (struct.isSetSuccess()) {
9284 {
9285 oprot.writeI32(struct.success.size());
9286 for (TDelete _iter84 : struct.success)
9287 {
9288 _iter84.write(oprot);
9289 }
9290 }
9291 }
9292 if (struct.isSetIo()) {
9293 struct.io.write(oprot);
9294 }
9295 }
9296
9297 @Override
9298 public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9299 TTupleProtocol iprot = (TTupleProtocol) prot;
9300 BitSet incoming = iprot.readBitSet(2);
9301 if (incoming.get(0)) {
9302 {
9303 org.apache.thrift.protocol.TList _list85 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
9304 struct.success = new ArrayList<TDelete>(_list85.size);
9305 for (int _i86 = 0; _i86 < _list85.size; ++_i86)
9306 {
9307 TDelete _elem87;
9308 _elem87 = new TDelete();
9309 _elem87.read(iprot);
9310 struct.success.add(_elem87);
9311 }
9312 }
9313 struct.setSuccessIsSet(true);
9314 }
9315 if (incoming.get(1)) {
9316 struct.io = new TIOError();
9317 struct.io.read(iprot);
9318 struct.setIoIsSet(true);
9319 }
9320 }
9321 }
9322
9323 }
9324
9325 public static class checkAndDelete_args implements org.apache.thrift.TBase<checkAndDelete_args, checkAndDelete_args._Fields>, java.io.Serializable, Cloneable {
9326 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_args");
9327
9328 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);
9329 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);
9330 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);
9331 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);
9332 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);
9333 private static final org.apache.thrift.protocol.TField DELETE_SINGLE_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteSingle", org.apache.thrift.protocol.TType.STRUCT, (short)6);
9334
9335 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
9336 static {
9337 schemes.put(StandardScheme.class, new checkAndDelete_argsStandardSchemeFactory());
9338 schemes.put(TupleScheme.class, new checkAndDelete_argsTupleSchemeFactory());
9339 }
9340
9341
9342
9343
9344 public ByteBuffer table;
9345
9346
9347
9348 public ByteBuffer row;
9349
9350
9351
9352 public ByteBuffer family;
9353
9354
9355
9356 public ByteBuffer qualifier;
9357
9358
9359
9360
9361
9362 public ByteBuffer value;
9363
9364
9365
9366 public TDelete deleteSingle;
9367
9368
9369 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
9370
9371
9372
9373 TABLE((short)1, "table"),
9374
9375
9376
9377 ROW((short)2, "row"),
9378
9379
9380
9381 FAMILY((short)3, "family"),
9382
9383
9384
9385 QUALIFIER((short)4, "qualifier"),
9386
9387
9388
9389
9390
9391 VALUE((short)5, "value"),
9392
9393
9394
9395 DELETE_SINGLE((short)6, "deleteSingle");
9396
9397 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9398
9399 static {
9400 for (_Fields field : EnumSet.allOf(_Fields.class)) {
9401 byName.put(field.getFieldName(), field);
9402 }
9403 }
9404
9405
9406
9407
9408 public static _Fields findByThriftId(int fieldId) {
9409 switch(fieldId) {
9410 case 1:
9411 return TABLE;
9412 case 2:
9413 return ROW;
9414 case 3:
9415 return FAMILY;
9416 case 4:
9417 return QUALIFIER;
9418 case 5:
9419 return VALUE;
9420 case 6:
9421 return DELETE_SINGLE;
9422 default:
9423 return null;
9424 }
9425 }
9426
9427
9428
9429
9430
9431 public static _Fields findByThriftIdOrThrow(int fieldId) {
9432 _Fields fields = findByThriftId(fieldId);
9433 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9434 return fields;
9435 }
9436
9437
9438
9439
9440 public static _Fields findByName(String name) {
9441 return byName.get(name);
9442 }
9443
9444 private final short _thriftId;
9445 private final String _fieldName;
9446
9447 _Fields(short thriftId, String fieldName) {
9448 _thriftId = thriftId;
9449 _fieldName = fieldName;
9450 }
9451
9452 public short getThriftFieldId() {
9453 return _thriftId;
9454 }
9455
9456 public String getFieldName() {
9457 return _fieldName;
9458 }
9459 }
9460
9461
9462 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
9463 static {
9464 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
9465 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
9466 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9467 tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED,
9468 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9469 tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED,
9470 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9471 tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED,
9472 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9473 tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT,
9474 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
9475 tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED,
9476 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
9477 metaDataMap = Collections.unmodifiableMap(tmpMap);
9478 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_args.class, metaDataMap);
9479 }
9480
9481 public checkAndDelete_args() {
9482 }
9483
9484 public checkAndDelete_args(
9485 ByteBuffer table,
9486 ByteBuffer row,
9487 ByteBuffer family,
9488 ByteBuffer qualifier,
9489 ByteBuffer value,
9490 TDelete deleteSingle)
9491 {
9492 this();
9493 this.table = table;
9494 this.row = row;
9495 this.family = family;
9496 this.qualifier = qualifier;
9497 this.value = value;
9498 this.deleteSingle = deleteSingle;
9499 }
9500
9501
9502
9503
9504 public checkAndDelete_args(checkAndDelete_args other) {
9505 if (other.isSetTable()) {
9506 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
9507 ;
9508 }
9509 if (other.isSetRow()) {
9510 this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
9511 ;
9512 }
9513 if (other.isSetFamily()) {
9514 this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
9515 ;
9516 }
9517 if (other.isSetQualifier()) {
9518 this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
9519 ;
9520 }
9521 if (other.isSetValue()) {
9522 this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
9523 ;
9524 }
9525 if (other.isSetDeleteSingle()) {
9526 this.deleteSingle = new TDelete(other.deleteSingle);
9527 }
9528 }
9529
9530 public checkAndDelete_args deepCopy() {
9531 return new checkAndDelete_args(this);
9532 }
9533
9534 @Override
9535 public void clear() {
9536 this.table = null;
9537 this.row = null;
9538 this.family = null;
9539 this.qualifier = null;
9540 this.value = null;
9541 this.deleteSingle = null;
9542 }
9543
9544
9545
9546
9547 public byte[] getTable() {
9548 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
9549 return table == null ? null : table.array();
9550 }
9551
9552 public ByteBuffer bufferForTable() {
9553 return table;
9554 }
9555
9556
9557
9558
9559 public checkAndDelete_args setTable(byte[] table) {
9560 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
9561 return this;
9562 }
9563
9564 public checkAndDelete_args setTable(ByteBuffer table) {
9565 this.table = table;
9566 return this;
9567 }
9568
9569 public void unsetTable() {
9570 this.table = null;
9571 }
9572
9573
9574 public boolean isSetTable() {
9575 return this.table != null;
9576 }
9577
9578 public void setTableIsSet(boolean value) {
9579 if (!value) {
9580 this.table = null;
9581 }
9582 }
9583
9584
9585
9586
9587 public byte[] getRow() {
9588 setRow(org.apache.thrift.TBaseHelper.rightSize(row));
9589 return row == null ? null : row.array();
9590 }
9591
9592 public ByteBuffer bufferForRow() {
9593 return row;
9594 }
9595
9596
9597
9598
9599 public checkAndDelete_args setRow(byte[] row) {
9600 setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
9601 return this;
9602 }
9603
9604 public checkAndDelete_args setRow(ByteBuffer row) {
9605 this.row = row;
9606 return this;
9607 }
9608
9609 public void unsetRow() {
9610 this.row = null;
9611 }
9612
9613
9614 public boolean isSetRow() {
9615 return this.row != null;
9616 }
9617
9618 public void setRowIsSet(boolean value) {
9619 if (!value) {
9620 this.row = null;
9621 }
9622 }
9623
9624
9625
9626
9627 public byte[] getFamily() {
9628 setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
9629 return family == null ? null : family.array();
9630 }
9631
9632 public ByteBuffer bufferForFamily() {
9633 return family;
9634 }
9635
9636
9637
9638
9639 public checkAndDelete_args setFamily(byte[] family) {
9640 setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
9641 return this;
9642 }
9643
9644 public checkAndDelete_args setFamily(ByteBuffer family) {
9645 this.family = family;
9646 return this;
9647 }
9648
9649 public void unsetFamily() {
9650 this.family = null;
9651 }
9652
9653
9654 public boolean isSetFamily() {
9655 return this.family != null;
9656 }
9657
9658 public void setFamilyIsSet(boolean value) {
9659 if (!value) {
9660 this.family = null;
9661 }
9662 }
9663
9664
9665
9666
9667 public byte[] getQualifier() {
9668 setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
9669 return qualifier == null ? null : qualifier.array();
9670 }
9671
9672 public ByteBuffer bufferForQualifier() {
9673 return qualifier;
9674 }
9675
9676
9677
9678
9679 public checkAndDelete_args setQualifier(byte[] qualifier) {
9680 setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
9681 return this;
9682 }
9683
9684 public checkAndDelete_args setQualifier(ByteBuffer qualifier) {
9685 this.qualifier = qualifier;
9686 return this;
9687 }
9688
9689 public void unsetQualifier() {
9690 this.qualifier = null;
9691 }
9692
9693
9694 public boolean isSetQualifier() {
9695 return this.qualifier != null;
9696 }
9697
9698 public void setQualifierIsSet(boolean value) {
9699 if (!value) {
9700 this.qualifier = null;
9701 }
9702 }
9703
9704
9705
9706
9707
9708
9709 public byte[] getValue() {
9710 setValue(org.apache.thrift.TBaseHelper.rightSize(value));
9711 return value == null ? null : value.array();
9712 }
9713
9714 public ByteBuffer bufferForValue() {
9715 return value;
9716 }
9717
9718
9719
9720
9721
9722
9723 public checkAndDelete_args setValue(byte[] value) {
9724 setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
9725 return this;
9726 }
9727
9728 public checkAndDelete_args setValue(ByteBuffer value) {
9729 this.value = value;
9730 return this;
9731 }
9732
9733 public void unsetValue() {
9734 this.value = null;
9735 }
9736
9737
9738 public boolean isSetValue() {
9739 return this.value != null;
9740 }
9741
9742 public void setValueIsSet(boolean value) {
9743 if (!value) {
9744 this.value = null;
9745 }
9746 }
9747
9748
9749
9750
9751 public TDelete getDeleteSingle() {
9752 return this.deleteSingle;
9753 }
9754
9755
9756
9757
9758 public checkAndDelete_args setDeleteSingle(TDelete deleteSingle) {
9759 this.deleteSingle = deleteSingle;
9760 return this;
9761 }
9762
9763 public void unsetDeleteSingle() {
9764 this.deleteSingle = null;
9765 }
9766
9767
9768 public boolean isSetDeleteSingle() {
9769 return this.deleteSingle != null;
9770 }
9771
9772 public void setDeleteSingleIsSet(boolean value) {
9773 if (!value) {
9774 this.deleteSingle = null;
9775 }
9776 }
9777
9778 public void setFieldValue(_Fields field, Object value) {
9779 switch (field) {
9780 case TABLE:
9781 if (value == null) {
9782 unsetTable();
9783 } else {
9784 setTable((ByteBuffer)value);
9785 }
9786 break;
9787
9788 case ROW:
9789 if (value == null) {
9790 unsetRow();
9791 } else {
9792 setRow((ByteBuffer)value);
9793 }
9794 break;
9795
9796 case FAMILY:
9797 if (value == null) {
9798 unsetFamily();
9799 } else {
9800 setFamily((ByteBuffer)value);
9801 }
9802 break;
9803
9804 case QUALIFIER:
9805 if (value == null) {
9806 unsetQualifier();
9807 } else {
9808 setQualifier((ByteBuffer)value);
9809 }
9810 break;
9811
9812 case VALUE:
9813 if (value == null) {
9814 unsetValue();
9815 } else {
9816 setValue((ByteBuffer)value);
9817 }
9818 break;
9819
9820 case DELETE_SINGLE:
9821 if (value == null) {
9822 unsetDeleteSingle();
9823 } else {
9824 setDeleteSingle((TDelete)value);
9825 }
9826 break;
9827
9828 }
9829 }
9830
9831 public Object getFieldValue(_Fields field) {
9832 switch (field) {
9833 case TABLE:
9834 return getTable();
9835
9836 case ROW:
9837 return getRow();
9838
9839 case FAMILY:
9840 return getFamily();
9841
9842 case QUALIFIER:
9843 return getQualifier();
9844
9845 case VALUE:
9846 return getValue();
9847
9848 case DELETE_SINGLE:
9849 return getDeleteSingle();
9850
9851 }
9852 throw new IllegalStateException();
9853 }
9854
9855
9856 public boolean isSet(_Fields field) {
9857 if (field == null) {
9858 throw new IllegalArgumentException();
9859 }
9860
9861 switch (field) {
9862 case TABLE:
9863 return isSetTable();
9864 case ROW:
9865 return isSetRow();
9866 case FAMILY:
9867 return isSetFamily();
9868 case QUALIFIER:
9869 return isSetQualifier();
9870 case VALUE:
9871 return isSetValue();
9872 case DELETE_SINGLE:
9873 return isSetDeleteSingle();
9874 }
9875 throw new IllegalStateException();
9876 }
9877
9878 @Override
9879 public boolean equals(Object that) {
9880 if (that == null)
9881 return false;
9882 if (that instanceof checkAndDelete_args)
9883 return this.equals((checkAndDelete_args)that);
9884 return false;
9885 }
9886
9887 public boolean equals(checkAndDelete_args that) {
9888 if (that == null)
9889 return false;
9890
9891 boolean this_present_table = true && this.isSetTable();
9892 boolean that_present_table = true && that.isSetTable();
9893 if (this_present_table || that_present_table) {
9894 if (!(this_present_table && that_present_table))
9895 return false;
9896 if (!this.table.equals(that.table))
9897 return false;
9898 }
9899
9900 boolean this_present_row = true && this.isSetRow();
9901 boolean that_present_row = true && that.isSetRow();
9902 if (this_present_row || that_present_row) {
9903 if (!(this_present_row && that_present_row))
9904 return false;
9905 if (!this.row.equals(that.row))
9906 return false;
9907 }
9908
9909 boolean this_present_family = true && this.isSetFamily();
9910 boolean that_present_family = true && that.isSetFamily();
9911 if (this_present_family || that_present_family) {
9912 if (!(this_present_family && that_present_family))
9913 return false;
9914 if (!this.family.equals(that.family))
9915 return false;
9916 }
9917
9918 boolean this_present_qualifier = true && this.isSetQualifier();
9919 boolean that_present_qualifier = true && that.isSetQualifier();
9920 if (this_present_qualifier || that_present_qualifier) {
9921 if (!(this_present_qualifier && that_present_qualifier))
9922 return false;
9923 if (!this.qualifier.equals(that.qualifier))
9924 return false;
9925 }
9926
9927 boolean this_present_value = true && this.isSetValue();
9928 boolean that_present_value = true && that.isSetValue();
9929 if (this_present_value || that_present_value) {
9930 if (!(this_present_value && that_present_value))
9931 return false;
9932 if (!this.value.equals(that.value))
9933 return false;
9934 }
9935
9936 boolean this_present_deleteSingle = true && this.isSetDeleteSingle();
9937 boolean that_present_deleteSingle = true && that.isSetDeleteSingle();
9938 if (this_present_deleteSingle || that_present_deleteSingle) {
9939 if (!(this_present_deleteSingle && that_present_deleteSingle))
9940 return false;
9941 if (!this.deleteSingle.equals(that.deleteSingle))
9942 return false;
9943 }
9944
9945 return true;
9946 }
9947
9948 @Override
9949 public int hashCode() {
9950 return 0;
9951 }
9952
9953 public int compareTo(checkAndDelete_args other) {
9954 if (!getClass().equals(other.getClass())) {
9955 return getClass().getName().compareTo(other.getClass().getName());
9956 }
9957
9958 int lastComparison = 0;
9959 checkAndDelete_args typedOther = (checkAndDelete_args)other;
9960
9961 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
9962 if (lastComparison != 0) {
9963 return lastComparison;
9964 }
9965 if (isSetTable()) {
9966 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
9967 if (lastComparison != 0) {
9968 return lastComparison;
9969 }
9970 }
9971 lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
9972 if (lastComparison != 0) {
9973 return lastComparison;
9974 }
9975 if (isSetRow()) {
9976 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
9977 if (lastComparison != 0) {
9978 return lastComparison;
9979 }
9980 }
9981 lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
9982 if (lastComparison != 0) {
9983 return lastComparison;
9984 }
9985 if (isSetFamily()) {
9986 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
9987 if (lastComparison != 0) {
9988 return lastComparison;
9989 }
9990 }
9991 lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
9992 if (lastComparison != 0) {
9993 return lastComparison;
9994 }
9995 if (isSetQualifier()) {
9996 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
9997 if (lastComparison != 0) {
9998 return lastComparison;
9999 }
10000 }
10001 lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
10002 if (lastComparison != 0) {
10003 return lastComparison;
10004 }
10005 if (isSetValue()) {
10006 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
10007 if (lastComparison != 0) {
10008 return lastComparison;
10009 }
10010 }
10011 lastComparison = Boolean.valueOf(isSetDeleteSingle()).compareTo(typedOther.isSetDeleteSingle());
10012 if (lastComparison != 0) {
10013 return lastComparison;
10014 }
10015 if (isSetDeleteSingle()) {
10016 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteSingle, typedOther.deleteSingle);
10017 if (lastComparison != 0) {
10018 return lastComparison;
10019 }
10020 }
10021 return 0;
10022 }
10023
10024 public _Fields fieldForId(int fieldId) {
10025 return _Fields.findByThriftId(fieldId);
10026 }
10027
10028 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
10029 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
10030 }
10031
10032 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
10033 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
10034 }
10035
10036 @Override
10037 public String toString() {
10038 StringBuilder sb = new StringBuilder("checkAndDelete_args(");
10039 boolean first = true;
10040
10041 sb.append("table:");
10042 if (this.table == null) {
10043 sb.append("null");
10044 } else {
10045 org.apache.thrift.TBaseHelper.toString(this.table, sb);
10046 }
10047 first = false;
10048 if (!first) sb.append(", ");
10049 sb.append("row:");
10050 if (this.row == null) {
10051 sb.append("null");
10052 } else {
10053 org.apache.thrift.TBaseHelper.toString(this.row, sb);
10054 }
10055 first = false;
10056 if (!first) sb.append(", ");
10057 sb.append("family:");
10058 if (this.family == null) {
10059 sb.append("null");
10060 } else {
10061 org.apache.thrift.TBaseHelper.toString(this.family, sb);
10062 }
10063 first = false;
10064 if (!first) sb.append(", ");
10065 sb.append("qualifier:");
10066 if (this.qualifier == null) {
10067 sb.append("null");
10068 } else {
10069 org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
10070 }
10071 first = false;
10072 if (!first) sb.append(", ");
10073 sb.append("value:");
10074 if (this.value == null) {
10075 sb.append("null");
10076 } else {
10077 org.apache.thrift.TBaseHelper.toString(this.value, sb);
10078 }
10079 first = false;
10080 if (!first) sb.append(", ");
10081 sb.append("deleteSingle:");
10082 if (this.deleteSingle == null) {
10083 sb.append("null");
10084 } else {
10085 sb.append(this.deleteSingle);
10086 }
10087 first = false;
10088 sb.append(")");
10089 return sb.toString();
10090 }
10091
10092 public void validate() throws org.apache.thrift.TException {
10093
10094 if (table == null) {
10095 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
10096 }
10097 if (row == null) {
10098 throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
10099 }
10100 if (family == null) {
10101 throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
10102 }
10103 if (qualifier == null) {
10104 throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
10105 }
10106 if (deleteSingle == null) {
10107 throw new org.apache.thrift.protocol.TProtocolException("Required field 'deleteSingle' was not present! Struct: " + toString());
10108 }
10109 }
10110
10111 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
10112 try {
10113 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
10114 } catch (org.apache.thrift.TException te) {
10115 throw new java.io.IOException(te);
10116 }
10117 }
10118
10119 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
10120 try {
10121 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
10122 } catch (org.apache.thrift.TException te) {
10123 throw new java.io.IOException(te);
10124 }
10125 }
10126
10127 private static class checkAndDelete_argsStandardSchemeFactory implements SchemeFactory {
10128 public checkAndDelete_argsStandardScheme getScheme() {
10129 return new checkAndDelete_argsStandardScheme();
10130 }
10131 }
10132
10133 private static class checkAndDelete_argsStandardScheme extends StandardScheme<checkAndDelete_args> {
10134
10135 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10136 org.apache.thrift.protocol.TField schemeField;
10137 iprot.readStructBegin();
10138 while (true)
10139 {
10140 schemeField = iprot.readFieldBegin();
10141 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
10142 break;
10143 }
10144 switch (schemeField.id) {
10145 case 1:
10146 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10147 struct.table = iprot.readBinary();
10148 struct.setTableIsSet(true);
10149 } else {
10150 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10151 }
10152 break;
10153 case 2:
10154 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10155 struct.row = iprot.readBinary();
10156 struct.setRowIsSet(true);
10157 } else {
10158 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10159 }
10160 break;
10161 case 3:
10162 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10163 struct.family = iprot.readBinary();
10164 struct.setFamilyIsSet(true);
10165 } else {
10166 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10167 }
10168 break;
10169 case 4:
10170 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10171 struct.qualifier = iprot.readBinary();
10172 struct.setQualifierIsSet(true);
10173 } else {
10174 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10175 }
10176 break;
10177 case 5:
10178 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
10179 struct.value = iprot.readBinary();
10180 struct.setValueIsSet(true);
10181 } else {
10182 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10183 }
10184 break;
10185 case 6:
10186 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
10187 struct.deleteSingle = new TDelete();
10188 struct.deleteSingle.read(iprot);
10189 struct.setDeleteSingleIsSet(true);
10190 } else {
10191 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10192 }
10193 break;
10194 default:
10195 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10196 }
10197 iprot.readFieldEnd();
10198 }
10199 iprot.readStructEnd();
10200
10201
10202 struct.validate();
10203 }
10204
10205 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10206 struct.validate();
10207
10208 oprot.writeStructBegin(STRUCT_DESC);
10209 if (struct.table != null) {
10210 oprot.writeFieldBegin(TABLE_FIELD_DESC);
10211 oprot.writeBinary(struct.table);
10212 oprot.writeFieldEnd();
10213 }
10214 if (struct.row != null) {
10215 oprot.writeFieldBegin(ROW_FIELD_DESC);
10216 oprot.writeBinary(struct.row);
10217 oprot.writeFieldEnd();
10218 }
10219 if (struct.family != null) {
10220 oprot.writeFieldBegin(FAMILY_FIELD_DESC);
10221 oprot.writeBinary(struct.family);
10222 oprot.writeFieldEnd();
10223 }
10224 if (struct.qualifier != null) {
10225 oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
10226 oprot.writeBinary(struct.qualifier);
10227 oprot.writeFieldEnd();
10228 }
10229 if (struct.value != null) {
10230 oprot.writeFieldBegin(VALUE_FIELD_DESC);
10231 oprot.writeBinary(struct.value);
10232 oprot.writeFieldEnd();
10233 }
10234 if (struct.deleteSingle != null) {
10235 oprot.writeFieldBegin(DELETE_SINGLE_FIELD_DESC);
10236 struct.deleteSingle.write(oprot);
10237 oprot.writeFieldEnd();
10238 }
10239 oprot.writeFieldStop();
10240 oprot.writeStructEnd();
10241 }
10242
10243 }
10244
10245 private static class checkAndDelete_argsTupleSchemeFactory implements SchemeFactory {
10246 public checkAndDelete_argsTupleScheme getScheme() {
10247 return new checkAndDelete_argsTupleScheme();
10248 }
10249 }
10250
10251 private static class checkAndDelete_argsTupleScheme extends TupleScheme<checkAndDelete_args> {
10252
10253 @Override
10254 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10255 TTupleProtocol oprot = (TTupleProtocol) prot;
10256 oprot.writeBinary(struct.table);
10257 oprot.writeBinary(struct.row);
10258 oprot.writeBinary(struct.family);
10259 oprot.writeBinary(struct.qualifier);
10260 struct.deleteSingle.write(oprot);
10261 BitSet optionals = new BitSet();
10262 if (struct.isSetValue()) {
10263 optionals.set(0);
10264 }
10265 oprot.writeBitSet(optionals, 1);
10266 if (struct.isSetValue()) {
10267 oprot.writeBinary(struct.value);
10268 }
10269 }
10270
10271 @Override
10272 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_args struct) throws org.apache.thrift.TException {
10273 TTupleProtocol iprot = (TTupleProtocol) prot;
10274 struct.table = iprot.readBinary();
10275 struct.setTableIsSet(true);
10276 struct.row = iprot.readBinary();
10277 struct.setRowIsSet(true);
10278 struct.family = iprot.readBinary();
10279 struct.setFamilyIsSet(true);
10280 struct.qualifier = iprot.readBinary();
10281 struct.setQualifierIsSet(true);
10282 struct.deleteSingle = new TDelete();
10283 struct.deleteSingle.read(iprot);
10284 struct.setDeleteSingleIsSet(true);
10285 BitSet incoming = iprot.readBitSet(1);
10286 if (incoming.get(0)) {
10287 struct.value = iprot.readBinary();
10288 struct.setValueIsSet(true);
10289 }
10290 }
10291 }
10292
10293 }
10294
10295 public static class checkAndDelete_result implements org.apache.thrift.TBase<checkAndDelete_result, checkAndDelete_result._Fields>, java.io.Serializable, Cloneable {
10296 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_result");
10297
10298 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);
10299 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);
10300
10301 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
10302 static {
10303 schemes.put(StandardScheme.class, new checkAndDelete_resultStandardSchemeFactory());
10304 schemes.put(TupleScheme.class, new checkAndDelete_resultTupleSchemeFactory());
10305 }
10306
10307 public boolean success;
10308 public TIOError io;
10309
10310
10311 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
10312 SUCCESS((short)0, "success"),
10313 IO((short)1, "io");
10314
10315 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10316
10317 static {
10318 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10319 byName.put(field.getFieldName(), field);
10320 }
10321 }
10322
10323
10324
10325
10326 public static _Fields findByThriftId(int fieldId) {
10327 switch(fieldId) {
10328 case 0:
10329 return SUCCESS;
10330 case 1:
10331 return IO;
10332 default:
10333 return null;
10334 }
10335 }
10336
10337
10338
10339
10340
10341 public static _Fields findByThriftIdOrThrow(int fieldId) {
10342 _Fields fields = findByThriftId(fieldId);
10343 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10344 return fields;
10345 }
10346
10347
10348
10349
10350 public static _Fields findByName(String name) {
10351 return byName.get(name);
10352 }
10353
10354 private final short _thriftId;
10355 private final String _fieldName;
10356
10357 _Fields(short thriftId, String fieldName) {
10358 _thriftId = thriftId;
10359 _fieldName = fieldName;
10360 }
10361
10362 public short getThriftFieldId() {
10363 return _thriftId;
10364 }
10365
10366 public String getFieldName() {
10367 return _fieldName;
10368 }
10369 }
10370
10371
10372 private static final int __SUCCESS_ISSET_ID = 0;
10373 private BitSet __isset_bit_vector = new BitSet(1);
10374 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
10375 static {
10376 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
10377 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
10378 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
10379 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
10380 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
10381 metaDataMap = Collections.unmodifiableMap(tmpMap);
10382 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_result.class, metaDataMap);
10383 }
10384
10385 public checkAndDelete_result() {
10386 }
10387
10388 public checkAndDelete_result(
10389 boolean success,
10390 TIOError io)
10391 {
10392 this();
10393 this.success = success;
10394 setSuccessIsSet(true);
10395 this.io = io;
10396 }
10397
10398
10399
10400
10401 public checkAndDelete_result(checkAndDelete_result other) {
10402 __isset_bit_vector.clear();
10403 __isset_bit_vector.or(other.__isset_bit_vector);
10404 this.success = other.success;
10405 if (other.isSetIo()) {
10406 this.io = new TIOError(other.io);
10407 }
10408 }
10409
10410 public checkAndDelete_result deepCopy() {
10411 return new checkAndDelete_result(this);
10412 }
10413
10414 @Override
10415 public void clear() {
10416 setSuccessIsSet(false);
10417 this.success = false;
10418 this.io = null;
10419 }
10420
10421 public boolean isSuccess() {
10422 return this.success;
10423 }
10424
10425 public checkAndDelete_result setSuccess(boolean success) {
10426 this.success = success;
10427 setSuccessIsSet(true);
10428 return this;
10429 }
10430
10431 public void unsetSuccess() {
10432 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
10433 }
10434
10435
10436 public boolean isSetSuccess() {
10437 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
10438 }
10439
10440 public void setSuccessIsSet(boolean value) {
10441 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
10442 }
10443
10444 public TIOError getIo() {
10445 return this.io;
10446 }
10447
10448 public checkAndDelete_result setIo(TIOError io) {
10449 this.io = io;
10450 return this;
10451 }
10452
10453 public void unsetIo() {
10454 this.io = null;
10455 }
10456
10457
10458 public boolean isSetIo() {
10459 return this.io != null;
10460 }
10461
10462 public void setIoIsSet(boolean value) {
10463 if (!value) {
10464 this.io = null;
10465 }
10466 }
10467
10468 public void setFieldValue(_Fields field, Object value) {
10469 switch (field) {
10470 case SUCCESS:
10471 if (value == null) {
10472 unsetSuccess();
10473 } else {
10474 setSuccess((Boolean)value);
10475 }
10476 break;
10477
10478 case IO:
10479 if (value == null) {
10480 unsetIo();
10481 } else {
10482 setIo((TIOError)value);
10483 }
10484 break;
10485
10486 }
10487 }
10488
10489 public Object getFieldValue(_Fields field) {
10490 switch (field) {
10491 case SUCCESS:
10492 return Boolean.valueOf(isSuccess());
10493
10494 case IO:
10495 return getIo();
10496
10497 }
10498 throw new IllegalStateException();
10499 }
10500
10501
10502 public boolean isSet(_Fields field) {
10503 if (field == null) {
10504 throw new IllegalArgumentException();
10505 }
10506
10507 switch (field) {
10508 case SUCCESS:
10509 return isSetSuccess();
10510 case IO:
10511 return isSetIo();
10512 }
10513 throw new IllegalStateException();
10514 }
10515
10516 @Override
10517 public boolean equals(Object that) {
10518 if (that == null)
10519 return false;
10520 if (that instanceof checkAndDelete_result)
10521 return this.equals((checkAndDelete_result)that);
10522 return false;
10523 }
10524
10525 public boolean equals(checkAndDelete_result that) {
10526 if (that == null)
10527 return false;
10528
10529 boolean this_present_success = true;
10530 boolean that_present_success = true;
10531 if (this_present_success || that_present_success) {
10532 if (!(this_present_success && that_present_success))
10533 return false;
10534 if (this.success != that.success)
10535 return false;
10536 }
10537
10538 boolean this_present_io = true && this.isSetIo();
10539 boolean that_present_io = true && that.isSetIo();
10540 if (this_present_io || that_present_io) {
10541 if (!(this_present_io && that_present_io))
10542 return false;
10543 if (!this.io.equals(that.io))
10544 return false;
10545 }
10546
10547 return true;
10548 }
10549
10550 @Override
10551 public int hashCode() {
10552 return 0;
10553 }
10554
10555 public int compareTo(checkAndDelete_result other) {
10556 if (!getClass().equals(other.getClass())) {
10557 return getClass().getName().compareTo(other.getClass().getName());
10558 }
10559
10560 int lastComparison = 0;
10561 checkAndDelete_result typedOther = (checkAndDelete_result)other;
10562
10563 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
10564 if (lastComparison != 0) {
10565 return lastComparison;
10566 }
10567 if (isSetSuccess()) {
10568 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
10569 if (lastComparison != 0) {
10570 return lastComparison;
10571 }
10572 }
10573 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
10574 if (lastComparison != 0) {
10575 return lastComparison;
10576 }
10577 if (isSetIo()) {
10578 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
10579 if (lastComparison != 0) {
10580 return lastComparison;
10581 }
10582 }
10583 return 0;
10584 }
10585
10586 public _Fields fieldForId(int fieldId) {
10587 return _Fields.findByThriftId(fieldId);
10588 }
10589
10590 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
10591 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
10592 }
10593
10594 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
10595 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
10596 }
10597
10598 @Override
10599 public String toString() {
10600 StringBuilder sb = new StringBuilder("checkAndDelete_result(");
10601 boolean first = true;
10602
10603 sb.append("success:");
10604 sb.append(this.success);
10605 first = false;
10606 if (!first) sb.append(", ");
10607 sb.append("io:");
10608 if (this.io == null) {
10609 sb.append("null");
10610 } else {
10611 sb.append(this.io);
10612 }
10613 first = false;
10614 sb.append(")");
10615 return sb.toString();
10616 }
10617
10618 public void validate() throws org.apache.thrift.TException {
10619
10620 }
10621
10622 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
10623 try {
10624 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
10625 } catch (org.apache.thrift.TException te) {
10626 throw new java.io.IOException(te);
10627 }
10628 }
10629
10630 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
10631 try {
10632 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
10633 } catch (org.apache.thrift.TException te) {
10634 throw new java.io.IOException(te);
10635 }
10636 }
10637
10638 private static class checkAndDelete_resultStandardSchemeFactory implements SchemeFactory {
10639 public checkAndDelete_resultStandardScheme getScheme() {
10640 return new checkAndDelete_resultStandardScheme();
10641 }
10642 }
10643
10644 private static class checkAndDelete_resultStandardScheme extends StandardScheme<checkAndDelete_result> {
10645
10646 public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10647 org.apache.thrift.protocol.TField schemeField;
10648 iprot.readStructBegin();
10649 while (true)
10650 {
10651 schemeField = iprot.readFieldBegin();
10652 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
10653 break;
10654 }
10655 switch (schemeField.id) {
10656 case 0:
10657 if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
10658 struct.success = iprot.readBool();
10659 struct.setSuccessIsSet(true);
10660 } else {
10661 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10662 }
10663 break;
10664 case 1:
10665 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
10666 struct.io = new TIOError();
10667 struct.io.read(iprot);
10668 struct.setIoIsSet(true);
10669 } else {
10670 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10671 }
10672 break;
10673 default:
10674 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
10675 }
10676 iprot.readFieldEnd();
10677 }
10678 iprot.readStructEnd();
10679
10680
10681 struct.validate();
10682 }
10683
10684 public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10685 struct.validate();
10686
10687 oprot.writeStructBegin(STRUCT_DESC);
10688 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
10689 oprot.writeBool(struct.success);
10690 oprot.writeFieldEnd();
10691 if (struct.io != null) {
10692 oprot.writeFieldBegin(IO_FIELD_DESC);
10693 struct.io.write(oprot);
10694 oprot.writeFieldEnd();
10695 }
10696 oprot.writeFieldStop();
10697 oprot.writeStructEnd();
10698 }
10699
10700 }
10701
10702 private static class checkAndDelete_resultTupleSchemeFactory implements SchemeFactory {
10703 public checkAndDelete_resultTupleScheme getScheme() {
10704 return new checkAndDelete_resultTupleScheme();
10705 }
10706 }
10707
10708 private static class checkAndDelete_resultTupleScheme extends TupleScheme<checkAndDelete_result> {
10709
10710 @Override
10711 public void write(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10712 TTupleProtocol oprot = (TTupleProtocol) prot;
10713 BitSet optionals = new BitSet();
10714 if (struct.isSetSuccess()) {
10715 optionals.set(0);
10716 }
10717 if (struct.isSetIo()) {
10718 optionals.set(1);
10719 }
10720 oprot.writeBitSet(optionals, 2);
10721 if (struct.isSetSuccess()) {
10722 oprot.writeBool(struct.success);
10723 }
10724 if (struct.isSetIo()) {
10725 struct.io.write(oprot);
10726 }
10727 }
10728
10729 @Override
10730 public void read(org.apache.thrift.protocol.TProtocol prot, checkAndDelete_result struct) throws org.apache.thrift.TException {
10731 TTupleProtocol iprot = (TTupleProtocol) prot;
10732 BitSet incoming = iprot.readBitSet(2);
10733 if (incoming.get(0)) {
10734 struct.success = iprot.readBool();
10735 struct.setSuccessIsSet(true);
10736 }
10737 if (incoming.get(1)) {
10738 struct.io = new TIOError();
10739 struct.io.read(iprot);
10740 struct.setIoIsSet(true);
10741 }
10742 }
10743 }
10744
10745 }
10746
10747 public static class increment_args implements org.apache.thrift.TBase<increment_args, increment_args._Fields>, java.io.Serializable, Cloneable {
10748 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_args");
10749
10750 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);
10751 private static final org.apache.thrift.protocol.TField INCREMENT_FIELD_DESC = new org.apache.thrift.protocol.TField("increment", org.apache.thrift.protocol.TType.STRUCT, (short)2);
10752
10753 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
10754 static {
10755 schemes.put(StandardScheme.class, new increment_argsStandardSchemeFactory());
10756 schemes.put(TupleScheme.class, new increment_argsTupleSchemeFactory());
10757 }
10758
10759
10760
10761
10762 public ByteBuffer table;
10763
10764
10765
10766 public TIncrement increment;
10767
10768
10769 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
10770
10771
10772
10773 TABLE((short)1, "table"),
10774
10775
10776
10777 INCREMENT((short)2, "increment");
10778
10779 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10780
10781 static {
10782 for (_Fields field : EnumSet.allOf(_Fields.class)) {
10783 byName.put(field.getFieldName(), field);
10784 }
10785 }
10786
10787
10788
10789
10790 public static _Fields findByThriftId(int fieldId) {
10791 switch(fieldId) {
10792 case 1:
10793 return TABLE;
10794 case 2:
10795 return INCREMENT;
10796 default:
10797 return null;
10798 }
10799 }
10800
10801
10802
10803
10804
10805 public static _Fields findByThriftIdOrThrow(int fieldId) {
10806 _Fields fields = findByThriftId(fieldId);
10807 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10808 return fields;
10809 }
10810
10811
10812
10813
10814 public static _Fields findByName(String name) {
10815 return byName.get(name);
10816 }
10817
10818 private final short _thriftId;
10819 private final String _fieldName;
10820
10821 _Fields(short thriftId, String fieldName) {
10822 _thriftId = thriftId;
10823 _fieldName = fieldName;
10824 }
10825
10826 public short getThriftFieldId() {
10827 return _thriftId;
10828 }
10829
10830 public String getFieldName() {
10831 return _fieldName;
10832 }
10833 }
10834
10835
10836 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
10837 static {
10838 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
10839 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
10840 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
10841 tmpMap.put(_Fields.INCREMENT, new org.apache.thrift.meta_data.FieldMetaData("increment", org.apache.thrift.TFieldRequirementType.REQUIRED,
10842 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIncrement.class)));
10843 metaDataMap = Collections.unmodifiableMap(tmpMap);
10844 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_args.class, metaDataMap);
10845 }
10846
10847 public increment_args() {
10848 }
10849
10850 public increment_args(
10851 ByteBuffer table,
10852 TIncrement increment)
10853 {
10854 this();
10855 this.table = table;
10856 this.increment = increment;
10857 }
10858
10859
10860
10861
10862 public increment_args(increment_args other) {
10863 if (other.isSetTable()) {
10864 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
10865 ;
10866 }
10867 if (other.isSetIncrement()) {
10868 this.increment = new TIncrement(other.increment);
10869 }
10870 }
10871
10872 public increment_args deepCopy() {
10873 return new increment_args(this);
10874 }
10875
10876 @Override
10877 public void clear() {
10878 this.table = null;
10879 this.increment = null;
10880 }
10881
10882
10883
10884
10885 public byte[] getTable() {
10886 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
10887 return table == null ? null : table.array();
10888 }
10889
10890 public ByteBuffer bufferForTable() {
10891 return table;
10892 }
10893
10894
10895
10896
10897 public increment_args setTable(byte[] table) {
10898 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
10899 return this;
10900 }
10901
10902 public increment_args setTable(ByteBuffer table) {
10903 this.table = table;
10904 return this;
10905 }
10906
10907 public void unsetTable() {
10908 this.table = null;
10909 }
10910
10911
10912 public boolean isSetTable() {
10913 return this.table != null;
10914 }
10915
10916 public void setTableIsSet(boolean value) {
10917 if (!value) {
10918 this.table = null;
10919 }
10920 }
10921
10922
10923
10924
10925 public TIncrement getIncrement() {
10926 return this.increment;
10927 }
10928
10929
10930
10931
10932 public increment_args setIncrement(TIncrement increment) {
10933 this.increment = increment;
10934 return this;
10935 }
10936
10937 public void unsetIncrement() {
10938 this.increment = null;
10939 }
10940
10941
10942 public boolean isSetIncrement() {
10943 return this.increment != null;
10944 }
10945
10946 public void setIncrementIsSet(boolean value) {
10947 if (!value) {
10948 this.increment = null;
10949 }
10950 }
10951
10952 public void setFieldValue(_Fields field, Object value) {
10953 switch (field) {
10954 case TABLE:
10955 if (value == null) {
10956 unsetTable();
10957 } else {
10958 setTable((ByteBuffer)value);
10959 }
10960 break;
10961
10962 case INCREMENT:
10963 if (value == null) {
10964 unsetIncrement();
10965 } else {
10966 setIncrement((TIncrement)value);
10967 }
10968 break;
10969
10970 }
10971 }
10972
10973 public Object getFieldValue(_Fields field) {
10974 switch (field) {
10975 case TABLE:
10976 return getTable();
10977
10978 case INCREMENT:
10979 return getIncrement();
10980
10981 }
10982 throw new IllegalStateException();
10983 }
10984
10985
10986 public boolean isSet(_Fields field) {
10987 if (field == null) {
10988 throw new IllegalArgumentException();
10989 }
10990
10991 switch (field) {
10992 case TABLE:
10993 return isSetTable();
10994 case INCREMENT:
10995 return isSetIncrement();
10996 }
10997 throw new IllegalStateException();
10998 }
10999
11000 @Override
11001 public boolean equals(Object that) {
11002 if (that == null)
11003 return false;
11004 if (that instanceof increment_args)
11005 return this.equals((increment_args)that);
11006 return false;
11007 }
11008
11009 public boolean equals(increment_args that) {
11010 if (that == null)
11011 return false;
11012
11013 boolean this_present_table = true && this.isSetTable();
11014 boolean that_present_table = true && that.isSetTable();
11015 if (this_present_table || that_present_table) {
11016 if (!(this_present_table && that_present_table))
11017 return false;
11018 if (!this.table.equals(that.table))
11019 return false;
11020 }
11021
11022 boolean this_present_increment = true && this.isSetIncrement();
11023 boolean that_present_increment = true && that.isSetIncrement();
11024 if (this_present_increment || that_present_increment) {
11025 if (!(this_present_increment && that_present_increment))
11026 return false;
11027 if (!this.increment.equals(that.increment))
11028 return false;
11029 }
11030
11031 return true;
11032 }
11033
11034 @Override
11035 public int hashCode() {
11036 return 0;
11037 }
11038
11039 public int compareTo(increment_args other) {
11040 if (!getClass().equals(other.getClass())) {
11041 return getClass().getName().compareTo(other.getClass().getName());
11042 }
11043
11044 int lastComparison = 0;
11045 increment_args typedOther = (increment_args)other;
11046
11047 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
11048 if (lastComparison != 0) {
11049 return lastComparison;
11050 }
11051 if (isSetTable()) {
11052 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
11053 if (lastComparison != 0) {
11054 return lastComparison;
11055 }
11056 }
11057 lastComparison = Boolean.valueOf(isSetIncrement()).compareTo(typedOther.isSetIncrement());
11058 if (lastComparison != 0) {
11059 return lastComparison;
11060 }
11061 if (isSetIncrement()) {
11062 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.increment, typedOther.increment);
11063 if (lastComparison != 0) {
11064 return lastComparison;
11065 }
11066 }
11067 return 0;
11068 }
11069
11070 public _Fields fieldForId(int fieldId) {
11071 return _Fields.findByThriftId(fieldId);
11072 }
11073
11074 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
11075 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
11076 }
11077
11078 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
11079 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
11080 }
11081
11082 @Override
11083 public String toString() {
11084 StringBuilder sb = new StringBuilder("increment_args(");
11085 boolean first = true;
11086
11087 sb.append("table:");
11088 if (this.table == null) {
11089 sb.append("null");
11090 } else {
11091 org.apache.thrift.TBaseHelper.toString(this.table, sb);
11092 }
11093 first = false;
11094 if (!first) sb.append(", ");
11095 sb.append("increment:");
11096 if (this.increment == null) {
11097 sb.append("null");
11098 } else {
11099 sb.append(this.increment);
11100 }
11101 first = false;
11102 sb.append(")");
11103 return sb.toString();
11104 }
11105
11106 public void validate() throws org.apache.thrift.TException {
11107
11108 if (table == null) {
11109 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
11110 }
11111 if (increment == null) {
11112 throw new org.apache.thrift.protocol.TProtocolException("Required field 'increment' was not present! Struct: " + toString());
11113 }
11114 }
11115
11116 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
11117 try {
11118 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
11119 } catch (org.apache.thrift.TException te) {
11120 throw new java.io.IOException(te);
11121 }
11122 }
11123
11124 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
11125 try {
11126 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
11127 } catch (org.apache.thrift.TException te) {
11128 throw new java.io.IOException(te);
11129 }
11130 }
11131
11132 private static class increment_argsStandardSchemeFactory implements SchemeFactory {
11133 public increment_argsStandardScheme getScheme() {
11134 return new increment_argsStandardScheme();
11135 }
11136 }
11137
11138 private static class increment_argsStandardScheme extends StandardScheme<increment_args> {
11139
11140 public void read(org.apache.thrift.protocol.TProtocol iprot, increment_args struct) throws org.apache.thrift.TException {
11141 org.apache.thrift.protocol.TField schemeField;
11142 iprot.readStructBegin();
11143 while (true)
11144 {
11145 schemeField = iprot.readFieldBegin();
11146 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
11147 break;
11148 }
11149 switch (schemeField.id) {
11150 case 1:
11151 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
11152 struct.table = iprot.readBinary();
11153 struct.setTableIsSet(true);
11154 } else {
11155 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11156 }
11157 break;
11158 case 2:
11159 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11160 struct.increment = new TIncrement();
11161 struct.increment.read(iprot);
11162 struct.setIncrementIsSet(true);
11163 } else {
11164 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11165 }
11166 break;
11167 default:
11168 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11169 }
11170 iprot.readFieldEnd();
11171 }
11172 iprot.readStructEnd();
11173
11174
11175 struct.validate();
11176 }
11177
11178 public void write(org.apache.thrift.protocol.TProtocol oprot, increment_args struct) throws org.apache.thrift.TException {
11179 struct.validate();
11180
11181 oprot.writeStructBegin(STRUCT_DESC);
11182 if (struct.table != null) {
11183 oprot.writeFieldBegin(TABLE_FIELD_DESC);
11184 oprot.writeBinary(struct.table);
11185 oprot.writeFieldEnd();
11186 }
11187 if (struct.increment != null) {
11188 oprot.writeFieldBegin(INCREMENT_FIELD_DESC);
11189 struct.increment.write(oprot);
11190 oprot.writeFieldEnd();
11191 }
11192 oprot.writeFieldStop();
11193 oprot.writeStructEnd();
11194 }
11195
11196 }
11197
11198 private static class increment_argsTupleSchemeFactory implements SchemeFactory {
11199 public increment_argsTupleScheme getScheme() {
11200 return new increment_argsTupleScheme();
11201 }
11202 }
11203
11204 private static class increment_argsTupleScheme extends TupleScheme<increment_args> {
11205
11206 @Override
11207 public void write(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
11208 TTupleProtocol oprot = (TTupleProtocol) prot;
11209 oprot.writeBinary(struct.table);
11210 struct.increment.write(oprot);
11211 }
11212
11213 @Override
11214 public void read(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException {
11215 TTupleProtocol iprot = (TTupleProtocol) prot;
11216 struct.table = iprot.readBinary();
11217 struct.setTableIsSet(true);
11218 struct.increment = new TIncrement();
11219 struct.increment.read(iprot);
11220 struct.setIncrementIsSet(true);
11221 }
11222 }
11223
11224 }
11225
11226 public static class increment_result implements org.apache.thrift.TBase<increment_result, increment_result._Fields>, java.io.Serializable, Cloneable {
11227 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("increment_result");
11228
11229 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);
11230 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);
11231
11232 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
11233 static {
11234 schemes.put(StandardScheme.class, new increment_resultStandardSchemeFactory());
11235 schemes.put(TupleScheme.class, new increment_resultTupleSchemeFactory());
11236 }
11237
11238 public TResult success;
11239 public TIOError io;
11240
11241
11242 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
11243 SUCCESS((short)0, "success"),
11244 IO((short)1, "io");
11245
11246 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11247
11248 static {
11249 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11250 byName.put(field.getFieldName(), field);
11251 }
11252 }
11253
11254
11255
11256
11257 public static _Fields findByThriftId(int fieldId) {
11258 switch(fieldId) {
11259 case 0:
11260 return SUCCESS;
11261 case 1:
11262 return IO;
11263 default:
11264 return null;
11265 }
11266 }
11267
11268
11269
11270
11271
11272 public static _Fields findByThriftIdOrThrow(int fieldId) {
11273 _Fields fields = findByThriftId(fieldId);
11274 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11275 return fields;
11276 }
11277
11278
11279
11280
11281 public static _Fields findByName(String name) {
11282 return byName.get(name);
11283 }
11284
11285 private final short _thriftId;
11286 private final String _fieldName;
11287
11288 _Fields(short thriftId, String fieldName) {
11289 _thriftId = thriftId;
11290 _fieldName = fieldName;
11291 }
11292
11293 public short getThriftFieldId() {
11294 return _thriftId;
11295 }
11296
11297 public String getFieldName() {
11298 return _fieldName;
11299 }
11300 }
11301
11302
11303 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
11304 static {
11305 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
11306 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
11307 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
11308 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
11309 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
11310 metaDataMap = Collections.unmodifiableMap(tmpMap);
11311 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(increment_result.class, metaDataMap);
11312 }
11313
11314 public increment_result() {
11315 }
11316
11317 public increment_result(
11318 TResult success,
11319 TIOError io)
11320 {
11321 this();
11322 this.success = success;
11323 this.io = io;
11324 }
11325
11326
11327
11328
11329 public increment_result(increment_result other) {
11330 if (other.isSetSuccess()) {
11331 this.success = new TResult(other.success);
11332 }
11333 if (other.isSetIo()) {
11334 this.io = new TIOError(other.io);
11335 }
11336 }
11337
11338 public increment_result deepCopy() {
11339 return new increment_result(this);
11340 }
11341
11342 @Override
11343 public void clear() {
11344 this.success = null;
11345 this.io = null;
11346 }
11347
11348 public TResult getSuccess() {
11349 return this.success;
11350 }
11351
11352 public increment_result setSuccess(TResult success) {
11353 this.success = success;
11354 return this;
11355 }
11356
11357 public void unsetSuccess() {
11358 this.success = null;
11359 }
11360
11361
11362 public boolean isSetSuccess() {
11363 return this.success != null;
11364 }
11365
11366 public void setSuccessIsSet(boolean value) {
11367 if (!value) {
11368 this.success = null;
11369 }
11370 }
11371
11372 public TIOError getIo() {
11373 return this.io;
11374 }
11375
11376 public increment_result setIo(TIOError io) {
11377 this.io = io;
11378 return this;
11379 }
11380
11381 public void unsetIo() {
11382 this.io = null;
11383 }
11384
11385
11386 public boolean isSetIo() {
11387 return this.io != null;
11388 }
11389
11390 public void setIoIsSet(boolean value) {
11391 if (!value) {
11392 this.io = null;
11393 }
11394 }
11395
11396 public void setFieldValue(_Fields field, Object value) {
11397 switch (field) {
11398 case SUCCESS:
11399 if (value == null) {
11400 unsetSuccess();
11401 } else {
11402 setSuccess((TResult)value);
11403 }
11404 break;
11405
11406 case IO:
11407 if (value == null) {
11408 unsetIo();
11409 } else {
11410 setIo((TIOError)value);
11411 }
11412 break;
11413
11414 }
11415 }
11416
11417 public Object getFieldValue(_Fields field) {
11418 switch (field) {
11419 case SUCCESS:
11420 return getSuccess();
11421
11422 case IO:
11423 return getIo();
11424
11425 }
11426 throw new IllegalStateException();
11427 }
11428
11429
11430 public boolean isSet(_Fields field) {
11431 if (field == null) {
11432 throw new IllegalArgumentException();
11433 }
11434
11435 switch (field) {
11436 case SUCCESS:
11437 return isSetSuccess();
11438 case IO:
11439 return isSetIo();
11440 }
11441 throw new IllegalStateException();
11442 }
11443
11444 @Override
11445 public boolean equals(Object that) {
11446 if (that == null)
11447 return false;
11448 if (that instanceof increment_result)
11449 return this.equals((increment_result)that);
11450 return false;
11451 }
11452
11453 public boolean equals(increment_result that) {
11454 if (that == null)
11455 return false;
11456
11457 boolean this_present_success = true && this.isSetSuccess();
11458 boolean that_present_success = true && that.isSetSuccess();
11459 if (this_present_success || that_present_success) {
11460 if (!(this_present_success && that_present_success))
11461 return false;
11462 if (!this.success.equals(that.success))
11463 return false;
11464 }
11465
11466 boolean this_present_io = true && this.isSetIo();
11467 boolean that_present_io = true && that.isSetIo();
11468 if (this_present_io || that_present_io) {
11469 if (!(this_present_io && that_present_io))
11470 return false;
11471 if (!this.io.equals(that.io))
11472 return false;
11473 }
11474
11475 return true;
11476 }
11477
11478 @Override
11479 public int hashCode() {
11480 return 0;
11481 }
11482
11483 public int compareTo(increment_result other) {
11484 if (!getClass().equals(other.getClass())) {
11485 return getClass().getName().compareTo(other.getClass().getName());
11486 }
11487
11488 int lastComparison = 0;
11489 increment_result typedOther = (increment_result)other;
11490
11491 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
11492 if (lastComparison != 0) {
11493 return lastComparison;
11494 }
11495 if (isSetSuccess()) {
11496 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
11497 if (lastComparison != 0) {
11498 return lastComparison;
11499 }
11500 }
11501 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
11502 if (lastComparison != 0) {
11503 return lastComparison;
11504 }
11505 if (isSetIo()) {
11506 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
11507 if (lastComparison != 0) {
11508 return lastComparison;
11509 }
11510 }
11511 return 0;
11512 }
11513
11514 public _Fields fieldForId(int fieldId) {
11515 return _Fields.findByThriftId(fieldId);
11516 }
11517
11518 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
11519 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
11520 }
11521
11522 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
11523 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
11524 }
11525
11526 @Override
11527 public String toString() {
11528 StringBuilder sb = new StringBuilder("increment_result(");
11529 boolean first = true;
11530
11531 sb.append("success:");
11532 if (this.success == null) {
11533 sb.append("null");
11534 } else {
11535 sb.append(this.success);
11536 }
11537 first = false;
11538 if (!first) sb.append(", ");
11539 sb.append("io:");
11540 if (this.io == null) {
11541 sb.append("null");
11542 } else {
11543 sb.append(this.io);
11544 }
11545 first = false;
11546 sb.append(")");
11547 return sb.toString();
11548 }
11549
11550 public void validate() throws org.apache.thrift.TException {
11551
11552 }
11553
11554 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
11555 try {
11556 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
11557 } catch (org.apache.thrift.TException te) {
11558 throw new java.io.IOException(te);
11559 }
11560 }
11561
11562 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
11563 try {
11564 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
11565 } catch (org.apache.thrift.TException te) {
11566 throw new java.io.IOException(te);
11567 }
11568 }
11569
11570 private static class increment_resultStandardSchemeFactory implements SchemeFactory {
11571 public increment_resultStandardScheme getScheme() {
11572 return new increment_resultStandardScheme();
11573 }
11574 }
11575
11576 private static class increment_resultStandardScheme extends StandardScheme<increment_result> {
11577
11578 public void read(org.apache.thrift.protocol.TProtocol iprot, increment_result struct) throws org.apache.thrift.TException {
11579 org.apache.thrift.protocol.TField schemeField;
11580 iprot.readStructBegin();
11581 while (true)
11582 {
11583 schemeField = iprot.readFieldBegin();
11584 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
11585 break;
11586 }
11587 switch (schemeField.id) {
11588 case 0:
11589 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11590 struct.success = new TResult();
11591 struct.success.read(iprot);
11592 struct.setSuccessIsSet(true);
11593 } else {
11594 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11595 }
11596 break;
11597 case 1:
11598 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
11599 struct.io = new TIOError();
11600 struct.io.read(iprot);
11601 struct.setIoIsSet(true);
11602 } else {
11603 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11604 }
11605 break;
11606 default:
11607 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
11608 }
11609 iprot.readFieldEnd();
11610 }
11611 iprot.readStructEnd();
11612
11613
11614 struct.validate();
11615 }
11616
11617 public void write(org.apache.thrift.protocol.TProtocol oprot, increment_result struct) throws org.apache.thrift.TException {
11618 struct.validate();
11619
11620 oprot.writeStructBegin(STRUCT_DESC);
11621 if (struct.success != null) {
11622 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11623 struct.success.write(oprot);
11624 oprot.writeFieldEnd();
11625 }
11626 if (struct.io != null) {
11627 oprot.writeFieldBegin(IO_FIELD_DESC);
11628 struct.io.write(oprot);
11629 oprot.writeFieldEnd();
11630 }
11631 oprot.writeFieldStop();
11632 oprot.writeStructEnd();
11633 }
11634
11635 }
11636
11637 private static class increment_resultTupleSchemeFactory implements SchemeFactory {
11638 public increment_resultTupleScheme getScheme() {
11639 return new increment_resultTupleScheme();
11640 }
11641 }
11642
11643 private static class increment_resultTupleScheme extends TupleScheme<increment_result> {
11644
11645 @Override
11646 public void write(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
11647 TTupleProtocol oprot = (TTupleProtocol) prot;
11648 BitSet optionals = new BitSet();
11649 if (struct.isSetSuccess()) {
11650 optionals.set(0);
11651 }
11652 if (struct.isSetIo()) {
11653 optionals.set(1);
11654 }
11655 oprot.writeBitSet(optionals, 2);
11656 if (struct.isSetSuccess()) {
11657 struct.success.write(oprot);
11658 }
11659 if (struct.isSetIo()) {
11660 struct.io.write(oprot);
11661 }
11662 }
11663
11664 @Override
11665 public void read(org.apache.thrift.protocol.TProtocol prot, increment_result struct) throws org.apache.thrift.TException {
11666 TTupleProtocol iprot = (TTupleProtocol) prot;
11667 BitSet incoming = iprot.readBitSet(2);
11668 if (incoming.get(0)) {
11669 struct.success = new TResult();
11670 struct.success.read(iprot);
11671 struct.setSuccessIsSet(true);
11672 }
11673 if (incoming.get(1)) {
11674 struct.io = new TIOError();
11675 struct.io.read(iprot);
11676 struct.setIoIsSet(true);
11677 }
11678 }
11679 }
11680
11681 }
11682
11683 public static class openScanner_args implements org.apache.thrift.TBase<openScanner_args, openScanner_args._Fields>, java.io.Serializable, Cloneable {
11684 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_args");
11685
11686 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);
11687 private static final org.apache.thrift.protocol.TField SCAN_FIELD_DESC = new org.apache.thrift.protocol.TField("scan", org.apache.thrift.protocol.TType.STRUCT, (short)2);
11688
11689 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
11690 static {
11691 schemes.put(StandardScheme.class, new openScanner_argsStandardSchemeFactory());
11692 schemes.put(TupleScheme.class, new openScanner_argsTupleSchemeFactory());
11693 }
11694
11695
11696
11697
11698 public ByteBuffer table;
11699
11700
11701
11702 public TScan scan;
11703
11704
11705 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
11706
11707
11708
11709 TABLE((short)1, "table"),
11710
11711
11712
11713 SCAN((short)2, "scan");
11714
11715 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11716
11717 static {
11718 for (_Fields field : EnumSet.allOf(_Fields.class)) {
11719 byName.put(field.getFieldName(), field);
11720 }
11721 }
11722
11723
11724
11725
11726 public static _Fields findByThriftId(int fieldId) {
11727 switch(fieldId) {
11728 case 1:
11729 return TABLE;
11730 case 2:
11731 return SCAN;
11732 default:
11733 return null;
11734 }
11735 }
11736
11737
11738
11739
11740
11741 public static _Fields findByThriftIdOrThrow(int fieldId) {
11742 _Fields fields = findByThriftId(fieldId);
11743 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11744 return fields;
11745 }
11746
11747
11748
11749
11750 public static _Fields findByName(String name) {
11751 return byName.get(name);
11752 }
11753
11754 private final short _thriftId;
11755 private final String _fieldName;
11756
11757 _Fields(short thriftId, String fieldName) {
11758 _thriftId = thriftId;
11759 _fieldName = fieldName;
11760 }
11761
11762 public short getThriftFieldId() {
11763 return _thriftId;
11764 }
11765
11766 public String getFieldName() {
11767 return _fieldName;
11768 }
11769 }
11770
11771
11772 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
11773 static {
11774 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
11775 tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED,
11776 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
11777 tmpMap.put(_Fields.SCAN, new org.apache.thrift.meta_data.FieldMetaData("scan", org.apache.thrift.TFieldRequirementType.REQUIRED,
11778 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TScan.class)));
11779 metaDataMap = Collections.unmodifiableMap(tmpMap);
11780 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_args.class, metaDataMap);
11781 }
11782
11783 public openScanner_args() {
11784 }
11785
11786 public openScanner_args(
11787 ByteBuffer table,
11788 TScan scan)
11789 {
11790 this();
11791 this.table = table;
11792 this.scan = scan;
11793 }
11794
11795
11796
11797
11798 public openScanner_args(openScanner_args other) {
11799 if (other.isSetTable()) {
11800 this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
11801 ;
11802 }
11803 if (other.isSetScan()) {
11804 this.scan = new TScan(other.scan);
11805 }
11806 }
11807
11808 public openScanner_args deepCopy() {
11809 return new openScanner_args(this);
11810 }
11811
11812 @Override
11813 public void clear() {
11814 this.table = null;
11815 this.scan = null;
11816 }
11817
11818
11819
11820
11821 public byte[] getTable() {
11822 setTable(org.apache.thrift.TBaseHelper.rightSize(table));
11823 return table == null ? null : table.array();
11824 }
11825
11826 public ByteBuffer bufferForTable() {
11827 return table;
11828 }
11829
11830
11831
11832
11833 public openScanner_args setTable(byte[] table) {
11834 setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
11835 return this;
11836 }
11837
11838 public openScanner_args setTable(ByteBuffer table) {
11839 this.table = table;
11840 return this;
11841 }
11842
11843 public void unsetTable() {
11844 this.table = null;
11845 }
11846
11847
11848 public boolean isSetTable() {
11849 return this.table != null;
11850 }
11851
11852 public void setTableIsSet(boolean value) {
11853 if (!value) {
11854 this.table = null;
11855 }
11856 }
11857
11858
11859
11860
11861 public TScan getScan() {
11862 return this.scan;
11863 }
11864
11865
11866
11867
11868 public openScanner_args setScan(TScan scan) {
11869 this.scan = scan;
11870 return this;
11871 }
11872
11873 public void unsetScan() {
11874 this.scan = null;
11875 }
11876
11877
11878 public boolean isSetScan() {
11879 return this.scan != null;
11880 }
11881
11882 public void setScanIsSet(boolean value) {
11883 if (!value) {
11884 this.scan = null;
11885 }
11886 }
11887
11888 public void setFieldValue(_Fields field, Object value) {
11889 switch (field) {
11890 case TABLE:
11891 if (value == null) {
11892 unsetTable();
11893 } else {
11894 setTable((ByteBuffer)value);
11895 }
11896 break;
11897
11898 case SCAN:
11899 if (value == null) {
11900 unsetScan();
11901 } else {
11902 setScan((TScan)value);
11903 }
11904 break;
11905
11906 }
11907 }
11908
11909 public Object getFieldValue(_Fields field) {
11910 switch (field) {
11911 case TABLE:
11912 return getTable();
11913
11914 case SCAN:
11915 return getScan();
11916
11917 }
11918 throw new IllegalStateException();
11919 }
11920
11921
11922 public boolean isSet(_Fields field) {
11923 if (field == null) {
11924 throw new IllegalArgumentException();
11925 }
11926
11927 switch (field) {
11928 case TABLE:
11929 return isSetTable();
11930 case SCAN:
11931 return isSetScan();
11932 }
11933 throw new IllegalStateException();
11934 }
11935
11936 @Override
11937 public boolean equals(Object that) {
11938 if (that == null)
11939 return false;
11940 if (that instanceof openScanner_args)
11941 return this.equals((openScanner_args)that);
11942 return false;
11943 }
11944
11945 public boolean equals(openScanner_args that) {
11946 if (that == null)
11947 return false;
11948
11949 boolean this_present_table = true && this.isSetTable();
11950 boolean that_present_table = true && that.isSetTable();
11951 if (this_present_table || that_present_table) {
11952 if (!(this_present_table && that_present_table))
11953 return false;
11954 if (!this.table.equals(that.table))
11955 return false;
11956 }
11957
11958 boolean this_present_scan = true && this.isSetScan();
11959 boolean that_present_scan = true && that.isSetScan();
11960 if (this_present_scan || that_present_scan) {
11961 if (!(this_present_scan && that_present_scan))
11962 return false;
11963 if (!this.scan.equals(that.scan))
11964 return false;
11965 }
11966
11967 return true;
11968 }
11969
11970 @Override
11971 public int hashCode() {
11972 return 0;
11973 }
11974
11975 public int compareTo(openScanner_args other) {
11976 if (!getClass().equals(other.getClass())) {
11977 return getClass().getName().compareTo(other.getClass().getName());
11978 }
11979
11980 int lastComparison = 0;
11981 openScanner_args typedOther = (openScanner_args)other;
11982
11983 lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
11984 if (lastComparison != 0) {
11985 return lastComparison;
11986 }
11987 if (isSetTable()) {
11988 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
11989 if (lastComparison != 0) {
11990 return lastComparison;
11991 }
11992 }
11993 lastComparison = Boolean.valueOf(isSetScan()).compareTo(typedOther.isSetScan());
11994 if (lastComparison != 0) {
11995 return lastComparison;
11996 }
11997 if (isSetScan()) {
11998 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scan, typedOther.scan);
11999 if (lastComparison != 0) {
12000 return lastComparison;
12001 }
12002 }
12003 return 0;
12004 }
12005
12006 public _Fields fieldForId(int fieldId) {
12007 return _Fields.findByThriftId(fieldId);
12008 }
12009
12010 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
12011 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
12012 }
12013
12014 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
12015 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
12016 }
12017
12018 @Override
12019 public String toString() {
12020 StringBuilder sb = new StringBuilder("openScanner_args(");
12021 boolean first = true;
12022
12023 sb.append("table:");
12024 if (this.table == null) {
12025 sb.append("null");
12026 } else {
12027 org.apache.thrift.TBaseHelper.toString(this.table, sb);
12028 }
12029 first = false;
12030 if (!first) sb.append(", ");
12031 sb.append("scan:");
12032 if (this.scan == null) {
12033 sb.append("null");
12034 } else {
12035 sb.append(this.scan);
12036 }
12037 first = false;
12038 sb.append(")");
12039 return sb.toString();
12040 }
12041
12042 public void validate() throws org.apache.thrift.TException {
12043
12044 if (table == null) {
12045 throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
12046 }
12047 if (scan == null) {
12048 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scan' was not present! Struct: " + toString());
12049 }
12050 }
12051
12052 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12053 try {
12054 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12055 } catch (org.apache.thrift.TException te) {
12056 throw new java.io.IOException(te);
12057 }
12058 }
12059
12060 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12061 try {
12062 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12063 } catch (org.apache.thrift.TException te) {
12064 throw new java.io.IOException(te);
12065 }
12066 }
12067
12068 private static class openScanner_argsStandardSchemeFactory implements SchemeFactory {
12069 public openScanner_argsStandardScheme getScheme() {
12070 return new openScanner_argsStandardScheme();
12071 }
12072 }
12073
12074 private static class openScanner_argsStandardScheme extends StandardScheme<openScanner_args> {
12075
12076 public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_args struct) throws org.apache.thrift.TException {
12077 org.apache.thrift.protocol.TField schemeField;
12078 iprot.readStructBegin();
12079 while (true)
12080 {
12081 schemeField = iprot.readFieldBegin();
12082 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
12083 break;
12084 }
12085 switch (schemeField.id) {
12086 case 1:
12087 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
12088 struct.table = iprot.readBinary();
12089 struct.setTableIsSet(true);
12090 } else {
12091 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12092 }
12093 break;
12094 case 2:
12095 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
12096 struct.scan = new TScan();
12097 struct.scan.read(iprot);
12098 struct.setScanIsSet(true);
12099 } else {
12100 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12101 }
12102 break;
12103 default:
12104 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12105 }
12106 iprot.readFieldEnd();
12107 }
12108 iprot.readStructEnd();
12109
12110
12111 struct.validate();
12112 }
12113
12114 public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_args struct) throws org.apache.thrift.TException {
12115 struct.validate();
12116
12117 oprot.writeStructBegin(STRUCT_DESC);
12118 if (struct.table != null) {
12119 oprot.writeFieldBegin(TABLE_FIELD_DESC);
12120 oprot.writeBinary(struct.table);
12121 oprot.writeFieldEnd();
12122 }
12123 if (struct.scan != null) {
12124 oprot.writeFieldBegin(SCAN_FIELD_DESC);
12125 struct.scan.write(oprot);
12126 oprot.writeFieldEnd();
12127 }
12128 oprot.writeFieldStop();
12129 oprot.writeStructEnd();
12130 }
12131
12132 }
12133
12134 private static class openScanner_argsTupleSchemeFactory implements SchemeFactory {
12135 public openScanner_argsTupleScheme getScheme() {
12136 return new openScanner_argsTupleScheme();
12137 }
12138 }
12139
12140 private static class openScanner_argsTupleScheme extends TupleScheme<openScanner_args> {
12141
12142 @Override
12143 public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
12144 TTupleProtocol oprot = (TTupleProtocol) prot;
12145 oprot.writeBinary(struct.table);
12146 struct.scan.write(oprot);
12147 }
12148
12149 @Override
12150 public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_args struct) throws org.apache.thrift.TException {
12151 TTupleProtocol iprot = (TTupleProtocol) prot;
12152 struct.table = iprot.readBinary();
12153 struct.setTableIsSet(true);
12154 struct.scan = new TScan();
12155 struct.scan.read(iprot);
12156 struct.setScanIsSet(true);
12157 }
12158 }
12159
12160 }
12161
12162 public static class openScanner_result implements org.apache.thrift.TBase<openScanner_result, openScanner_result._Fields>, java.io.Serializable, Cloneable {
12163 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("openScanner_result");
12164
12165 private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (short)0);
12166 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);
12167
12168 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
12169 static {
12170 schemes.put(StandardScheme.class, new openScanner_resultStandardSchemeFactory());
12171 schemes.put(TupleScheme.class, new openScanner_resultTupleSchemeFactory());
12172 }
12173
12174 public int success;
12175 public TIOError io;
12176
12177
12178 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
12179 SUCCESS((short)0, "success"),
12180 IO((short)1, "io");
12181
12182 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12183
12184 static {
12185 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12186 byName.put(field.getFieldName(), field);
12187 }
12188 }
12189
12190
12191
12192
12193 public static _Fields findByThriftId(int fieldId) {
12194 switch(fieldId) {
12195 case 0:
12196 return SUCCESS;
12197 case 1:
12198 return IO;
12199 default:
12200 return null;
12201 }
12202 }
12203
12204
12205
12206
12207
12208 public static _Fields findByThriftIdOrThrow(int fieldId) {
12209 _Fields fields = findByThriftId(fieldId);
12210 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12211 return fields;
12212 }
12213
12214
12215
12216
12217 public static _Fields findByName(String name) {
12218 return byName.get(name);
12219 }
12220
12221 private final short _thriftId;
12222 private final String _fieldName;
12223
12224 _Fields(short thriftId, String fieldName) {
12225 _thriftId = thriftId;
12226 _fieldName = fieldName;
12227 }
12228
12229 public short getThriftFieldId() {
12230 return _thriftId;
12231 }
12232
12233 public String getFieldName() {
12234 return _fieldName;
12235 }
12236 }
12237
12238
12239 private static final int __SUCCESS_ISSET_ID = 0;
12240 private BitSet __isset_bit_vector = new BitSet(1);
12241 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
12242 static {
12243 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
12244 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
12245 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12246 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
12247 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
12248 metaDataMap = Collections.unmodifiableMap(tmpMap);
12249 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(openScanner_result.class, metaDataMap);
12250 }
12251
12252 public openScanner_result() {
12253 }
12254
12255 public openScanner_result(
12256 int success,
12257 TIOError io)
12258 {
12259 this();
12260 this.success = success;
12261 setSuccessIsSet(true);
12262 this.io = io;
12263 }
12264
12265
12266
12267
12268 public openScanner_result(openScanner_result other) {
12269 __isset_bit_vector.clear();
12270 __isset_bit_vector.or(other.__isset_bit_vector);
12271 this.success = other.success;
12272 if (other.isSetIo()) {
12273 this.io = new TIOError(other.io);
12274 }
12275 }
12276
12277 public openScanner_result deepCopy() {
12278 return new openScanner_result(this);
12279 }
12280
12281 @Override
12282 public void clear() {
12283 setSuccessIsSet(false);
12284 this.success = 0;
12285 this.io = null;
12286 }
12287
12288 public int getSuccess() {
12289 return this.success;
12290 }
12291
12292 public openScanner_result setSuccess(int success) {
12293 this.success = success;
12294 setSuccessIsSet(true);
12295 return this;
12296 }
12297
12298 public void unsetSuccess() {
12299 __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
12300 }
12301
12302
12303 public boolean isSetSuccess() {
12304 return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
12305 }
12306
12307 public void setSuccessIsSet(boolean value) {
12308 __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
12309 }
12310
12311 public TIOError getIo() {
12312 return this.io;
12313 }
12314
12315 public openScanner_result setIo(TIOError io) {
12316 this.io = io;
12317 return this;
12318 }
12319
12320 public void unsetIo() {
12321 this.io = null;
12322 }
12323
12324
12325 public boolean isSetIo() {
12326 return this.io != null;
12327 }
12328
12329 public void setIoIsSet(boolean value) {
12330 if (!value) {
12331 this.io = null;
12332 }
12333 }
12334
12335 public void setFieldValue(_Fields field, Object value) {
12336 switch (field) {
12337 case SUCCESS:
12338 if (value == null) {
12339 unsetSuccess();
12340 } else {
12341 setSuccess((Integer)value);
12342 }
12343 break;
12344
12345 case IO:
12346 if (value == null) {
12347 unsetIo();
12348 } else {
12349 setIo((TIOError)value);
12350 }
12351 break;
12352
12353 }
12354 }
12355
12356 public Object getFieldValue(_Fields field) {
12357 switch (field) {
12358 case SUCCESS:
12359 return Integer.valueOf(getSuccess());
12360
12361 case IO:
12362 return getIo();
12363
12364 }
12365 throw new IllegalStateException();
12366 }
12367
12368
12369 public boolean isSet(_Fields field) {
12370 if (field == null) {
12371 throw new IllegalArgumentException();
12372 }
12373
12374 switch (field) {
12375 case SUCCESS:
12376 return isSetSuccess();
12377 case IO:
12378 return isSetIo();
12379 }
12380 throw new IllegalStateException();
12381 }
12382
12383 @Override
12384 public boolean equals(Object that) {
12385 if (that == null)
12386 return false;
12387 if (that instanceof openScanner_result)
12388 return this.equals((openScanner_result)that);
12389 return false;
12390 }
12391
12392 public boolean equals(openScanner_result that) {
12393 if (that == null)
12394 return false;
12395
12396 boolean this_present_success = true;
12397 boolean that_present_success = true;
12398 if (this_present_success || that_present_success) {
12399 if (!(this_present_success && that_present_success))
12400 return false;
12401 if (this.success != that.success)
12402 return false;
12403 }
12404
12405 boolean this_present_io = true && this.isSetIo();
12406 boolean that_present_io = true && that.isSetIo();
12407 if (this_present_io || that_present_io) {
12408 if (!(this_present_io && that_present_io))
12409 return false;
12410 if (!this.io.equals(that.io))
12411 return false;
12412 }
12413
12414 return true;
12415 }
12416
12417 @Override
12418 public int hashCode() {
12419 return 0;
12420 }
12421
12422 public int compareTo(openScanner_result other) {
12423 if (!getClass().equals(other.getClass())) {
12424 return getClass().getName().compareTo(other.getClass().getName());
12425 }
12426
12427 int lastComparison = 0;
12428 openScanner_result typedOther = (openScanner_result)other;
12429
12430 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
12431 if (lastComparison != 0) {
12432 return lastComparison;
12433 }
12434 if (isSetSuccess()) {
12435 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
12436 if (lastComparison != 0) {
12437 return lastComparison;
12438 }
12439 }
12440 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
12441 if (lastComparison != 0) {
12442 return lastComparison;
12443 }
12444 if (isSetIo()) {
12445 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
12446 if (lastComparison != 0) {
12447 return lastComparison;
12448 }
12449 }
12450 return 0;
12451 }
12452
12453 public _Fields fieldForId(int fieldId) {
12454 return _Fields.findByThriftId(fieldId);
12455 }
12456
12457 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
12458 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
12459 }
12460
12461 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
12462 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
12463 }
12464
12465 @Override
12466 public String toString() {
12467 StringBuilder sb = new StringBuilder("openScanner_result(");
12468 boolean first = true;
12469
12470 sb.append("success:");
12471 sb.append(this.success);
12472 first = false;
12473 if (!first) sb.append(", ");
12474 sb.append("io:");
12475 if (this.io == null) {
12476 sb.append("null");
12477 } else {
12478 sb.append(this.io);
12479 }
12480 first = false;
12481 sb.append(")");
12482 return sb.toString();
12483 }
12484
12485 public void validate() throws org.apache.thrift.TException {
12486
12487 }
12488
12489 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12490 try {
12491 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12492 } catch (org.apache.thrift.TException te) {
12493 throw new java.io.IOException(te);
12494 }
12495 }
12496
12497 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12498 try {
12499 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12500 } catch (org.apache.thrift.TException te) {
12501 throw new java.io.IOException(te);
12502 }
12503 }
12504
12505 private static class openScanner_resultStandardSchemeFactory implements SchemeFactory {
12506 public openScanner_resultStandardScheme getScheme() {
12507 return new openScanner_resultStandardScheme();
12508 }
12509 }
12510
12511 private static class openScanner_resultStandardScheme extends StandardScheme<openScanner_result> {
12512
12513 public void read(org.apache.thrift.protocol.TProtocol iprot, openScanner_result struct) throws org.apache.thrift.TException {
12514 org.apache.thrift.protocol.TField schemeField;
12515 iprot.readStructBegin();
12516 while (true)
12517 {
12518 schemeField = iprot.readFieldBegin();
12519 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
12520 break;
12521 }
12522 switch (schemeField.id) {
12523 case 0:
12524 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
12525 struct.success = iprot.readI32();
12526 struct.setSuccessIsSet(true);
12527 } else {
12528 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12529 }
12530 break;
12531 case 1:
12532 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
12533 struct.io = new TIOError();
12534 struct.io.read(iprot);
12535 struct.setIoIsSet(true);
12536 } else {
12537 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12538 }
12539 break;
12540 default:
12541 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
12542 }
12543 iprot.readFieldEnd();
12544 }
12545 iprot.readStructEnd();
12546
12547
12548 struct.validate();
12549 }
12550
12551 public void write(org.apache.thrift.protocol.TProtocol oprot, openScanner_result struct) throws org.apache.thrift.TException {
12552 struct.validate();
12553
12554 oprot.writeStructBegin(STRUCT_DESC);
12555 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12556 oprot.writeI32(struct.success);
12557 oprot.writeFieldEnd();
12558 if (struct.io != null) {
12559 oprot.writeFieldBegin(IO_FIELD_DESC);
12560 struct.io.write(oprot);
12561 oprot.writeFieldEnd();
12562 }
12563 oprot.writeFieldStop();
12564 oprot.writeStructEnd();
12565 }
12566
12567 }
12568
12569 private static class openScanner_resultTupleSchemeFactory implements SchemeFactory {
12570 public openScanner_resultTupleScheme getScheme() {
12571 return new openScanner_resultTupleScheme();
12572 }
12573 }
12574
12575 private static class openScanner_resultTupleScheme extends TupleScheme<openScanner_result> {
12576
12577 @Override
12578 public void write(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
12579 TTupleProtocol oprot = (TTupleProtocol) prot;
12580 BitSet optionals = new BitSet();
12581 if (struct.isSetSuccess()) {
12582 optionals.set(0);
12583 }
12584 if (struct.isSetIo()) {
12585 optionals.set(1);
12586 }
12587 oprot.writeBitSet(optionals, 2);
12588 if (struct.isSetSuccess()) {
12589 oprot.writeI32(struct.success);
12590 }
12591 if (struct.isSetIo()) {
12592 struct.io.write(oprot);
12593 }
12594 }
12595
12596 @Override
12597 public void read(org.apache.thrift.protocol.TProtocol prot, openScanner_result struct) throws org.apache.thrift.TException {
12598 TTupleProtocol iprot = (TTupleProtocol) prot;
12599 BitSet incoming = iprot.readBitSet(2);
12600 if (incoming.get(0)) {
12601 struct.success = iprot.readI32();
12602 struct.setSuccessIsSet(true);
12603 }
12604 if (incoming.get(1)) {
12605 struct.io = new TIOError();
12606 struct.io.read(iprot);
12607 struct.setIoIsSet(true);
12608 }
12609 }
12610 }
12611
12612 }
12613
12614 public static class getScannerRows_args implements org.apache.thrift.TBase<getScannerRows_args, getScannerRows_args._Fields>, java.io.Serializable, Cloneable {
12615 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_args");
12616
12617 private static final org.apache.thrift.protocol.TField SCANNER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scannerId", org.apache.thrift.protocol.TType.I32, (short)1);
12618 private static final org.apache.thrift.protocol.TField NUM_ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("numRows", org.apache.thrift.protocol.TType.I32, (short)2);
12619
12620 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
12621 static {
12622 schemes.put(StandardScheme.class, new getScannerRows_argsStandardSchemeFactory());
12623 schemes.put(TupleScheme.class, new getScannerRows_argsTupleSchemeFactory());
12624 }
12625
12626
12627
12628
12629 public int scannerId;
12630
12631
12632
12633 public int numRows;
12634
12635
12636 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
12637
12638
12639
12640 SCANNER_ID((short)1, "scannerId"),
12641
12642
12643
12644 NUM_ROWS((short)2, "numRows");
12645
12646 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12647
12648 static {
12649 for (_Fields field : EnumSet.allOf(_Fields.class)) {
12650 byName.put(field.getFieldName(), field);
12651 }
12652 }
12653
12654
12655
12656
12657 public static _Fields findByThriftId(int fieldId) {
12658 switch(fieldId) {
12659 case 1:
12660 return SCANNER_ID;
12661 case 2:
12662 return NUM_ROWS;
12663 default:
12664 return null;
12665 }
12666 }
12667
12668
12669
12670
12671
12672 public static _Fields findByThriftIdOrThrow(int fieldId) {
12673 _Fields fields = findByThriftId(fieldId);
12674 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12675 return fields;
12676 }
12677
12678
12679
12680
12681 public static _Fields findByName(String name) {
12682 return byName.get(name);
12683 }
12684
12685 private final short _thriftId;
12686 private final String _fieldName;
12687
12688 _Fields(short thriftId, String fieldName) {
12689 _thriftId = thriftId;
12690 _fieldName = fieldName;
12691 }
12692
12693 public short getThriftFieldId() {
12694 return _thriftId;
12695 }
12696
12697 public String getFieldName() {
12698 return _fieldName;
12699 }
12700 }
12701
12702
12703 private static final int __SCANNERID_ISSET_ID = 0;
12704 private static final int __NUMROWS_ISSET_ID = 1;
12705 private BitSet __isset_bit_vector = new BitSet(2);
12706 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
12707 static {
12708 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
12709 tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
12710 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12711 tmpMap.put(_Fields.NUM_ROWS, new org.apache.thrift.meta_data.FieldMetaData("numRows", org.apache.thrift.TFieldRequirementType.DEFAULT,
12712 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
12713 metaDataMap = Collections.unmodifiableMap(tmpMap);
12714 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_args.class, metaDataMap);
12715 }
12716
12717 public getScannerRows_args() {
12718 this.numRows = 1;
12719
12720 }
12721
12722 public getScannerRows_args(
12723 int scannerId,
12724 int numRows)
12725 {
12726 this();
12727 this.scannerId = scannerId;
12728 setScannerIdIsSet(true);
12729 this.numRows = numRows;
12730 setNumRowsIsSet(true);
12731 }
12732
12733
12734
12735
12736 public getScannerRows_args(getScannerRows_args other) {
12737 __isset_bit_vector.clear();
12738 __isset_bit_vector.or(other.__isset_bit_vector);
12739 this.scannerId = other.scannerId;
12740 this.numRows = other.numRows;
12741 }
12742
12743 public getScannerRows_args deepCopy() {
12744 return new getScannerRows_args(this);
12745 }
12746
12747 @Override
12748 public void clear() {
12749 setScannerIdIsSet(false);
12750 this.scannerId = 0;
12751 this.numRows = 1;
12752
12753 }
12754
12755
12756
12757
12758 public int getScannerId() {
12759 return this.scannerId;
12760 }
12761
12762
12763
12764
12765 public getScannerRows_args setScannerId(int scannerId) {
12766 this.scannerId = scannerId;
12767 setScannerIdIsSet(true);
12768 return this;
12769 }
12770
12771 public void unsetScannerId() {
12772 __isset_bit_vector.clear(__SCANNERID_ISSET_ID);
12773 }
12774
12775
12776 public boolean isSetScannerId() {
12777 return __isset_bit_vector.get(__SCANNERID_ISSET_ID);
12778 }
12779
12780 public void setScannerIdIsSet(boolean value) {
12781 __isset_bit_vector.set(__SCANNERID_ISSET_ID, value);
12782 }
12783
12784
12785
12786
12787 public int getNumRows() {
12788 return this.numRows;
12789 }
12790
12791
12792
12793
12794 public getScannerRows_args setNumRows(int numRows) {
12795 this.numRows = numRows;
12796 setNumRowsIsSet(true);
12797 return this;
12798 }
12799
12800 public void unsetNumRows() {
12801 __isset_bit_vector.clear(__NUMROWS_ISSET_ID);
12802 }
12803
12804
12805 public boolean isSetNumRows() {
12806 return __isset_bit_vector.get(__NUMROWS_ISSET_ID);
12807 }
12808
12809 public void setNumRowsIsSet(boolean value) {
12810 __isset_bit_vector.set(__NUMROWS_ISSET_ID, value);
12811 }
12812
12813 public void setFieldValue(_Fields field, Object value) {
12814 switch (field) {
12815 case SCANNER_ID:
12816 if (value == null) {
12817 unsetScannerId();
12818 } else {
12819 setScannerId((Integer)value);
12820 }
12821 break;
12822
12823 case NUM_ROWS:
12824 if (value == null) {
12825 unsetNumRows();
12826 } else {
12827 setNumRows((Integer)value);
12828 }
12829 break;
12830
12831 }
12832 }
12833
12834 public Object getFieldValue(_Fields field) {
12835 switch (field) {
12836 case SCANNER_ID:
12837 return Integer.valueOf(getScannerId());
12838
12839 case NUM_ROWS:
12840 return Integer.valueOf(getNumRows());
12841
12842 }
12843 throw new IllegalStateException();
12844 }
12845
12846
12847 public boolean isSet(_Fields field) {
12848 if (field == null) {
12849 throw new IllegalArgumentException();
12850 }
12851
12852 switch (field) {
12853 case SCANNER_ID:
12854 return isSetScannerId();
12855 case NUM_ROWS:
12856 return isSetNumRows();
12857 }
12858 throw new IllegalStateException();
12859 }
12860
12861 @Override
12862 public boolean equals(Object that) {
12863 if (that == null)
12864 return false;
12865 if (that instanceof getScannerRows_args)
12866 return this.equals((getScannerRows_args)that);
12867 return false;
12868 }
12869
12870 public boolean equals(getScannerRows_args that) {
12871 if (that == null)
12872 return false;
12873
12874 boolean this_present_scannerId = true;
12875 boolean that_present_scannerId = true;
12876 if (this_present_scannerId || that_present_scannerId) {
12877 if (!(this_present_scannerId && that_present_scannerId))
12878 return false;
12879 if (this.scannerId != that.scannerId)
12880 return false;
12881 }
12882
12883 boolean this_present_numRows = true;
12884 boolean that_present_numRows = true;
12885 if (this_present_numRows || that_present_numRows) {
12886 if (!(this_present_numRows && that_present_numRows))
12887 return false;
12888 if (this.numRows != that.numRows)
12889 return false;
12890 }
12891
12892 return true;
12893 }
12894
12895 @Override
12896 public int hashCode() {
12897 return 0;
12898 }
12899
12900 public int compareTo(getScannerRows_args other) {
12901 if (!getClass().equals(other.getClass())) {
12902 return getClass().getName().compareTo(other.getClass().getName());
12903 }
12904
12905 int lastComparison = 0;
12906 getScannerRows_args typedOther = (getScannerRows_args)other;
12907
12908 lastComparison = Boolean.valueOf(isSetScannerId()).compareTo(typedOther.isSetScannerId());
12909 if (lastComparison != 0) {
12910 return lastComparison;
12911 }
12912 if (isSetScannerId()) {
12913 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, typedOther.scannerId);
12914 if (lastComparison != 0) {
12915 return lastComparison;
12916 }
12917 }
12918 lastComparison = Boolean.valueOf(isSetNumRows()).compareTo(typedOther.isSetNumRows());
12919 if (lastComparison != 0) {
12920 return lastComparison;
12921 }
12922 if (isSetNumRows()) {
12923 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numRows, typedOther.numRows);
12924 if (lastComparison != 0) {
12925 return lastComparison;
12926 }
12927 }
12928 return 0;
12929 }
12930
12931 public _Fields fieldForId(int fieldId) {
12932 return _Fields.findByThriftId(fieldId);
12933 }
12934
12935 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
12936 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
12937 }
12938
12939 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
12940 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
12941 }
12942
12943 @Override
12944 public String toString() {
12945 StringBuilder sb = new StringBuilder("getScannerRows_args(");
12946 boolean first = true;
12947
12948 sb.append("scannerId:");
12949 sb.append(this.scannerId);
12950 first = false;
12951 if (!first) sb.append(", ");
12952 sb.append("numRows:");
12953 sb.append(this.numRows);
12954 first = false;
12955 sb.append(")");
12956 return sb.toString();
12957 }
12958
12959 public void validate() throws org.apache.thrift.TException {
12960
12961
12962 }
12963
12964 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
12965 try {
12966 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
12967 } catch (org.apache.thrift.TException te) {
12968 throw new java.io.IOException(te);
12969 }
12970 }
12971
12972 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
12973 try {
12974
12975 __isset_bit_vector = new BitSet(1);
12976 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
12977 } catch (org.apache.thrift.TException te) {
12978 throw new java.io.IOException(te);
12979 }
12980 }
12981
12982 private static class getScannerRows_argsStandardSchemeFactory implements SchemeFactory {
12983 public getScannerRows_argsStandardScheme getScheme() {
12984 return new getScannerRows_argsStandardScheme();
12985 }
12986 }
12987
12988 private static class getScannerRows_argsStandardScheme extends StandardScheme<getScannerRows_args> {
12989
12990 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_args struct) throws org.apache.thrift.TException {
12991 org.apache.thrift.protocol.TField schemeField;
12992 iprot.readStructBegin();
12993 while (true)
12994 {
12995 schemeField = iprot.readFieldBegin();
12996 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
12997 break;
12998 }
12999 switch (schemeField.id) {
13000 case 1:
13001 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
13002 struct.scannerId = iprot.readI32();
13003 struct.setScannerIdIsSet(true);
13004 } else {
13005 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13006 }
13007 break;
13008 case 2:
13009 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
13010 struct.numRows = iprot.readI32();
13011 struct.setNumRowsIsSet(true);
13012 } else {
13013 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13014 }
13015 break;
13016 default:
13017 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13018 }
13019 iprot.readFieldEnd();
13020 }
13021 iprot.readStructEnd();
13022
13023
13024 if (!struct.isSetScannerId()) {
13025 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
13026 }
13027 struct.validate();
13028 }
13029
13030 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_args struct) throws org.apache.thrift.TException {
13031 struct.validate();
13032
13033 oprot.writeStructBegin(STRUCT_DESC);
13034 oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
13035 oprot.writeI32(struct.scannerId);
13036 oprot.writeFieldEnd();
13037 oprot.writeFieldBegin(NUM_ROWS_FIELD_DESC);
13038 oprot.writeI32(struct.numRows);
13039 oprot.writeFieldEnd();
13040 oprot.writeFieldStop();
13041 oprot.writeStructEnd();
13042 }
13043
13044 }
13045
13046 private static class getScannerRows_argsTupleSchemeFactory implements SchemeFactory {
13047 public getScannerRows_argsTupleScheme getScheme() {
13048 return new getScannerRows_argsTupleScheme();
13049 }
13050 }
13051
13052 private static class getScannerRows_argsTupleScheme extends TupleScheme<getScannerRows_args> {
13053
13054 @Override
13055 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
13056 TTupleProtocol oprot = (TTupleProtocol) prot;
13057 oprot.writeI32(struct.scannerId);
13058 BitSet optionals = new BitSet();
13059 if (struct.isSetNumRows()) {
13060 optionals.set(0);
13061 }
13062 oprot.writeBitSet(optionals, 1);
13063 if (struct.isSetNumRows()) {
13064 oprot.writeI32(struct.numRows);
13065 }
13066 }
13067
13068 @Override
13069 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_args struct) throws org.apache.thrift.TException {
13070 TTupleProtocol iprot = (TTupleProtocol) prot;
13071 struct.scannerId = iprot.readI32();
13072 struct.setScannerIdIsSet(true);
13073 BitSet incoming = iprot.readBitSet(1);
13074 if (incoming.get(0)) {
13075 struct.numRows = iprot.readI32();
13076 struct.setNumRowsIsSet(true);
13077 }
13078 }
13079 }
13080
13081 }
13082
13083 public static class getScannerRows_result implements org.apache.thrift.TBase<getScannerRows_result, getScannerRows_result._Fields>, java.io.Serializable, Cloneable {
13084 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getScannerRows_result");
13085
13086 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);
13087 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);
13088 private static final org.apache.thrift.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2);
13089
13090 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
13091 static {
13092 schemes.put(StandardScheme.class, new getScannerRows_resultStandardSchemeFactory());
13093 schemes.put(TupleScheme.class, new getScannerRows_resultTupleSchemeFactory());
13094 }
13095
13096 public List<TResult> success;
13097 public TIOError io;
13098
13099
13100
13101 public TIllegalArgument ia;
13102
13103
13104 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
13105 SUCCESS((short)0, "success"),
13106 IO((short)1, "io"),
13107
13108
13109
13110 IA((short)2, "ia");
13111
13112 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13113
13114 static {
13115 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13116 byName.put(field.getFieldName(), field);
13117 }
13118 }
13119
13120
13121
13122
13123 public static _Fields findByThriftId(int fieldId) {
13124 switch(fieldId) {
13125 case 0:
13126 return SUCCESS;
13127 case 1:
13128 return IO;
13129 case 2:
13130 return IA;
13131 default:
13132 return null;
13133 }
13134 }
13135
13136
13137
13138
13139
13140 public static _Fields findByThriftIdOrThrow(int fieldId) {
13141 _Fields fields = findByThriftId(fieldId);
13142 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13143 return fields;
13144 }
13145
13146
13147
13148
13149 public static _Fields findByName(String name) {
13150 return byName.get(name);
13151 }
13152
13153 private final short _thriftId;
13154 private final String _fieldName;
13155
13156 _Fields(short thriftId, String fieldName) {
13157 _thriftId = thriftId;
13158 _fieldName = fieldName;
13159 }
13160
13161 public short getThriftFieldId() {
13162 return _thriftId;
13163 }
13164
13165 public String getFieldName() {
13166 return _fieldName;
13167 }
13168 }
13169
13170
13171 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
13172 static {
13173 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
13174 tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
13175 new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
13176 new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
13177 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
13178 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
13179 tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
13180 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
13181 metaDataMap = Collections.unmodifiableMap(tmpMap);
13182 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getScannerRows_result.class, metaDataMap);
13183 }
13184
13185 public getScannerRows_result() {
13186 }
13187
13188 public getScannerRows_result(
13189 List<TResult> success,
13190 TIOError io,
13191 TIllegalArgument ia)
13192 {
13193 this();
13194 this.success = success;
13195 this.io = io;
13196 this.ia = ia;
13197 }
13198
13199
13200
13201
13202 public getScannerRows_result(getScannerRows_result other) {
13203 if (other.isSetSuccess()) {
13204 List<TResult> __this__success = new ArrayList<TResult>();
13205 for (TResult other_element : other.success) {
13206 __this__success.add(new TResult(other_element));
13207 }
13208 this.success = __this__success;
13209 }
13210 if (other.isSetIo()) {
13211 this.io = new TIOError(other.io);
13212 }
13213 if (other.isSetIa()) {
13214 this.ia = new TIllegalArgument(other.ia);
13215 }
13216 }
13217
13218 public getScannerRows_result deepCopy() {
13219 return new getScannerRows_result(this);
13220 }
13221
13222 @Override
13223 public void clear() {
13224 this.success = null;
13225 this.io = null;
13226 this.ia = null;
13227 }
13228
13229 public int getSuccessSize() {
13230 return (this.success == null) ? 0 : this.success.size();
13231 }
13232
13233 public java.util.Iterator<TResult> getSuccessIterator() {
13234 return (this.success == null) ? null : this.success.iterator();
13235 }
13236
13237 public void addToSuccess(TResult elem) {
13238 if (this.success == null) {
13239 this.success = new ArrayList<TResult>();
13240 }
13241 this.success.add(elem);
13242 }
13243
13244 public List<TResult> getSuccess() {
13245 return this.success;
13246 }
13247
13248 public getScannerRows_result setSuccess(List<TResult> success) {
13249 this.success = success;
13250 return this;
13251 }
13252
13253 public void unsetSuccess() {
13254 this.success = null;
13255 }
13256
13257
13258 public boolean isSetSuccess() {
13259 return this.success != null;
13260 }
13261
13262 public void setSuccessIsSet(boolean value) {
13263 if (!value) {
13264 this.success = null;
13265 }
13266 }
13267
13268 public TIOError getIo() {
13269 return this.io;
13270 }
13271
13272 public getScannerRows_result setIo(TIOError io) {
13273 this.io = io;
13274 return this;
13275 }
13276
13277 public void unsetIo() {
13278 this.io = null;
13279 }
13280
13281
13282 public boolean isSetIo() {
13283 return this.io != null;
13284 }
13285
13286 public void setIoIsSet(boolean value) {
13287 if (!value) {
13288 this.io = null;
13289 }
13290 }
13291
13292
13293
13294
13295 public TIllegalArgument getIa() {
13296 return this.ia;
13297 }
13298
13299
13300
13301
13302 public getScannerRows_result setIa(TIllegalArgument ia) {
13303 this.ia = ia;
13304 return this;
13305 }
13306
13307 public void unsetIa() {
13308 this.ia = null;
13309 }
13310
13311
13312 public boolean isSetIa() {
13313 return this.ia != null;
13314 }
13315
13316 public void setIaIsSet(boolean value) {
13317 if (!value) {
13318 this.ia = null;
13319 }
13320 }
13321
13322 public void setFieldValue(_Fields field, Object value) {
13323 switch (field) {
13324 case SUCCESS:
13325 if (value == null) {
13326 unsetSuccess();
13327 } else {
13328 setSuccess((List<TResult>)value);
13329 }
13330 break;
13331
13332 case IO:
13333 if (value == null) {
13334 unsetIo();
13335 } else {
13336 setIo((TIOError)value);
13337 }
13338 break;
13339
13340 case IA:
13341 if (value == null) {
13342 unsetIa();
13343 } else {
13344 setIa((TIllegalArgument)value);
13345 }
13346 break;
13347
13348 }
13349 }
13350
13351 public Object getFieldValue(_Fields field) {
13352 switch (field) {
13353 case SUCCESS:
13354 return getSuccess();
13355
13356 case IO:
13357 return getIo();
13358
13359 case IA:
13360 return getIa();
13361
13362 }
13363 throw new IllegalStateException();
13364 }
13365
13366
13367 public boolean isSet(_Fields field) {
13368 if (field == null) {
13369 throw new IllegalArgumentException();
13370 }
13371
13372 switch (field) {
13373 case SUCCESS:
13374 return isSetSuccess();
13375 case IO:
13376 return isSetIo();
13377 case IA:
13378 return isSetIa();
13379 }
13380 throw new IllegalStateException();
13381 }
13382
13383 @Override
13384 public boolean equals(Object that) {
13385 if (that == null)
13386 return false;
13387 if (that instanceof getScannerRows_result)
13388 return this.equals((getScannerRows_result)that);
13389 return false;
13390 }
13391
13392 public boolean equals(getScannerRows_result that) {
13393 if (that == null)
13394 return false;
13395
13396 boolean this_present_success = true && this.isSetSuccess();
13397 boolean that_present_success = true && that.isSetSuccess();
13398 if (this_present_success || that_present_success) {
13399 if (!(this_present_success && that_present_success))
13400 return false;
13401 if (!this.success.equals(that.success))
13402 return false;
13403 }
13404
13405 boolean this_present_io = true && this.isSetIo();
13406 boolean that_present_io = true && that.isSetIo();
13407 if (this_present_io || that_present_io) {
13408 if (!(this_present_io && that_present_io))
13409 return false;
13410 if (!this.io.equals(that.io))
13411 return false;
13412 }
13413
13414 boolean this_present_ia = true && this.isSetIa();
13415 boolean that_present_ia = true && that.isSetIa();
13416 if (this_present_ia || that_present_ia) {
13417 if (!(this_present_ia && that_present_ia))
13418 return false;
13419 if (!this.ia.equals(that.ia))
13420 return false;
13421 }
13422
13423 return true;
13424 }
13425
13426 @Override
13427 public int hashCode() {
13428 return 0;
13429 }
13430
13431 public int compareTo(getScannerRows_result other) {
13432 if (!getClass().equals(other.getClass())) {
13433 return getClass().getName().compareTo(other.getClass().getName());
13434 }
13435
13436 int lastComparison = 0;
13437 getScannerRows_result typedOther = (getScannerRows_result)other;
13438
13439 lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
13440 if (lastComparison != 0) {
13441 return lastComparison;
13442 }
13443 if (isSetSuccess()) {
13444 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
13445 if (lastComparison != 0) {
13446 return lastComparison;
13447 }
13448 }
13449 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
13450 if (lastComparison != 0) {
13451 return lastComparison;
13452 }
13453 if (isSetIo()) {
13454 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
13455 if (lastComparison != 0) {
13456 return lastComparison;
13457 }
13458 }
13459 lastComparison = Boolean.valueOf(isSetIa()).compareTo(typedOther.isSetIa());
13460 if (lastComparison != 0) {
13461 return lastComparison;
13462 }
13463 if (isSetIa()) {
13464 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia);
13465 if (lastComparison != 0) {
13466 return lastComparison;
13467 }
13468 }
13469 return 0;
13470 }
13471
13472 public _Fields fieldForId(int fieldId) {
13473 return _Fields.findByThriftId(fieldId);
13474 }
13475
13476 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
13477 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
13478 }
13479
13480 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
13481 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
13482 }
13483
13484 @Override
13485 public String toString() {
13486 StringBuilder sb = new StringBuilder("getScannerRows_result(");
13487 boolean first = true;
13488
13489 sb.append("success:");
13490 if (this.success == null) {
13491 sb.append("null");
13492 } else {
13493 sb.append(this.success);
13494 }
13495 first = false;
13496 if (!first) sb.append(", ");
13497 sb.append("io:");
13498 if (this.io == null) {
13499 sb.append("null");
13500 } else {
13501 sb.append(this.io);
13502 }
13503 first = false;
13504 if (!first) sb.append(", ");
13505 sb.append("ia:");
13506 if (this.ia == null) {
13507 sb.append("null");
13508 } else {
13509 sb.append(this.ia);
13510 }
13511 first = false;
13512 sb.append(")");
13513 return sb.toString();
13514 }
13515
13516 public void validate() throws org.apache.thrift.TException {
13517
13518 }
13519
13520 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
13521 try {
13522 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
13523 } catch (org.apache.thrift.TException te) {
13524 throw new java.io.IOException(te);
13525 }
13526 }
13527
13528 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
13529 try {
13530 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
13531 } catch (org.apache.thrift.TException te) {
13532 throw new java.io.IOException(te);
13533 }
13534 }
13535
13536 private static class getScannerRows_resultStandardSchemeFactory implements SchemeFactory {
13537 public getScannerRows_resultStandardScheme getScheme() {
13538 return new getScannerRows_resultStandardScheme();
13539 }
13540 }
13541
13542 private static class getScannerRows_resultStandardScheme extends StandardScheme<getScannerRows_result> {
13543
13544 public void read(org.apache.thrift.protocol.TProtocol iprot, getScannerRows_result struct) throws org.apache.thrift.TException {
13545 org.apache.thrift.protocol.TField schemeField;
13546 iprot.readStructBegin();
13547 while (true)
13548 {
13549 schemeField = iprot.readFieldBegin();
13550 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
13551 break;
13552 }
13553 switch (schemeField.id) {
13554 case 0:
13555 if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
13556 {
13557 org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
13558 struct.success = new ArrayList<TResult>(_list88.size);
13559 for (int _i89 = 0; _i89 < _list88.size; ++_i89)
13560 {
13561 TResult _elem90;
13562 _elem90 = new TResult();
13563 _elem90.read(iprot);
13564 struct.success.add(_elem90);
13565 }
13566 iprot.readListEnd();
13567 }
13568 struct.setSuccessIsSet(true);
13569 } else {
13570 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13571 }
13572 break;
13573 case 1:
13574 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
13575 struct.io = new TIOError();
13576 struct.io.read(iprot);
13577 struct.setIoIsSet(true);
13578 } else {
13579 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13580 }
13581 break;
13582 case 2:
13583 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
13584 struct.ia = new TIllegalArgument();
13585 struct.ia.read(iprot);
13586 struct.setIaIsSet(true);
13587 } else {
13588 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13589 }
13590 break;
13591 default:
13592 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
13593 }
13594 iprot.readFieldEnd();
13595 }
13596 iprot.readStructEnd();
13597
13598
13599 struct.validate();
13600 }
13601
13602 public void write(org.apache.thrift.protocol.TProtocol oprot, getScannerRows_result struct) throws org.apache.thrift.TException {
13603 struct.validate();
13604
13605 oprot.writeStructBegin(STRUCT_DESC);
13606 if (struct.success != null) {
13607 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13608 {
13609 oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
13610 for (TResult _iter91 : struct.success)
13611 {
13612 _iter91.write(oprot);
13613 }
13614 oprot.writeListEnd();
13615 }
13616 oprot.writeFieldEnd();
13617 }
13618 if (struct.io != null) {
13619 oprot.writeFieldBegin(IO_FIELD_DESC);
13620 struct.io.write(oprot);
13621 oprot.writeFieldEnd();
13622 }
13623 if (struct.ia != null) {
13624 oprot.writeFieldBegin(IA_FIELD_DESC);
13625 struct.ia.write(oprot);
13626 oprot.writeFieldEnd();
13627 }
13628 oprot.writeFieldStop();
13629 oprot.writeStructEnd();
13630 }
13631
13632 }
13633
13634 private static class getScannerRows_resultTupleSchemeFactory implements SchemeFactory {
13635 public getScannerRows_resultTupleScheme getScheme() {
13636 return new getScannerRows_resultTupleScheme();
13637 }
13638 }
13639
13640 private static class getScannerRows_resultTupleScheme extends TupleScheme<getScannerRows_result> {
13641
13642 @Override
13643 public void write(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
13644 TTupleProtocol oprot = (TTupleProtocol) prot;
13645 BitSet optionals = new BitSet();
13646 if (struct.isSetSuccess()) {
13647 optionals.set(0);
13648 }
13649 if (struct.isSetIo()) {
13650 optionals.set(1);
13651 }
13652 if (struct.isSetIa()) {
13653 optionals.set(2);
13654 }
13655 oprot.writeBitSet(optionals, 3);
13656 if (struct.isSetSuccess()) {
13657 {
13658 oprot.writeI32(struct.success.size());
13659 for (TResult _iter92 : struct.success)
13660 {
13661 _iter92.write(oprot);
13662 }
13663 }
13664 }
13665 if (struct.isSetIo()) {
13666 struct.io.write(oprot);
13667 }
13668 if (struct.isSetIa()) {
13669 struct.ia.write(oprot);
13670 }
13671 }
13672
13673 @Override
13674 public void read(org.apache.thrift.protocol.TProtocol prot, getScannerRows_result struct) throws org.apache.thrift.TException {
13675 TTupleProtocol iprot = (TTupleProtocol) prot;
13676 BitSet incoming = iprot.readBitSet(3);
13677 if (incoming.get(0)) {
13678 {
13679 org.apache.thrift.protocol.TList _list93 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
13680 struct.success = new ArrayList<TResult>(_list93.size);
13681 for (int _i94 = 0; _i94 < _list93.size; ++_i94)
13682 {
13683 TResult _elem95;
13684 _elem95 = new TResult();
13685 _elem95.read(iprot);
13686 struct.success.add(_elem95);
13687 }
13688 }
13689 struct.setSuccessIsSet(true);
13690 }
13691 if (incoming.get(1)) {
13692 struct.io = new TIOError();
13693 struct.io.read(iprot);
13694 struct.setIoIsSet(true);
13695 }
13696 if (incoming.get(2)) {
13697 struct.ia = new TIllegalArgument();
13698 struct.ia.read(iprot);
13699 struct.setIaIsSet(true);
13700 }
13701 }
13702 }
13703
13704 }
13705
13706 public static class closeScanner_args implements org.apache.thrift.TBase<closeScanner_args, closeScanner_args._Fields>, java.io.Serializable, Cloneable {
13707 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_args");
13708
13709 private static final org.apache.thrift.protocol.TField SCANNER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("scannerId", org.apache.thrift.protocol.TType.I32, (short)1);
13710
13711 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
13712 static {
13713 schemes.put(StandardScheme.class, new closeScanner_argsStandardSchemeFactory());
13714 schemes.put(TupleScheme.class, new closeScanner_argsTupleSchemeFactory());
13715 }
13716
13717
13718
13719
13720 public int scannerId;
13721
13722
13723 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
13724
13725
13726
13727 SCANNER_ID((short)1, "scannerId");
13728
13729 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13730
13731 static {
13732 for (_Fields field : EnumSet.allOf(_Fields.class)) {
13733 byName.put(field.getFieldName(), field);
13734 }
13735 }
13736
13737
13738
13739
13740 public static _Fields findByThriftId(int fieldId) {
13741 switch(fieldId) {
13742 case 1:
13743 return SCANNER_ID;
13744 default:
13745 return null;
13746 }
13747 }
13748
13749
13750
13751
13752
13753 public static _Fields findByThriftIdOrThrow(int fieldId) {
13754 _Fields fields = findByThriftId(fieldId);
13755 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13756 return fields;
13757 }
13758
13759
13760
13761
13762 public static _Fields findByName(String name) {
13763 return byName.get(name);
13764 }
13765
13766 private final short _thriftId;
13767 private final String _fieldName;
13768
13769 _Fields(short thriftId, String fieldName) {
13770 _thriftId = thriftId;
13771 _fieldName = fieldName;
13772 }
13773
13774 public short getThriftFieldId() {
13775 return _thriftId;
13776 }
13777
13778 public String getFieldName() {
13779 return _fieldName;
13780 }
13781 }
13782
13783
13784 private static final int __SCANNERID_ISSET_ID = 0;
13785 private BitSet __isset_bit_vector = new BitSet(1);
13786 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
13787 static {
13788 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
13789 tmpMap.put(_Fields.SCANNER_ID, new org.apache.thrift.meta_data.FieldMetaData("scannerId", org.apache.thrift.TFieldRequirementType.REQUIRED,
13790 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
13791 metaDataMap = Collections.unmodifiableMap(tmpMap);
13792 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_args.class, metaDataMap);
13793 }
13794
13795 public closeScanner_args() {
13796 }
13797
13798 public closeScanner_args(
13799 int scannerId)
13800 {
13801 this();
13802 this.scannerId = scannerId;
13803 setScannerIdIsSet(true);
13804 }
13805
13806
13807
13808
13809 public closeScanner_args(closeScanner_args other) {
13810 __isset_bit_vector.clear();
13811 __isset_bit_vector.or(other.__isset_bit_vector);
13812 this.scannerId = other.scannerId;
13813 }
13814
13815 public closeScanner_args deepCopy() {
13816 return new closeScanner_args(this);
13817 }
13818
13819 @Override
13820 public void clear() {
13821 setScannerIdIsSet(false);
13822 this.scannerId = 0;
13823 }
13824
13825
13826
13827
13828 public int getScannerId() {
13829 return this.scannerId;
13830 }
13831
13832
13833
13834
13835 public closeScanner_args setScannerId(int scannerId) {
13836 this.scannerId = scannerId;
13837 setScannerIdIsSet(true);
13838 return this;
13839 }
13840
13841 public void unsetScannerId() {
13842 __isset_bit_vector.clear(__SCANNERID_ISSET_ID);
13843 }
13844
13845
13846 public boolean isSetScannerId() {
13847 return __isset_bit_vector.get(__SCANNERID_ISSET_ID);
13848 }
13849
13850 public void setScannerIdIsSet(boolean value) {
13851 __isset_bit_vector.set(__SCANNERID_ISSET_ID, value);
13852 }
13853
13854 public void setFieldValue(_Fields field, Object value) {
13855 switch (field) {
13856 case SCANNER_ID:
13857 if (value == null) {
13858 unsetScannerId();
13859 } else {
13860 setScannerId((Integer)value);
13861 }
13862 break;
13863
13864 }
13865 }
13866
13867 public Object getFieldValue(_Fields field) {
13868 switch (field) {
13869 case SCANNER_ID:
13870 return Integer.valueOf(getScannerId());
13871
13872 }
13873 throw new IllegalStateException();
13874 }
13875
13876
13877 public boolean isSet(_Fields field) {
13878 if (field == null) {
13879 throw new IllegalArgumentException();
13880 }
13881
13882 switch (field) {
13883 case SCANNER_ID:
13884 return isSetScannerId();
13885 }
13886 throw new IllegalStateException();
13887 }
13888
13889 @Override
13890 public boolean equals(Object that) {
13891 if (that == null)
13892 return false;
13893 if (that instanceof closeScanner_args)
13894 return this.equals((closeScanner_args)that);
13895 return false;
13896 }
13897
13898 public boolean equals(closeScanner_args that) {
13899 if (that == null)
13900 return false;
13901
13902 boolean this_present_scannerId = true;
13903 boolean that_present_scannerId = true;
13904 if (this_present_scannerId || that_present_scannerId) {
13905 if (!(this_present_scannerId && that_present_scannerId))
13906 return false;
13907 if (this.scannerId != that.scannerId)
13908 return false;
13909 }
13910
13911 return true;
13912 }
13913
13914 @Override
13915 public int hashCode() {
13916 return 0;
13917 }
13918
13919 public int compareTo(closeScanner_args other) {
13920 if (!getClass().equals(other.getClass())) {
13921 return getClass().getName().compareTo(other.getClass().getName());
13922 }
13923
13924 int lastComparison = 0;
13925 closeScanner_args typedOther = (closeScanner_args)other;
13926
13927 lastComparison = Boolean.valueOf(isSetScannerId()).compareTo(typedOther.isSetScannerId());
13928 if (lastComparison != 0) {
13929 return lastComparison;
13930 }
13931 if (isSetScannerId()) {
13932 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scannerId, typedOther.scannerId);
13933 if (lastComparison != 0) {
13934 return lastComparison;
13935 }
13936 }
13937 return 0;
13938 }
13939
13940 public _Fields fieldForId(int fieldId) {
13941 return _Fields.findByThriftId(fieldId);
13942 }
13943
13944 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
13945 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
13946 }
13947
13948 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
13949 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
13950 }
13951
13952 @Override
13953 public String toString() {
13954 StringBuilder sb = new StringBuilder("closeScanner_args(");
13955 boolean first = true;
13956
13957 sb.append("scannerId:");
13958 sb.append(this.scannerId);
13959 first = false;
13960 sb.append(")");
13961 return sb.toString();
13962 }
13963
13964 public void validate() throws org.apache.thrift.TException {
13965
13966
13967 }
13968
13969 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
13970 try {
13971 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
13972 } catch (org.apache.thrift.TException te) {
13973 throw new java.io.IOException(te);
13974 }
13975 }
13976
13977 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
13978 try {
13979
13980 __isset_bit_vector = new BitSet(1);
13981 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
13982 } catch (org.apache.thrift.TException te) {
13983 throw new java.io.IOException(te);
13984 }
13985 }
13986
13987 private static class closeScanner_argsStandardSchemeFactory implements SchemeFactory {
13988 public closeScanner_argsStandardScheme getScheme() {
13989 return new closeScanner_argsStandardScheme();
13990 }
13991 }
13992
13993 private static class closeScanner_argsStandardScheme extends StandardScheme<closeScanner_args> {
13994
13995 public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_args struct) throws org.apache.thrift.TException {
13996 org.apache.thrift.protocol.TField schemeField;
13997 iprot.readStructBegin();
13998 while (true)
13999 {
14000 schemeField = iprot.readFieldBegin();
14001 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
14002 break;
14003 }
14004 switch (schemeField.id) {
14005 case 1:
14006 if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
14007 struct.scannerId = iprot.readI32();
14008 struct.setScannerIdIsSet(true);
14009 } else {
14010 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14011 }
14012 break;
14013 default:
14014 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14015 }
14016 iprot.readFieldEnd();
14017 }
14018 iprot.readStructEnd();
14019
14020
14021 if (!struct.isSetScannerId()) {
14022 throw new org.apache.thrift.protocol.TProtocolException("Required field 'scannerId' was not found in serialized data! Struct: " + toString());
14023 }
14024 struct.validate();
14025 }
14026
14027 public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_args struct) throws org.apache.thrift.TException {
14028 struct.validate();
14029
14030 oprot.writeStructBegin(STRUCT_DESC);
14031 oprot.writeFieldBegin(SCANNER_ID_FIELD_DESC);
14032 oprot.writeI32(struct.scannerId);
14033 oprot.writeFieldEnd();
14034 oprot.writeFieldStop();
14035 oprot.writeStructEnd();
14036 }
14037
14038 }
14039
14040 private static class closeScanner_argsTupleSchemeFactory implements SchemeFactory {
14041 public closeScanner_argsTupleScheme getScheme() {
14042 return new closeScanner_argsTupleScheme();
14043 }
14044 }
14045
14046 private static class closeScanner_argsTupleScheme extends TupleScheme<closeScanner_args> {
14047
14048 @Override
14049 public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
14050 TTupleProtocol oprot = (TTupleProtocol) prot;
14051 oprot.writeI32(struct.scannerId);
14052 }
14053
14054 @Override
14055 public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_args struct) throws org.apache.thrift.TException {
14056 TTupleProtocol iprot = (TTupleProtocol) prot;
14057 struct.scannerId = iprot.readI32();
14058 struct.setScannerIdIsSet(true);
14059 }
14060 }
14061
14062 }
14063
14064 public static class closeScanner_result implements org.apache.thrift.TBase<closeScanner_result, closeScanner_result._Fields>, java.io.Serializable, Cloneable {
14065 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("closeScanner_result");
14066
14067 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);
14068 private static final org.apache.thrift.protocol.TField IA_FIELD_DESC = new org.apache.thrift.protocol.TField("ia", org.apache.thrift.protocol.TType.STRUCT, (short)2);
14069
14070 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
14071 static {
14072 schemes.put(StandardScheme.class, new closeScanner_resultStandardSchemeFactory());
14073 schemes.put(TupleScheme.class, new closeScanner_resultTupleSchemeFactory());
14074 }
14075
14076 public TIOError io;
14077
14078
14079
14080 public TIllegalArgument ia;
14081
14082
14083 public enum _Fields implements org.apache.thrift.TFieldIdEnum {
14084 IO((short)1, "io"),
14085
14086
14087
14088 IA((short)2, "ia");
14089
14090 private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14091
14092 static {
14093 for (_Fields field : EnumSet.allOf(_Fields.class)) {
14094 byName.put(field.getFieldName(), field);
14095 }
14096 }
14097
14098
14099
14100
14101 public static _Fields findByThriftId(int fieldId) {
14102 switch(fieldId) {
14103 case 1:
14104 return IO;
14105 case 2:
14106 return IA;
14107 default:
14108 return null;
14109 }
14110 }
14111
14112
14113
14114
14115
14116 public static _Fields findByThriftIdOrThrow(int fieldId) {
14117 _Fields fields = findByThriftId(fieldId);
14118 if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14119 return fields;
14120 }
14121
14122
14123
14124
14125 public static _Fields findByName(String name) {
14126 return byName.get(name);
14127 }
14128
14129 private final short _thriftId;
14130 private final String _fieldName;
14131
14132 _Fields(short thriftId, String fieldName) {
14133 _thriftId = thriftId;
14134 _fieldName = fieldName;
14135 }
14136
14137 public short getThriftFieldId() {
14138 return _thriftId;
14139 }
14140
14141 public String getFieldName() {
14142 return _fieldName;
14143 }
14144 }
14145
14146
14147 public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
14148 static {
14149 Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
14150 tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT,
14151 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
14152 tmpMap.put(_Fields.IA, new org.apache.thrift.meta_data.FieldMetaData("ia", org.apache.thrift.TFieldRequirementType.DEFAULT,
14153 new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
14154 metaDataMap = Collections.unmodifiableMap(tmpMap);
14155 org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(closeScanner_result.class, metaDataMap);
14156 }
14157
14158 public closeScanner_result() {
14159 }
14160
14161 public closeScanner_result(
14162 TIOError io,
14163 TIllegalArgument ia)
14164 {
14165 this();
14166 this.io = io;
14167 this.ia = ia;
14168 }
14169
14170
14171
14172
14173 public closeScanner_result(closeScanner_result other) {
14174 if (other.isSetIo()) {
14175 this.io = new TIOError(other.io);
14176 }
14177 if (other.isSetIa()) {
14178 this.ia = new TIllegalArgument(other.ia);
14179 }
14180 }
14181
14182 public closeScanner_result deepCopy() {
14183 return new closeScanner_result(this);
14184 }
14185
14186 @Override
14187 public void clear() {
14188 this.io = null;
14189 this.ia = null;
14190 }
14191
14192 public TIOError getIo() {
14193 return this.io;
14194 }
14195
14196 public closeScanner_result setIo(TIOError io) {
14197 this.io = io;
14198 return this;
14199 }
14200
14201 public void unsetIo() {
14202 this.io = null;
14203 }
14204
14205
14206 public boolean isSetIo() {
14207 return this.io != null;
14208 }
14209
14210 public void setIoIsSet(boolean value) {
14211 if (!value) {
14212 this.io = null;
14213 }
14214 }
14215
14216
14217
14218
14219 public TIllegalArgument getIa() {
14220 return this.ia;
14221 }
14222
14223
14224
14225
14226 public closeScanner_result setIa(TIllegalArgument ia) {
14227 this.ia = ia;
14228 return this;
14229 }
14230
14231 public void unsetIa() {
14232 this.ia = null;
14233 }
14234
14235
14236 public boolean isSetIa() {
14237 return this.ia != null;
14238 }
14239
14240 public void setIaIsSet(boolean value) {
14241 if (!value) {
14242 this.ia = null;
14243 }
14244 }
14245
14246 public void setFieldValue(_Fields field, Object value) {
14247 switch (field) {
14248 case IO:
14249 if (value == null) {
14250 unsetIo();
14251 } else {
14252 setIo((TIOError)value);
14253 }
14254 break;
14255
14256 case IA:
14257 if (value == null) {
14258 unsetIa();
14259 } else {
14260 setIa((TIllegalArgument)value);
14261 }
14262 break;
14263
14264 }
14265 }
14266
14267 public Object getFieldValue(_Fields field) {
14268 switch (field) {
14269 case IO:
14270 return getIo();
14271
14272 case IA:
14273 return getIa();
14274
14275 }
14276 throw new IllegalStateException();
14277 }
14278
14279
14280 public boolean isSet(_Fields field) {
14281 if (field == null) {
14282 throw new IllegalArgumentException();
14283 }
14284
14285 switch (field) {
14286 case IO:
14287 return isSetIo();
14288 case IA:
14289 return isSetIa();
14290 }
14291 throw new IllegalStateException();
14292 }
14293
14294 @Override
14295 public boolean equals(Object that) {
14296 if (that == null)
14297 return false;
14298 if (that instanceof closeScanner_result)
14299 return this.equals((closeScanner_result)that);
14300 return false;
14301 }
14302
14303 public boolean equals(closeScanner_result that) {
14304 if (that == null)
14305 return false;
14306
14307 boolean this_present_io = true && this.isSetIo();
14308 boolean that_present_io = true && that.isSetIo();
14309 if (this_present_io || that_present_io) {
14310 if (!(this_present_io && that_present_io))
14311 return false;
14312 if (!this.io.equals(that.io))
14313 return false;
14314 }
14315
14316 boolean this_present_ia = true && this.isSetIa();
14317 boolean that_present_ia = true && that.isSetIa();
14318 if (this_present_ia || that_present_ia) {
14319 if (!(this_present_ia && that_present_ia))
14320 return false;
14321 if (!this.ia.equals(that.ia))
14322 return false;
14323 }
14324
14325 return true;
14326 }
14327
14328 @Override
14329 public int hashCode() {
14330 return 0;
14331 }
14332
14333 public int compareTo(closeScanner_result other) {
14334 if (!getClass().equals(other.getClass())) {
14335 return getClass().getName().compareTo(other.getClass().getName());
14336 }
14337
14338 int lastComparison = 0;
14339 closeScanner_result typedOther = (closeScanner_result)other;
14340
14341 lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
14342 if (lastComparison != 0) {
14343 return lastComparison;
14344 }
14345 if (isSetIo()) {
14346 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
14347 if (lastComparison != 0) {
14348 return lastComparison;
14349 }
14350 }
14351 lastComparison = Boolean.valueOf(isSetIa()).compareTo(typedOther.isSetIa());
14352 if (lastComparison != 0) {
14353 return lastComparison;
14354 }
14355 if (isSetIa()) {
14356 lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ia, typedOther.ia);
14357 if (lastComparison != 0) {
14358 return lastComparison;
14359 }
14360 }
14361 return 0;
14362 }
14363
14364 public _Fields fieldForId(int fieldId) {
14365 return _Fields.findByThriftId(fieldId);
14366 }
14367
14368 public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
14369 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
14370 }
14371
14372 public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
14373 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
14374 }
14375
14376 @Override
14377 public String toString() {
14378 StringBuilder sb = new StringBuilder("closeScanner_result(");
14379 boolean first = true;
14380
14381 sb.append("io:");
14382 if (this.io == null) {
14383 sb.append("null");
14384 } else {
14385 sb.append(this.io);
14386 }
14387 first = false;
14388 if (!first) sb.append(", ");
14389 sb.append("ia:");
14390 if (this.ia == null) {
14391 sb.append("null");
14392 } else {
14393 sb.append(this.ia);
14394 }
14395 first = false;
14396 sb.append(")");
14397 return sb.toString();
14398 }
14399
14400 public void validate() throws org.apache.thrift.TException {
14401
14402 }
14403
14404 private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
14405 try {
14406 write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
14407 } catch (org.apache.thrift.TException te) {
14408 throw new java.io.IOException(te);
14409 }
14410 }
14411
14412 private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
14413 try {
14414 read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
14415 } catch (org.apache.thrift.TException te) {
14416 throw new java.io.IOException(te);
14417 }
14418 }
14419
14420 private static class closeScanner_resultStandardSchemeFactory implements SchemeFactory {
14421 public closeScanner_resultStandardScheme getScheme() {
14422 return new closeScanner_resultStandardScheme();
14423 }
14424 }
14425
14426 private static class closeScanner_resultStandardScheme extends StandardScheme<closeScanner_result> {
14427
14428 public void read(org.apache.thrift.protocol.TProtocol iprot, closeScanner_result struct) throws org.apache.thrift.TException {
14429 org.apache.thrift.protocol.TField schemeField;
14430 iprot.readStructBegin();
14431 while (true)
14432 {
14433 schemeField = iprot.readFieldBegin();
14434 if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
14435 break;
14436 }
14437 switch (schemeField.id) {
14438 case 1:
14439 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14440 struct.io = new TIOError();
14441 struct.io.read(iprot);
14442 struct.setIoIsSet(true);
14443 } else {
14444 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14445 }
14446 break;
14447 case 2:
14448 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
14449 struct.ia = new TIllegalArgument();
14450 struct.ia.read(iprot);
14451 struct.setIaIsSet(true);
14452 } else {
14453 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14454 }
14455 break;
14456 default:
14457 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
14458 }
14459 iprot.readFieldEnd();
14460 }
14461 iprot.readStructEnd();
14462
14463
14464 struct.validate();
14465 }
14466
14467 public void write(org.apache.thrift.protocol.TProtocol oprot, closeScanner_result struct) throws org.apache.thrift.TException {
14468 struct.validate();
14469
14470 oprot.writeStructBegin(STRUCT_DESC);
14471 if (struct.io != null) {
14472 oprot.writeFieldBegin(IO_FIELD_DESC);
14473 struct.io.write(oprot);
14474 oprot.writeFieldEnd();
14475 }
14476 if (struct.ia != null) {
14477 oprot.writeFieldBegin(IA_FIELD_DESC);
14478 struct.ia.write(oprot);
14479 oprot.writeFieldEnd();
14480 }
14481 oprot.writeFieldStop();
14482 oprot.writeStructEnd();
14483 }
14484
14485 }
14486
14487 private static class closeScanner_resultTupleSchemeFactory implements SchemeFactory {
14488 public closeScanner_resultTupleScheme getScheme() {
14489 return new closeScanner_resultTupleScheme();
14490 }
14491 }
14492
14493 private static class closeScanner_resultTupleScheme extends TupleScheme<closeScanner_result> {
14494
14495 @Override
14496 public void write(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
14497 TTupleProtocol oprot = (TTupleProtocol) prot;
14498 BitSet optionals = new BitSet();
14499 if (struct.isSetIo()) {
14500 optionals.set(0);
14501 }
14502 if (struct.isSetIa()) {
14503 optionals.set(1);
14504 }
14505 oprot.writeBitSet(optionals, 2);
14506 if (struct.isSetIo()) {
14507 struct.io.write(oprot);
14508 }
14509 if (struct.isSetIa()) {
14510 struct.ia.write(oprot);
14511 }
14512 }
14513
14514 @Override
14515 public void read(org.apache.thrift.protocol.TProtocol prot, closeScanner_result struct) throws org.apache.thrift.TException {
14516 TTupleProtocol iprot = (TTupleProtocol) prot;
14517 BitSet incoming = iprot.readBitSet(2);
14518 if (incoming.get(0)) {
14519 struct.io = new TIOError();
14520 struct.io.read(iprot);
14521 struct.setIoIsSet(true);
14522 }
14523 if (incoming.get(1)) {
14524 struct.ia = new TIllegalArgument();
14525 struct.ia.read(iprot);
14526 struct.setIaIsSet(true);
14527 }
14528 }
14529 }
14530
14531 }
14532
14533 }