View Javadoc

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