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.thrift.scheme.IScheme;
10  import org.apache.thrift.scheme.SchemeFactory;
11  import org.apache.thrift.scheme.StandardScheme;
12  
13  import org.apache.thrift.scheme.TupleScheme;
14  import org.apache.thrift.protocol.TTupleProtocol;
15  import java.util.List;
16  import java.util.ArrayList;
17  import java.util.Map;
18  import java.util.HashMap;
19  import java.util.EnumMap;
20  import java.util.Set;
21  import java.util.HashSet;
22  import java.util.EnumSet;
23  import java.util.Collections;
24  import java.util.BitSet;
25  import java.nio.ByteBuffer;
26  import java.util.Arrays;
27  import org.slf4j.Logger;
28  import org.slf4j.LoggerFactory;
29  
30  public class THBaseService {
31  
32    public interface Iface {
33  
34      /**
35       * Test for the existence of columns in the table, as specified in the TGet.
36       * 
37       * @return true if the specified TGet matches one or more keys, false if not
38       * 
39       * @param table the table to check on
40       * 
41       * @param get the TGet to check for
42       */
43      public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
44  
45      /**
46       * Method for getting data from a row.
47       * 
48       * If the row cannot be found an empty Result is returned.
49       * This can be checked by the empty field of the TResult
50       * 
51       * @return the result
52       * 
53       * @param table the table to get from
54       * 
55       * @param get the TGet to fetch
56       */
57      public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException;
58  
59      /**
60       * Method for getting multiple rows.
61       * 
62       * If a row cannot be found there will be a null
63       * value in the result list for that TGet at the
64       * same position.
65       * 
66       * So the Results are in the same order as the TGets.
67       * 
68       * @param table the table to get from
69       * 
70       * @param gets a list of TGets to fetch, the Result list
71       * will have the Results at corresponding positions
72       * or null if there was an error
73       */
74      public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException;
75  
76      /**
77       * Commit a TPut to a table.
78       * 
79       * @param table the table to put data in
80       * 
81       * @param put the TPut to put
82       */
83      public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException;
84  
85      /**
86       * Atomically checks if a row/family/qualifier value matches the expected
87       * value. If it does, it adds the TPut.
88       * 
89       * @return true if the new put was executed, false otherwise
90       * 
91       * @param table to check in and put to
92       * 
93       * @param row row to check
94       * 
95       * @param family column family to check
96       * 
97       * @param qualifier column qualifier to check
98       * 
99       * @param value the expected value, if not provided the
100      * check is for the non-existence of the
101      * column in question
102      * 
103      * @param put the TPut to put if the check succeeds
104      */
105     public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException;
106 
107     /**
108      * Commit a List of Puts to the table.
109      * 
110      * @param table the table to put data in
111      * 
112      * @param puts a list of TPuts to commit
113      */
114     public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException;
115 
116     /**
117      * Deletes as specified by the TDelete.
118      * 
119      * Note: "delete" is a reserved keyword and cannot be used in Thrift
120      * thus the inconsistent naming scheme from the other functions.
121      * 
122      * @param table the table to delete from
123      * 
124      * @param deleteSingle the TDelete to delete
125      */
126     public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
127 
128     /**
129      * Bulk commit a List of TDeletes to the table.
130      * 
131      * This returns a list of TDeletes that were not
132      * executed. So if everything succeeds you'll
133      * receive an empty list.
134      * 
135      * @param table the table to delete from
136      * 
137      * @param deletes list of TDeletes to delete
138      */
139     public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException;
140 
141     /**
142      * Atomically checks if a row/family/qualifier value matches the expected
143      * value. If it does, it adds the delete.
144      * 
145      * @return true if the new delete was executed, false otherwise
146      * 
147      * @param table to check in and delete from
148      * 
149      * @param row row to check
150      * 
151      * @param family column family to check
152      * 
153      * @param qualifier column qualifier to check
154      * 
155      * @param value the expected value, if not provided the
156      * check is for the non-existence of the
157      * column in question
158      * 
159      * @param deleteSingle the TDelete to execute if the check succeeds
160      */
161     public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException;
162 
163     public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException;
164 
165     /**
166      * Get a Scanner for the provided TScan object.
167      * 
168      * @return Scanner Id to be used with other scanner procedures
169      * 
170      * @param table the table to get the Scanner for
171      * 
172      * @param scan the scan object to get a Scanner for
173      */
174     public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException;
175 
176     /**
177      * Grabs multiple rows from a Scanner.
178      * 
179      * @return Between zero and numRows TResults
180      * 
181      * @param scannerId the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
182      * 
183      * @param numRows number of rows to return
184      */
185     public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
186 
187     /**
188      * Closes the scanner. Should be called to free server side resources timely.
189      * Typically close once the scanner is not needed anymore, i.e. after looping
190      * over it to get all the required rows.
191      * 
192      * @param scannerId the Id of the Scanner to close *
193      */
194     public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException;
195 
196     /**
197      * mutateRow performs multiple mutations atomically on a single row.
198      * 
199      * @param table table to apply the mutations
200      * 
201      * @param rowMutations mutations to apply
202      */
203     public void mutateRow(ByteBuffer table, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException;
204 
205     /**
206      * Get results for the provided TScan object.
207      * This helper function opens a scanner, get the results and close the scanner.
208      * 
209      * @return between zero and numRows TResults
210      * 
211      * @param table the table to get the Scanner for
212      * 
213      * @param scan the scan object to get a Scanner for
214      * 
215      * @param numRows number of rows to return
216      */
217     public List<TResult> getScannerResults(ByteBuffer table, TScan scan, int numRows) throws TIOError, org.apache.thrift.TException;
218 
219   }
220 
221   public interface AsyncIface {
222 
223     public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.exists_call> resultHandler) throws org.apache.thrift.TException;
224 
225     public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.get_call> resultHandler) throws org.apache.thrift.TException;
226 
227     public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getMultiple_call> resultHandler) throws org.apache.thrift.TException;
228 
229     public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.put_call> resultHandler) throws org.apache.thrift.TException;
230 
231     public void checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.checkAndPut_call> resultHandler) throws org.apache.thrift.TException;
232 
233     public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.putMultiple_call> resultHandler) throws org.apache.thrift.TException;
234 
235     public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteSingle_call> resultHandler) throws org.apache.thrift.TException;
236 
237     public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteMultiple_call> resultHandler) throws org.apache.thrift.TException;
238 
239     public void checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.checkAndDelete_call> resultHandler) throws org.apache.thrift.TException;
240 
241     public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.increment_call> resultHandler) throws org.apache.thrift.TException;
242 
243     public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.openScanner_call> resultHandler) throws org.apache.thrift.TException;
244 
245     public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getScannerRows_call> resultHandler) throws org.apache.thrift.TException;
246 
247     public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.closeScanner_call> resultHandler) throws org.apache.thrift.TException;
248 
249     public void mutateRow(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.mutateRow_call> resultHandler) throws org.apache.thrift.TException;
250 
251     public void getScannerResults(ByteBuffer table, TScan scan, int numRows, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getScannerResults_call> resultHandler) throws org.apache.thrift.TException;
252 
253   }
254 
255   public static class Client extends org.apache.thrift.TServiceClient implements Iface {
256     public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
257       public Factory() {}
258       public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
259         return new Client(prot);
260       }
261       public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
262         return new Client(iprot, oprot);
263       }
264     }
265 
266     public Client(org.apache.thrift.protocol.TProtocol prot)
267     {
268       super(prot, prot);
269     }
270 
271     public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
272       super(iprot, oprot);
273     }
274 
275     public boolean exists(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
276     {
277       send_exists(table, get);
278       return recv_exists();
279     }
280 
281     public void send_exists(ByteBuffer table, TGet get) throws org.apache.thrift.TException
282     {
283       exists_args args = new exists_args();
284       args.setTable(table);
285       args.setGet(get);
286       sendBase("exists", args);
287     }
288 
289     public boolean recv_exists() throws TIOError, org.apache.thrift.TException
290     {
291       exists_result result = new exists_result();
292       receiveBase(result, "exists");
293       if (result.isSetSuccess()) {
294         return result.success;
295       }
296       if (result.io != null) {
297         throw result.io;
298       }
299       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "exists failed: unknown result");
300     }
301 
302     public TResult get(ByteBuffer table, TGet get) throws TIOError, org.apache.thrift.TException
303     {
304       send_get(table, get);
305       return recv_get();
306     }
307 
308     public void send_get(ByteBuffer table, TGet get) throws org.apache.thrift.TException
309     {
310       get_args args = new get_args();
311       args.setTable(table);
312       args.setGet(get);
313       sendBase("get", args);
314     }
315 
316     public TResult recv_get() throws TIOError, org.apache.thrift.TException
317     {
318       get_result result = new get_result();
319       receiveBase(result, "get");
320       if (result.isSetSuccess()) {
321         return result.success;
322       }
323       if (result.io != null) {
324         throw result.io;
325       }
326       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get failed: unknown result");
327     }
328 
329     public List<TResult> getMultiple(ByteBuffer table, List<TGet> gets) throws TIOError, org.apache.thrift.TException
330     {
331       send_getMultiple(table, gets);
332       return recv_getMultiple();
333     }
334 
335     public void send_getMultiple(ByteBuffer table, List<TGet> gets) throws org.apache.thrift.TException
336     {
337       getMultiple_args args = new getMultiple_args();
338       args.setTable(table);
339       args.setGets(gets);
340       sendBase("getMultiple", args);
341     }
342 
343     public List<TResult> recv_getMultiple() throws TIOError, org.apache.thrift.TException
344     {
345       getMultiple_result result = new getMultiple_result();
346       receiveBase(result, "getMultiple");
347       if (result.isSetSuccess()) {
348         return result.success;
349       }
350       if (result.io != null) {
351         throw result.io;
352       }
353       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getMultiple failed: unknown result");
354     }
355 
356     public void put(ByteBuffer table, TPut put) throws TIOError, org.apache.thrift.TException
357     {
358       send_put(table, put);
359       recv_put();
360     }
361 
362     public void send_put(ByteBuffer table, TPut put) throws org.apache.thrift.TException
363     {
364       put_args args = new put_args();
365       args.setTable(table);
366       args.setPut(put);
367       sendBase("put", args);
368     }
369 
370     public void recv_put() throws TIOError, org.apache.thrift.TException
371     {
372       put_result result = new put_result();
373       receiveBase(result, "put");
374       if (result.io != null) {
375         throw result.io;
376       }
377       return;
378     }
379 
380     public boolean checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws TIOError, org.apache.thrift.TException
381     {
382       send_checkAndPut(table, row, family, qualifier, value, put);
383       return recv_checkAndPut();
384     }
385 
386     public void send_checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put) throws org.apache.thrift.TException
387     {
388       checkAndPut_args args = new checkAndPut_args();
389       args.setTable(table);
390       args.setRow(row);
391       args.setFamily(family);
392       args.setQualifier(qualifier);
393       args.setValue(value);
394       args.setPut(put);
395       sendBase("checkAndPut", args);
396     }
397 
398     public boolean recv_checkAndPut() throws TIOError, org.apache.thrift.TException
399     {
400       checkAndPut_result result = new checkAndPut_result();
401       receiveBase(result, "checkAndPut");
402       if (result.isSetSuccess()) {
403         return result.success;
404       }
405       if (result.io != null) {
406         throw result.io;
407       }
408       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndPut failed: unknown result");
409     }
410 
411     public void putMultiple(ByteBuffer table, List<TPut> puts) throws TIOError, org.apache.thrift.TException
412     {
413       send_putMultiple(table, puts);
414       recv_putMultiple();
415     }
416 
417     public void send_putMultiple(ByteBuffer table, List<TPut> puts) throws org.apache.thrift.TException
418     {
419       putMultiple_args args = new putMultiple_args();
420       args.setTable(table);
421       args.setPuts(puts);
422       sendBase("putMultiple", args);
423     }
424 
425     public void recv_putMultiple() throws TIOError, org.apache.thrift.TException
426     {
427       putMultiple_result result = new putMultiple_result();
428       receiveBase(result, "putMultiple");
429       if (result.io != null) {
430         throw result.io;
431       }
432       return;
433     }
434 
435     public void deleteSingle(ByteBuffer table, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
436     {
437       send_deleteSingle(table, deleteSingle);
438       recv_deleteSingle();
439     }
440 
441     public void send_deleteSingle(ByteBuffer table, TDelete deleteSingle) throws org.apache.thrift.TException
442     {
443       deleteSingle_args args = new deleteSingle_args();
444       args.setTable(table);
445       args.setDeleteSingle(deleteSingle);
446       sendBase("deleteSingle", args);
447     }
448 
449     public void recv_deleteSingle() throws TIOError, org.apache.thrift.TException
450     {
451       deleteSingle_result result = new deleteSingle_result();
452       receiveBase(result, "deleteSingle");
453       if (result.io != null) {
454         throw result.io;
455       }
456       return;
457     }
458 
459     public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError, org.apache.thrift.TException
460     {
461       send_deleteMultiple(table, deletes);
462       return recv_deleteMultiple();
463     }
464 
465     public void send_deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws org.apache.thrift.TException
466     {
467       deleteMultiple_args args = new deleteMultiple_args();
468       args.setTable(table);
469       args.setDeletes(deletes);
470       sendBase("deleteMultiple", args);
471     }
472 
473     public List<TDelete> recv_deleteMultiple() throws TIOError, org.apache.thrift.TException
474     {
475       deleteMultiple_result result = new deleteMultiple_result();
476       receiveBase(result, "deleteMultiple");
477       if (result.isSetSuccess()) {
478         return result.success;
479       }
480       if (result.io != null) {
481         throw result.io;
482       }
483       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "deleteMultiple failed: unknown result");
484     }
485 
486     public boolean checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws TIOError, org.apache.thrift.TException
487     {
488       send_checkAndDelete(table, row, family, qualifier, value, deleteSingle);
489       return recv_checkAndDelete();
490     }
491 
492     public void send_checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle) throws org.apache.thrift.TException
493     {
494       checkAndDelete_args args = new checkAndDelete_args();
495       args.setTable(table);
496       args.setRow(row);
497       args.setFamily(family);
498       args.setQualifier(qualifier);
499       args.setValue(value);
500       args.setDeleteSingle(deleteSingle);
501       sendBase("checkAndDelete", args);
502     }
503 
504     public boolean recv_checkAndDelete() throws TIOError, org.apache.thrift.TException
505     {
506       checkAndDelete_result result = new checkAndDelete_result();
507       receiveBase(result, "checkAndDelete");
508       if (result.isSetSuccess()) {
509         return result.success;
510       }
511       if (result.io != null) {
512         throw result.io;
513       }
514       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkAndDelete failed: unknown result");
515     }
516 
517     public TResult increment(ByteBuffer table, TIncrement increment) throws TIOError, org.apache.thrift.TException
518     {
519       send_increment(table, increment);
520       return recv_increment();
521     }
522 
523     public void send_increment(ByteBuffer table, TIncrement increment) throws org.apache.thrift.TException
524     {
525       increment_args args = new increment_args();
526       args.setTable(table);
527       args.setIncrement(increment);
528       sendBase("increment", args);
529     }
530 
531     public TResult recv_increment() throws TIOError, org.apache.thrift.TException
532     {
533       increment_result result = new increment_result();
534       receiveBase(result, "increment");
535       if (result.isSetSuccess()) {
536         return result.success;
537       }
538       if (result.io != null) {
539         throw result.io;
540       }
541       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "increment failed: unknown result");
542     }
543 
544     public int openScanner(ByteBuffer table, TScan scan) throws TIOError, org.apache.thrift.TException
545     {
546       send_openScanner(table, scan);
547       return recv_openScanner();
548     }
549 
550     public void send_openScanner(ByteBuffer table, TScan scan) throws org.apache.thrift.TException
551     {
552       openScanner_args args = new openScanner_args();
553       args.setTable(table);
554       args.setScan(scan);
555       sendBase("openScanner", args);
556     }
557 
558     public int recv_openScanner() throws TIOError, org.apache.thrift.TException
559     {
560       openScanner_result result = new openScanner_result();
561       receiveBase(result, "openScanner");
562       if (result.isSetSuccess()) {
563         return result.success;
564       }
565       if (result.io != null) {
566         throw result.io;
567       }
568       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "openScanner failed: unknown result");
569     }
570 
571     public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, org.apache.thrift.TException
572     {
573       send_getScannerRows(scannerId, numRows);
574       return recv_getScannerRows();
575     }
576 
577     public void send_getScannerRows(int scannerId, int numRows) throws org.apache.thrift.TException
578     {
579       getScannerRows_args args = new getScannerRows_args();
580       args.setScannerId(scannerId);
581       args.setNumRows(numRows);
582       sendBase("getScannerRows", args);
583     }
584 
585     public List<TResult> recv_getScannerRows() throws TIOError, TIllegalArgument, org.apache.thrift.TException
586     {
587       getScannerRows_result result = new getScannerRows_result();
588       receiveBase(result, "getScannerRows");
589       if (result.isSetSuccess()) {
590         return result.success;
591       }
592       if (result.io != null) {
593         throw result.io;
594       }
595       if (result.ia != null) {
596         throw result.ia;
597       }
598       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerRows failed: unknown result");
599     }
600 
601     public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, org.apache.thrift.TException
602     {
603       send_closeScanner(scannerId);
604       recv_closeScanner();
605     }
606 
607     public void send_closeScanner(int scannerId) throws org.apache.thrift.TException
608     {
609       closeScanner_args args = new closeScanner_args();
610       args.setScannerId(scannerId);
611       sendBase("closeScanner", args);
612     }
613 
614     public void recv_closeScanner() throws TIOError, TIllegalArgument, org.apache.thrift.TException
615     {
616       closeScanner_result result = new closeScanner_result();
617       receiveBase(result, "closeScanner");
618       if (result.io != null) {
619         throw result.io;
620       }
621       if (result.ia != null) {
622         throw result.ia;
623       }
624       return;
625     }
626 
627     public void mutateRow(ByteBuffer table, TRowMutations rowMutations) throws TIOError, org.apache.thrift.TException
628     {
629       send_mutateRow(table, rowMutations);
630       recv_mutateRow();
631     }
632 
633     public void send_mutateRow(ByteBuffer table, TRowMutations rowMutations) throws org.apache.thrift.TException
634     {
635       mutateRow_args args = new mutateRow_args();
636       args.setTable(table);
637       args.setRowMutations(rowMutations);
638       sendBase("mutateRow", args);
639     }
640 
641     public void recv_mutateRow() throws TIOError, org.apache.thrift.TException
642     {
643       mutateRow_result result = new mutateRow_result();
644       receiveBase(result, "mutateRow");
645       if (result.io != null) {
646         throw result.io;
647       }
648       return;
649     }
650 
651     public List<TResult> getScannerResults(ByteBuffer table, TScan scan, int numRows) throws TIOError, org.apache.thrift.TException
652     {
653       send_getScannerResults(table, scan, numRows);
654       return recv_getScannerResults();
655     }
656 
657     public void send_getScannerResults(ByteBuffer table, TScan scan, int numRows) throws org.apache.thrift.TException
658     {
659       getScannerResults_args args = new getScannerResults_args();
660       args.setTable(table);
661       args.setScan(scan);
662       args.setNumRows(numRows);
663       sendBase("getScannerResults", args);
664     }
665 
666     public List<TResult> recv_getScannerResults() throws TIOError, org.apache.thrift.TException
667     {
668       getScannerResults_result result = new getScannerResults_result();
669       receiveBase(result, "getScannerResults");
670       if (result.isSetSuccess()) {
671         return result.success;
672       }
673       if (result.io != null) {
674         throw result.io;
675       }
676       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getScannerResults failed: unknown result");
677     }
678 
679   }
680   public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
681     public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
682       private org.apache.thrift.async.TAsyncClientManager clientManager;
683       private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
684       public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) {
685         this.clientManager = clientManager;
686         this.protocolFactory = protocolFactory;
687       }
688       public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) {
689         return new AsyncClient(protocolFactory, clientManager, transport);
690       }
691     }
692 
693     public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) {
694       super(protocolFactory, clientManager, transport);
695     }
696 
697     public void exists(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<exists_call> resultHandler) throws org.apache.thrift.TException {
698       checkReady();
699       exists_call method_call = new exists_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
700       this.___currentMethod = method_call;
701       ___manager.call(method_call);
702     }
703 
704     public static class exists_call extends org.apache.thrift.async.TAsyncMethodCall {
705       private ByteBuffer table;
706       private TGet get;
707       public exists_call(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<exists_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
708         super(client, protocolFactory, transport, resultHandler, false);
709         this.table = table;
710         this.get = get;
711       }
712 
713       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
714         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("exists", org.apache.thrift.protocol.TMessageType.CALL, 0));
715         exists_args args = new exists_args();
716         args.setTable(table);
717         args.setGet(get);
718         args.write(prot);
719         prot.writeMessageEnd();
720       }
721 
722       public boolean getResult() throws TIOError, org.apache.thrift.TException {
723         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
724           throw new IllegalStateException("Method call not finished!");
725         }
726         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
727         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
728         return (new Client(prot)).recv_exists();
729       }
730     }
731 
732     public void get(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<get_call> resultHandler) throws org.apache.thrift.TException {
733       checkReady();
734       get_call method_call = new get_call(table, get, resultHandler, this, ___protocolFactory, ___transport);
735       this.___currentMethod = method_call;
736       ___manager.call(method_call);
737     }
738 
739     public static class get_call extends org.apache.thrift.async.TAsyncMethodCall {
740       private ByteBuffer table;
741       private TGet get;
742       public get_call(ByteBuffer table, TGet get, org.apache.thrift.async.AsyncMethodCallback<get_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
743         super(client, protocolFactory, transport, resultHandler, false);
744         this.table = table;
745         this.get = get;
746       }
747 
748       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
749         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get", org.apache.thrift.protocol.TMessageType.CALL, 0));
750         get_args args = new get_args();
751         args.setTable(table);
752         args.setGet(get);
753         args.write(prot);
754         prot.writeMessageEnd();
755       }
756 
757       public TResult getResult() throws TIOError, org.apache.thrift.TException {
758         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
759           throw new IllegalStateException("Method call not finished!");
760         }
761         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
762         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
763         return (new Client(prot)).recv_get();
764       }
765     }
766 
767     public void getMultiple(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<getMultiple_call> resultHandler) throws org.apache.thrift.TException {
768       checkReady();
769       getMultiple_call method_call = new getMultiple_call(table, gets, resultHandler, this, ___protocolFactory, ___transport);
770       this.___currentMethod = method_call;
771       ___manager.call(method_call);
772     }
773 
774     public static class getMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
775       private ByteBuffer table;
776       private List<TGet> gets;
777       public getMultiple_call(ByteBuffer table, List<TGet> gets, org.apache.thrift.async.AsyncMethodCallback<getMultiple_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
778         super(client, protocolFactory, transport, resultHandler, false);
779         this.table = table;
780         this.gets = gets;
781       }
782 
783       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
784         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
785         getMultiple_args args = new getMultiple_args();
786         args.setTable(table);
787         args.setGets(gets);
788         args.write(prot);
789         prot.writeMessageEnd();
790       }
791 
792       public List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
793         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
794           throw new IllegalStateException("Method call not finished!");
795         }
796         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
797         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
798         return (new Client(prot)).recv_getMultiple();
799       }
800     }
801 
802     public void put(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<put_call> resultHandler) throws org.apache.thrift.TException {
803       checkReady();
804       put_call method_call = new put_call(table, put, resultHandler, this, ___protocolFactory, ___transport);
805       this.___currentMethod = method_call;
806       ___manager.call(method_call);
807     }
808 
809     public static class put_call extends org.apache.thrift.async.TAsyncMethodCall {
810       private ByteBuffer table;
811       private TPut put;
812       public put_call(ByteBuffer table, TPut put, org.apache.thrift.async.AsyncMethodCallback<put_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
813         super(client, protocolFactory, transport, resultHandler, false);
814         this.table = table;
815         this.put = put;
816       }
817 
818       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
819         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("put", org.apache.thrift.protocol.TMessageType.CALL, 0));
820         put_args args = new put_args();
821         args.setTable(table);
822         args.setPut(put);
823         args.write(prot);
824         prot.writeMessageEnd();
825       }
826 
827       public void getResult() throws TIOError, org.apache.thrift.TException {
828         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
829           throw new IllegalStateException("Method call not finished!");
830         }
831         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
832         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
833         (new Client(prot)).recv_put();
834       }
835     }
836 
837     public void checkAndPut(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put, org.apache.thrift.async.AsyncMethodCallback<checkAndPut_call> resultHandler) throws org.apache.thrift.TException {
838       checkReady();
839       checkAndPut_call method_call = new checkAndPut_call(table, row, family, qualifier, value, put, resultHandler, this, ___protocolFactory, ___transport);
840       this.___currentMethod = method_call;
841       ___manager.call(method_call);
842     }
843 
844     public static class checkAndPut_call extends org.apache.thrift.async.TAsyncMethodCall {
845       private ByteBuffer table;
846       private ByteBuffer row;
847       private ByteBuffer family;
848       private ByteBuffer qualifier;
849       private ByteBuffer value;
850       private TPut put;
851       public checkAndPut_call(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TPut put, org.apache.thrift.async.AsyncMethodCallback<checkAndPut_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
852         super(client, protocolFactory, transport, resultHandler, false);
853         this.table = table;
854         this.row = row;
855         this.family = family;
856         this.qualifier = qualifier;
857         this.value = value;
858         this.put = put;
859       }
860 
861       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
862         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndPut", org.apache.thrift.protocol.TMessageType.CALL, 0));
863         checkAndPut_args args = new checkAndPut_args();
864         args.setTable(table);
865         args.setRow(row);
866         args.setFamily(family);
867         args.setQualifier(qualifier);
868         args.setValue(value);
869         args.setPut(put);
870         args.write(prot);
871         prot.writeMessageEnd();
872       }
873 
874       public boolean getResult() throws TIOError, org.apache.thrift.TException {
875         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
876           throw new IllegalStateException("Method call not finished!");
877         }
878         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
879         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
880         return (new Client(prot)).recv_checkAndPut();
881       }
882     }
883 
884     public void putMultiple(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<putMultiple_call> resultHandler) throws org.apache.thrift.TException {
885       checkReady();
886       putMultiple_call method_call = new putMultiple_call(table, puts, resultHandler, this, ___protocolFactory, ___transport);
887       this.___currentMethod = method_call;
888       ___manager.call(method_call);
889     }
890 
891     public static class putMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
892       private ByteBuffer table;
893       private List<TPut> puts;
894       public putMultiple_call(ByteBuffer table, List<TPut> puts, org.apache.thrift.async.AsyncMethodCallback<putMultiple_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
895         super(client, protocolFactory, transport, resultHandler, false);
896         this.table = table;
897         this.puts = puts;
898       }
899 
900       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
901         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("putMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
902         putMultiple_args args = new putMultiple_args();
903         args.setTable(table);
904         args.setPuts(puts);
905         args.write(prot);
906         prot.writeMessageEnd();
907       }
908 
909       public void getResult() throws TIOError, org.apache.thrift.TException {
910         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
911           throw new IllegalStateException("Method call not finished!");
912         }
913         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
914         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
915         (new Client(prot)).recv_putMultiple();
916       }
917     }
918 
919     public void deleteSingle(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<deleteSingle_call> resultHandler) throws org.apache.thrift.TException {
920       checkReady();
921       deleteSingle_call method_call = new deleteSingle_call(table, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
922       this.___currentMethod = method_call;
923       ___manager.call(method_call);
924     }
925 
926     public static class deleteSingle_call extends org.apache.thrift.async.TAsyncMethodCall {
927       private ByteBuffer table;
928       private TDelete deleteSingle;
929       public deleteSingle_call(ByteBuffer table, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<deleteSingle_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
930         super(client, protocolFactory, transport, resultHandler, false);
931         this.table = table;
932         this.deleteSingle = deleteSingle;
933       }
934 
935       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
936         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteSingle", org.apache.thrift.protocol.TMessageType.CALL, 0));
937         deleteSingle_args args = new deleteSingle_args();
938         args.setTable(table);
939         args.setDeleteSingle(deleteSingle);
940         args.write(prot);
941         prot.writeMessageEnd();
942       }
943 
944       public void getResult() throws TIOError, org.apache.thrift.TException {
945         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
946           throw new IllegalStateException("Method call not finished!");
947         }
948         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
949         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
950         (new Client(prot)).recv_deleteSingle();
951       }
952     }
953 
954     public void deleteMultiple(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<deleteMultiple_call> resultHandler) throws org.apache.thrift.TException {
955       checkReady();
956       deleteMultiple_call method_call = new deleteMultiple_call(table, deletes, resultHandler, this, ___protocolFactory, ___transport);
957       this.___currentMethod = method_call;
958       ___manager.call(method_call);
959     }
960 
961     public static class deleteMultiple_call extends org.apache.thrift.async.TAsyncMethodCall {
962       private ByteBuffer table;
963       private List<TDelete> deletes;
964       public deleteMultiple_call(ByteBuffer table, List<TDelete> deletes, org.apache.thrift.async.AsyncMethodCallback<deleteMultiple_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
965         super(client, protocolFactory, transport, resultHandler, false);
966         this.table = table;
967         this.deletes = deletes;
968       }
969 
970       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
971         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteMultiple", org.apache.thrift.protocol.TMessageType.CALL, 0));
972         deleteMultiple_args args = new deleteMultiple_args();
973         args.setTable(table);
974         args.setDeletes(deletes);
975         args.write(prot);
976         prot.writeMessageEnd();
977       }
978 
979       public List<TDelete> getResult() throws TIOError, org.apache.thrift.TException {
980         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
981           throw new IllegalStateException("Method call not finished!");
982         }
983         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
984         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
985         return (new Client(prot)).recv_deleteMultiple();
986       }
987     }
988 
989     public void checkAndDelete(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<checkAndDelete_call> resultHandler) throws org.apache.thrift.TException {
990       checkReady();
991       checkAndDelete_call method_call = new checkAndDelete_call(table, row, family, qualifier, value, deleteSingle, resultHandler, this, ___protocolFactory, ___transport);
992       this.___currentMethod = method_call;
993       ___manager.call(method_call);
994     }
995 
996     public static class checkAndDelete_call extends org.apache.thrift.async.TAsyncMethodCall {
997       private ByteBuffer table;
998       private ByteBuffer row;
999       private ByteBuffer family;
1000       private ByteBuffer qualifier;
1001       private ByteBuffer value;
1002       private TDelete deleteSingle;
1003       public checkAndDelete_call(ByteBuffer table, ByteBuffer row, ByteBuffer family, ByteBuffer qualifier, ByteBuffer value, TDelete deleteSingle, org.apache.thrift.async.AsyncMethodCallback<checkAndDelete_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1004         super(client, protocolFactory, transport, resultHandler, false);
1005         this.table = table;
1006         this.row = row;
1007         this.family = family;
1008         this.qualifier = qualifier;
1009         this.value = value;
1010         this.deleteSingle = deleteSingle;
1011       }
1012 
1013       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1014         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkAndDelete", org.apache.thrift.protocol.TMessageType.CALL, 0));
1015         checkAndDelete_args args = new checkAndDelete_args();
1016         args.setTable(table);
1017         args.setRow(row);
1018         args.setFamily(family);
1019         args.setQualifier(qualifier);
1020         args.setValue(value);
1021         args.setDeleteSingle(deleteSingle);
1022         args.write(prot);
1023         prot.writeMessageEnd();
1024       }
1025 
1026       public boolean getResult() throws TIOError, org.apache.thrift.TException {
1027         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1028           throw new IllegalStateException("Method call not finished!");
1029         }
1030         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1031         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1032         return (new Client(prot)).recv_checkAndDelete();
1033       }
1034     }
1035 
1036     public void increment(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<increment_call> resultHandler) throws org.apache.thrift.TException {
1037       checkReady();
1038       increment_call method_call = new increment_call(table, increment, resultHandler, this, ___protocolFactory, ___transport);
1039       this.___currentMethod = method_call;
1040       ___manager.call(method_call);
1041     }
1042 
1043     public static class increment_call extends org.apache.thrift.async.TAsyncMethodCall {
1044       private ByteBuffer table;
1045       private TIncrement increment;
1046       public increment_call(ByteBuffer table, TIncrement increment, org.apache.thrift.async.AsyncMethodCallback<increment_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1047         super(client, protocolFactory, transport, resultHandler, false);
1048         this.table = table;
1049         this.increment = increment;
1050       }
1051 
1052       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1053         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("increment", org.apache.thrift.protocol.TMessageType.CALL, 0));
1054         increment_args args = new increment_args();
1055         args.setTable(table);
1056         args.setIncrement(increment);
1057         args.write(prot);
1058         prot.writeMessageEnd();
1059       }
1060 
1061       public TResult getResult() throws TIOError, org.apache.thrift.TException {
1062         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1063           throw new IllegalStateException("Method call not finished!");
1064         }
1065         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1066         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1067         return (new Client(prot)).recv_increment();
1068       }
1069     }
1070 
1071     public void openScanner(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<openScanner_call> resultHandler) throws org.apache.thrift.TException {
1072       checkReady();
1073       openScanner_call method_call = new openScanner_call(table, scan, resultHandler, this, ___protocolFactory, ___transport);
1074       this.___currentMethod = method_call;
1075       ___manager.call(method_call);
1076     }
1077 
1078     public static class openScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1079       private ByteBuffer table;
1080       private TScan scan;
1081       public openScanner_call(ByteBuffer table, TScan scan, org.apache.thrift.async.AsyncMethodCallback<openScanner_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1082         super(client, protocolFactory, transport, resultHandler, false);
1083         this.table = table;
1084         this.scan = scan;
1085       }
1086 
1087       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1088         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("openScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1089         openScanner_args args = new openScanner_args();
1090         args.setTable(table);
1091         args.setScan(scan);
1092         args.write(prot);
1093         prot.writeMessageEnd();
1094       }
1095 
1096       public int getResult() throws TIOError, org.apache.thrift.TException {
1097         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1098           throw new IllegalStateException("Method call not finished!");
1099         }
1100         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1101         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1102         return (new Client(prot)).recv_openScanner();
1103       }
1104     }
1105 
1106     public void getScannerRows(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerRows_call> resultHandler) throws org.apache.thrift.TException {
1107       checkReady();
1108       getScannerRows_call method_call = new getScannerRows_call(scannerId, numRows, resultHandler, this, ___protocolFactory, ___transport);
1109       this.___currentMethod = method_call;
1110       ___manager.call(method_call);
1111     }
1112 
1113     public static class getScannerRows_call extends org.apache.thrift.async.TAsyncMethodCall {
1114       private int scannerId;
1115       private int numRows;
1116       public getScannerRows_call(int scannerId, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerRows_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1117         super(client, protocolFactory, transport, resultHandler, false);
1118         this.scannerId = scannerId;
1119         this.numRows = numRows;
1120       }
1121 
1122       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1123         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerRows", org.apache.thrift.protocol.TMessageType.CALL, 0));
1124         getScannerRows_args args = new getScannerRows_args();
1125         args.setScannerId(scannerId);
1126         args.setNumRows(numRows);
1127         args.write(prot);
1128         prot.writeMessageEnd();
1129       }
1130 
1131       public List<TResult> getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1132         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1133           throw new IllegalStateException("Method call not finished!");
1134         }
1135         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1136         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1137         return (new Client(prot)).recv_getScannerRows();
1138       }
1139     }
1140 
1141     public void closeScanner(int scannerId, org.apache.thrift.async.AsyncMethodCallback<closeScanner_call> resultHandler) throws org.apache.thrift.TException {
1142       checkReady();
1143       closeScanner_call method_call = new closeScanner_call(scannerId, resultHandler, this, ___protocolFactory, ___transport);
1144       this.___currentMethod = method_call;
1145       ___manager.call(method_call);
1146     }
1147 
1148     public static class closeScanner_call extends org.apache.thrift.async.TAsyncMethodCall {
1149       private int scannerId;
1150       public closeScanner_call(int scannerId, org.apache.thrift.async.AsyncMethodCallback<closeScanner_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1151         super(client, protocolFactory, transport, resultHandler, false);
1152         this.scannerId = scannerId;
1153       }
1154 
1155       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1156         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("closeScanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
1157         closeScanner_args args = new closeScanner_args();
1158         args.setScannerId(scannerId);
1159         args.write(prot);
1160         prot.writeMessageEnd();
1161       }
1162 
1163       public void getResult() throws TIOError, TIllegalArgument, org.apache.thrift.TException {
1164         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1165           throw new IllegalStateException("Method call not finished!");
1166         }
1167         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1168         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1169         (new Client(prot)).recv_closeScanner();
1170       }
1171     }
1172 
1173     public void mutateRow(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<mutateRow_call> resultHandler) throws org.apache.thrift.TException {
1174       checkReady();
1175       mutateRow_call method_call = new mutateRow_call(table, rowMutations, resultHandler, this, ___protocolFactory, ___transport);
1176       this.___currentMethod = method_call;
1177       ___manager.call(method_call);
1178     }
1179 
1180     public static class mutateRow_call extends org.apache.thrift.async.TAsyncMethodCall {
1181       private ByteBuffer table;
1182       private TRowMutations rowMutations;
1183       public mutateRow_call(ByteBuffer table, TRowMutations rowMutations, org.apache.thrift.async.AsyncMethodCallback<mutateRow_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1184         super(client, protocolFactory, transport, resultHandler, false);
1185         this.table = table;
1186         this.rowMutations = rowMutations;
1187       }
1188 
1189       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1190         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("mutateRow", org.apache.thrift.protocol.TMessageType.CALL, 0));
1191         mutateRow_args args = new mutateRow_args();
1192         args.setTable(table);
1193         args.setRowMutations(rowMutations);
1194         args.write(prot);
1195         prot.writeMessageEnd();
1196       }
1197 
1198       public void getResult() throws TIOError, org.apache.thrift.TException {
1199         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1200           throw new IllegalStateException("Method call not finished!");
1201         }
1202         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1203         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1204         (new Client(prot)).recv_mutateRow();
1205       }
1206     }
1207 
1208     public void getScannerResults(ByteBuffer table, TScan scan, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerResults_call> resultHandler) throws org.apache.thrift.TException {
1209       checkReady();
1210       getScannerResults_call method_call = new getScannerResults_call(table, scan, numRows, resultHandler, this, ___protocolFactory, ___transport);
1211       this.___currentMethod = method_call;
1212       ___manager.call(method_call);
1213     }
1214 
1215     public static class getScannerResults_call extends org.apache.thrift.async.TAsyncMethodCall {
1216       private ByteBuffer table;
1217       private TScan scan;
1218       private int numRows;
1219       public getScannerResults_call(ByteBuffer table, TScan scan, int numRows, org.apache.thrift.async.AsyncMethodCallback<getScannerResults_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
1220         super(client, protocolFactory, transport, resultHandler, false);
1221         this.table = table;
1222         this.scan = scan;
1223         this.numRows = numRows;
1224       }
1225 
1226       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
1227         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getScannerResults", org.apache.thrift.protocol.TMessageType.CALL, 0));
1228         getScannerResults_args args = new getScannerResults_args();
1229         args.setTable(table);
1230         args.setScan(scan);
1231         args.setNumRows(numRows);
1232         args.write(prot);
1233         prot.writeMessageEnd();
1234       }
1235 
1236       public List<TResult> getResult() throws TIOError, org.apache.thrift.TException {
1237         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
1238           throw new IllegalStateException("Method call not finished!");
1239         }
1240         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
1241         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
1242         return (new Client(prot)).recv_getScannerResults();
1243       }
1244     }
1245 
1246   }
1247 
1248   public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
1249     private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1250     public Processor(I iface) {
1251       super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
1252     }
1253 
1254     protected Processor(I iface, Map<String,  org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> processMap) {
1255       super(iface, getProcessMap(processMap));
1256     }
1257 
1258     private static <I extends Iface> Map<String,  org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> getProcessMap(Map<String,  org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> processMap) {
1259       processMap.put("exists", new exists());
1260       processMap.put("get", new get());
1261       processMap.put("getMultiple", new getMultiple());
1262       processMap.put("put", new put());
1263       processMap.put("checkAndPut", new checkAndPut());
1264       processMap.put("putMultiple", new putMultiple());
1265       processMap.put("deleteSingle", new deleteSingle());
1266       processMap.put("deleteMultiple", new deleteMultiple());
1267       processMap.put("checkAndDelete", new checkAndDelete());
1268       processMap.put("increment", new increment());
1269       processMap.put("openScanner", new openScanner());
1270       processMap.put("getScannerRows", new getScannerRows());
1271       processMap.put("closeScanner", new closeScanner());
1272       processMap.put("mutateRow", new mutateRow());
1273       processMap.put("getScannerResults", new getScannerResults());
1274       return processMap;
1275     }
1276 
1277     private static class exists<I extends Iface> extends org.apache.thrift.ProcessFunction<I, exists_args> {
1278       public exists() {
1279         super("exists");
1280       }
1281 
1282       protected exists_args getEmptyArgsInstance() {
1283         return new exists_args();
1284       }
1285 
1286       protected exists_result getResult(I iface, exists_args args) throws org.apache.thrift.TException {
1287         exists_result result = new exists_result();
1288         try {
1289           result.success = iface.exists(args.table, args.get);
1290           result.setSuccessIsSet(true);
1291         } catch (TIOError io) {
1292           result.io = io;
1293         }
1294         return result;
1295       }
1296     }
1297 
1298     private static class get<I extends Iface> extends org.apache.thrift.ProcessFunction<I, get_args> {
1299       public get() {
1300         super("get");
1301       }
1302 
1303       protected get_args getEmptyArgsInstance() {
1304         return new get_args();
1305       }
1306 
1307       protected get_result getResult(I iface, get_args args) throws org.apache.thrift.TException {
1308         get_result result = new get_result();
1309         try {
1310           result.success = iface.get(args.table, args.get);
1311         } catch (TIOError io) {
1312           result.io = io;
1313         }
1314         return result;
1315       }
1316     }
1317 
1318     private static class getMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getMultiple_args> {
1319       public getMultiple() {
1320         super("getMultiple");
1321       }
1322 
1323       protected getMultiple_args getEmptyArgsInstance() {
1324         return new getMultiple_args();
1325       }
1326 
1327       protected getMultiple_result getResult(I iface, getMultiple_args args) throws org.apache.thrift.TException {
1328         getMultiple_result result = new getMultiple_result();
1329         try {
1330           result.success = iface.getMultiple(args.table, args.gets);
1331         } catch (TIOError io) {
1332           result.io = io;
1333         }
1334         return result;
1335       }
1336     }
1337 
1338     private static class put<I extends Iface> extends org.apache.thrift.ProcessFunction<I, put_args> {
1339       public put() {
1340         super("put");
1341       }
1342 
1343       protected put_args getEmptyArgsInstance() {
1344         return new put_args();
1345       }
1346 
1347       protected put_result getResult(I iface, put_args args) throws org.apache.thrift.TException {
1348         put_result result = new put_result();
1349         try {
1350           iface.put(args.table, args.put);
1351         } catch (TIOError io) {
1352           result.io = io;
1353         }
1354         return result;
1355       }
1356     }
1357 
1358     private static class checkAndPut<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndPut_args> {
1359       public checkAndPut() {
1360         super("checkAndPut");
1361       }
1362 
1363       protected checkAndPut_args getEmptyArgsInstance() {
1364         return new checkAndPut_args();
1365       }
1366 
1367       protected checkAndPut_result getResult(I iface, checkAndPut_args args) throws org.apache.thrift.TException {
1368         checkAndPut_result result = new checkAndPut_result();
1369         try {
1370           result.success = iface.checkAndPut(args.table, args.row, args.family, args.qualifier, args.value, args.put);
1371           result.setSuccessIsSet(true);
1372         } catch (TIOError io) {
1373           result.io = io;
1374         }
1375         return result;
1376       }
1377     }
1378 
1379     private static class putMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, putMultiple_args> {
1380       public putMultiple() {
1381         super("putMultiple");
1382       }
1383 
1384       protected putMultiple_args getEmptyArgsInstance() {
1385         return new putMultiple_args();
1386       }
1387 
1388       protected putMultiple_result getResult(I iface, putMultiple_args args) throws org.apache.thrift.TException {
1389         putMultiple_result result = new putMultiple_result();
1390         try {
1391           iface.putMultiple(args.table, args.puts);
1392         } catch (TIOError io) {
1393           result.io = io;
1394         }
1395         return result;
1396       }
1397     }
1398 
1399     private static class deleteSingle<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteSingle_args> {
1400       public deleteSingle() {
1401         super("deleteSingle");
1402       }
1403 
1404       protected deleteSingle_args getEmptyArgsInstance() {
1405         return new deleteSingle_args();
1406       }
1407 
1408       protected deleteSingle_result getResult(I iface, deleteSingle_args args) throws org.apache.thrift.TException {
1409         deleteSingle_result result = new deleteSingle_result();
1410         try {
1411           iface.deleteSingle(args.table, args.deleteSingle);
1412         } catch (TIOError io) {
1413           result.io = io;
1414         }
1415         return result;
1416       }
1417     }
1418 
1419     private static class deleteMultiple<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteMultiple_args> {
1420       public deleteMultiple() {
1421         super("deleteMultiple");
1422       }
1423 
1424       protected deleteMultiple_args getEmptyArgsInstance() {
1425         return new deleteMultiple_args();
1426       }
1427 
1428       protected deleteMultiple_result getResult(I iface, deleteMultiple_args args) throws org.apache.thrift.TException {
1429         deleteMultiple_result result = new deleteMultiple_result();
1430         try {
1431           result.success = iface.deleteMultiple(args.table, args.deletes);
1432         } catch (TIOError io) {
1433           result.io = io;
1434         }
1435         return result;
1436       }
1437     }
1438 
1439     private static class checkAndDelete<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkAndDelete_args> {
1440       public checkAndDelete() {
1441         super("checkAndDelete");
1442       }
1443 
1444       protected checkAndDelete_args getEmptyArgsInstance() {
1445         return new checkAndDelete_args();
1446       }
1447 
1448       protected checkAndDelete_result getResult(I iface, checkAndDelete_args args) throws org.apache.thrift.TException {
1449         checkAndDelete_result result = new checkAndDelete_result();
1450         try {
1451           result.success = iface.checkAndDelete(args.table, args.row, args.family, args.qualifier, args.value, args.deleteSingle);
1452           result.setSuccessIsSet(true);
1453         } catch (TIOError io) {
1454           result.io = io;
1455         }
1456         return result;
1457       }
1458     }
1459 
1460     private static class increment<I extends Iface> extends org.apache.thrift.ProcessFunction<I, increment_args> {
1461       public increment() {
1462         super("increment");
1463       }
1464 
1465       protected increment_args getEmptyArgsInstance() {
1466         return new increment_args();
1467       }
1468 
1469       protected increment_result getResult(I iface, increment_args args) throws org.apache.thrift.TException {
1470         increment_result result = new increment_result();
1471         try {
1472           result.success = iface.increment(args.table, args.increment);
1473         } catch (TIOError io) {
1474           result.io = io;
1475         }
1476         return result;
1477       }
1478     }
1479 
1480     private static class openScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, openScanner_args> {
1481       public openScanner() {
1482         super("openScanner");
1483       }
1484 
1485       protected openScanner_args getEmptyArgsInstance() {
1486         return new openScanner_args();
1487       }
1488 
1489       protected openScanner_result getResult(I iface, openScanner_args args) throws org.apache.thrift.TException {
1490         openScanner_result result = new openScanner_result();
1491         try {
1492           result.success = iface.openScanner(args.table, args.scan);
1493           result.setSuccessIsSet(true);
1494         } catch (TIOError io) {
1495           result.io = io;
1496         }
1497         return result;
1498       }
1499     }
1500 
1501     private static class getScannerRows<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerRows_args> {
1502       public getScannerRows() {
1503         super("getScannerRows");
1504       }
1505 
1506       protected getScannerRows_args getEmptyArgsInstance() {
1507         return new getScannerRows_args();
1508       }
1509 
1510       protected getScannerRows_result getResult(I iface, getScannerRows_args args) throws org.apache.thrift.TException {
1511         getScannerRows_result result = new getScannerRows_result();
1512         try {
1513           result.success = iface.getScannerRows(args.scannerId, args.numRows);
1514         } catch (TIOError io) {
1515           result.io = io;
1516         } catch (TIllegalArgument ia) {
1517           result.ia = ia;
1518         }
1519         return result;
1520       }
1521     }
1522 
1523     private static class closeScanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, closeScanner_args> {
1524       public closeScanner() {
1525         super("closeScanner");
1526       }
1527 
1528       protected closeScanner_args getEmptyArgsInstance() {
1529         return new closeScanner_args();
1530       }
1531 
1532       protected closeScanner_result getResult(I iface, closeScanner_args args) throws org.apache.thrift.TException {
1533         closeScanner_result result = new closeScanner_result();
1534         try {
1535           iface.closeScanner(args.scannerId);
1536         } catch (TIOError io) {
1537           result.io = io;
1538         } catch (TIllegalArgument ia) {
1539           result.ia = ia;
1540         }
1541         return result;
1542       }
1543     }
1544 
1545     private static class mutateRow<I extends Iface> extends org.apache.thrift.ProcessFunction<I, mutateRow_args> {
1546       public mutateRow() {
1547         super("mutateRow");
1548       }
1549 
1550       protected mutateRow_args getEmptyArgsInstance() {
1551         return new mutateRow_args();
1552       }
1553 
1554       protected mutateRow_result getResult(I iface, mutateRow_args args) throws org.apache.thrift.TException {
1555         mutateRow_result result = new mutateRow_result();
1556         try {
1557           iface.mutateRow(args.table, args.rowMutations);
1558         } catch (TIOError io) {
1559           result.io = io;
1560         }
1561         return result;
1562       }
1563     }
1564 
1565     private static class getScannerResults<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getScannerResults_args> {
1566       public getScannerResults() {
1567         super("getScannerResults");
1568       }
1569 
1570       protected getScannerResults_args getEmptyArgsInstance() {
1571         return new getScannerResults_args();
1572       }
1573 
1574       protected getScannerResults_result getResult(I iface, getScannerResults_args args) throws org.apache.thrift.TException {
1575         getScannerResults_result result = new getScannerResults_result();
1576         try {
1577           result.success = iface.getScannerResults(args.table, args.scan, args.numRows);
1578         } catch (TIOError io) {
1579           result.io = io;
1580         }
1581         return result;
1582       }
1583     }
1584 
1585   }
1586 
1587   public static class exists_args implements org.apache.thrift.TBase<exists_args, exists_args._Fields>, java.io.Serializable, Cloneable   {
1588     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_args");
1589 
1590     private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
1591     private static final org.apache.thrift.protocol.TField GET_FIELD_DESC = new org.apache.thrift.protocol.TField("get", org.apache.thrift.protocol.TType.STRUCT, (short)2);
1592 
1593     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
1594     static {
1595       schemes.put(StandardScheme.class, new exists_argsStandardSchemeFactory());
1596       schemes.put(TupleScheme.class, new exists_argsTupleSchemeFactory());
1597     }
1598 
1599     /**
1600      * the table to check on
1601      */
1602     public ByteBuffer table; // required
1603     /**
1604      * the TGet to check for
1605      */
1606     public TGet get; // required
1607 
1608     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
1609     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
1610       /**
1611        * the table to check on
1612        */
1613       TABLE((short)1, "table"),
1614       /**
1615        * the TGet to check for
1616        */
1617       GET((short)2, "get");
1618 
1619       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
1620 
1621       static {
1622         for (_Fields field : EnumSet.allOf(_Fields.class)) {
1623           byName.put(field.getFieldName(), field);
1624         }
1625       }
1626 
1627       /**
1628        * Find the _Fields constant that matches fieldId, or null if its not found.
1629        */
1630       public static _Fields findByThriftId(int fieldId) {
1631         switch(fieldId) {
1632           case 1: // TABLE
1633             return TABLE;
1634           case 2: // GET
1635             return GET;
1636           default:
1637             return null;
1638         }
1639       }
1640 
1641       /**
1642        * Find the _Fields constant that matches fieldId, throwing an exception
1643        * if it is not found.
1644        */
1645       public static _Fields findByThriftIdOrThrow(int fieldId) {
1646         _Fields fields = findByThriftId(fieldId);
1647         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
1648         return fields;
1649       }
1650 
1651       /**
1652        * Find the _Fields constant that matches name, or null if its not found.
1653        */
1654       public static _Fields findByName(String name) {
1655         return byName.get(name);
1656       }
1657 
1658       private final short _thriftId;
1659       private final String _fieldName;
1660 
1661       _Fields(short thriftId, String fieldName) {
1662         _thriftId = thriftId;
1663         _fieldName = fieldName;
1664       }
1665 
1666       public short getThriftFieldId() {
1667         return _thriftId;
1668       }
1669 
1670       public String getFieldName() {
1671         return _fieldName;
1672       }
1673     }
1674 
1675     // isset id assignments
1676     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
1677     static {
1678       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
1679       tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED, 
1680           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
1681       tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED, 
1682           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
1683       metaDataMap = Collections.unmodifiableMap(tmpMap);
1684       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_args.class, metaDataMap);
1685     }
1686 
1687     public exists_args() {
1688     }
1689 
1690     public exists_args(
1691       ByteBuffer table,
1692       TGet get)
1693     {
1694       this();
1695       this.table = table;
1696       this.get = get;
1697     }
1698 
1699     /**
1700      * Performs a deep copy on <i>other</i>.
1701      */
1702     public exists_args(exists_args other) {
1703       if (other.isSetTable()) {
1704         this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
1705 ;
1706       }
1707       if (other.isSetGet()) {
1708         this.get = new TGet(other.get);
1709       }
1710     }
1711 
1712     public exists_args deepCopy() {
1713       return new exists_args(this);
1714     }
1715 
1716     @Override
1717     public void clear() {
1718       this.table = null;
1719       this.get = null;
1720     }
1721 
1722     /**
1723      * the table to check on
1724      */
1725     public byte[] getTable() {
1726       setTable(org.apache.thrift.TBaseHelper.rightSize(table));
1727       return table == null ? null : table.array();
1728     }
1729 
1730     public ByteBuffer bufferForTable() {
1731       return table;
1732     }
1733 
1734     /**
1735      * the table to check on
1736      */
1737     public exists_args setTable(byte[] table) {
1738       setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
1739       return this;
1740     }
1741 
1742     public exists_args setTable(ByteBuffer table) {
1743       this.table = table;
1744       return this;
1745     }
1746 
1747     public void unsetTable() {
1748       this.table = null;
1749     }
1750 
1751     /** Returns true if field table is set (has been assigned a value) and false otherwise */
1752     public boolean isSetTable() {
1753       return this.table != null;
1754     }
1755 
1756     public void setTableIsSet(boolean value) {
1757       if (!value) {
1758         this.table = null;
1759       }
1760     }
1761 
1762     /**
1763      * the TGet to check for
1764      */
1765     public TGet getGet() {
1766       return this.get;
1767     }
1768 
1769     /**
1770      * the TGet to check for
1771      */
1772     public exists_args setGet(TGet get) {
1773       this.get = get;
1774       return this;
1775     }
1776 
1777     public void unsetGet() {
1778       this.get = null;
1779     }
1780 
1781     /** Returns true if field get is set (has been assigned a value) and false otherwise */
1782     public boolean isSetGet() {
1783       return this.get != null;
1784     }
1785 
1786     public void setGetIsSet(boolean value) {
1787       if (!value) {
1788         this.get = null;
1789       }
1790     }
1791 
1792     public void setFieldValue(_Fields field, Object value) {
1793       switch (field) {
1794       case TABLE:
1795         if (value == null) {
1796           unsetTable();
1797         } else {
1798           setTable((ByteBuffer)value);
1799         }
1800         break;
1801 
1802       case GET:
1803         if (value == null) {
1804           unsetGet();
1805         } else {
1806           setGet((TGet)value);
1807         }
1808         break;
1809 
1810       }
1811     }
1812 
1813     public Object getFieldValue(_Fields field) {
1814       switch (field) {
1815       case TABLE:
1816         return getTable();
1817 
1818       case GET:
1819         return getGet();
1820 
1821       }
1822       throw new IllegalStateException();
1823     }
1824 
1825     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
1826     public boolean isSet(_Fields field) {
1827       if (field == null) {
1828         throw new IllegalArgumentException();
1829       }
1830 
1831       switch (field) {
1832       case TABLE:
1833         return isSetTable();
1834       case GET:
1835         return isSetGet();
1836       }
1837       throw new IllegalStateException();
1838     }
1839 
1840     @Override
1841     public boolean equals(Object that) {
1842       if (that == null)
1843         return false;
1844       if (that instanceof exists_args)
1845         return this.equals((exists_args)that);
1846       return false;
1847     }
1848 
1849     public boolean equals(exists_args that) {
1850       if (that == null)
1851         return false;
1852 
1853       boolean this_present_table = true && this.isSetTable();
1854       boolean that_present_table = true && that.isSetTable();
1855       if (this_present_table || that_present_table) {
1856         if (!(this_present_table && that_present_table))
1857           return false;
1858         if (!this.table.equals(that.table))
1859           return false;
1860       }
1861 
1862       boolean this_present_get = true && this.isSetGet();
1863       boolean that_present_get = true && that.isSetGet();
1864       if (this_present_get || that_present_get) {
1865         if (!(this_present_get && that_present_get))
1866           return false;
1867         if (!this.get.equals(that.get))
1868           return false;
1869       }
1870 
1871       return true;
1872     }
1873 
1874     @Override
1875     public int hashCode() {
1876       return 0;
1877     }
1878 
1879     public int compareTo(exists_args other) {
1880       if (!getClass().equals(other.getClass())) {
1881         return getClass().getName().compareTo(other.getClass().getName());
1882       }
1883 
1884       int lastComparison = 0;
1885       exists_args typedOther = (exists_args)other;
1886 
1887       lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
1888       if (lastComparison != 0) {
1889         return lastComparison;
1890       }
1891       if (isSetTable()) {
1892         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
1893         if (lastComparison != 0) {
1894           return lastComparison;
1895         }
1896       }
1897       lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
1898       if (lastComparison != 0) {
1899         return lastComparison;
1900       }
1901       if (isSetGet()) {
1902         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
1903         if (lastComparison != 0) {
1904           return lastComparison;
1905         }
1906       }
1907       return 0;
1908     }
1909 
1910     public _Fields fieldForId(int fieldId) {
1911       return _Fields.findByThriftId(fieldId);
1912     }
1913 
1914     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
1915       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
1916     }
1917 
1918     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
1919       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
1920     }
1921 
1922     @Override
1923     public String toString() {
1924       StringBuilder sb = new StringBuilder("exists_args(");
1925       boolean first = true;
1926 
1927       sb.append("table:");
1928       if (this.table == null) {
1929         sb.append("null");
1930       } else {
1931         org.apache.thrift.TBaseHelper.toString(this.table, sb);
1932       }
1933       first = false;
1934       if (!first) sb.append(", ");
1935       sb.append("get:");
1936       if (this.get == null) {
1937         sb.append("null");
1938       } else {
1939         sb.append(this.get);
1940       }
1941       first = false;
1942       sb.append(")");
1943       return sb.toString();
1944     }
1945 
1946     public void validate() throws org.apache.thrift.TException {
1947       // check for required fields
1948       if (table == null) {
1949         throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
1950       }
1951       if (get == null) {
1952         throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
1953       }
1954     }
1955 
1956     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
1957       try {
1958         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
1959       } catch (org.apache.thrift.TException te) {
1960         throw new java.io.IOException(te);
1961       }
1962     }
1963 
1964     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
1965       try {
1966         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
1967       } catch (org.apache.thrift.TException te) {
1968         throw new java.io.IOException(te);
1969       }
1970     }
1971 
1972     private static class exists_argsStandardSchemeFactory implements SchemeFactory {
1973       public exists_argsStandardScheme getScheme() {
1974         return new exists_argsStandardScheme();
1975       }
1976     }
1977 
1978     private static class exists_argsStandardScheme extends StandardScheme<exists_args> {
1979 
1980       public void read(org.apache.thrift.protocol.TProtocol iprot, exists_args struct) throws org.apache.thrift.TException {
1981         org.apache.thrift.protocol.TField schemeField;
1982         iprot.readStructBegin();
1983         while (true)
1984         {
1985           schemeField = iprot.readFieldBegin();
1986           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
1987             break;
1988           }
1989           switch (schemeField.id) {
1990             case 1: // TABLE
1991               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
1992                 struct.table = iprot.readBinary();
1993                 struct.setTableIsSet(true);
1994               } else { 
1995                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1996               }
1997               break;
1998             case 2: // GET
1999               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2000                 struct.get = new TGet();
2001                 struct.get.read(iprot);
2002                 struct.setGetIsSet(true);
2003               } else { 
2004                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2005               }
2006               break;
2007             default:
2008               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2009           }
2010           iprot.readFieldEnd();
2011         }
2012         iprot.readStructEnd();
2013 
2014         // check for required fields of primitive type, which can't be checked in the validate method
2015         struct.validate();
2016       }
2017 
2018       public void write(org.apache.thrift.protocol.TProtocol oprot, exists_args struct) throws org.apache.thrift.TException {
2019         struct.validate();
2020 
2021         oprot.writeStructBegin(STRUCT_DESC);
2022         if (struct.table != null) {
2023           oprot.writeFieldBegin(TABLE_FIELD_DESC);
2024           oprot.writeBinary(struct.table);
2025           oprot.writeFieldEnd();
2026         }
2027         if (struct.get != null) {
2028           oprot.writeFieldBegin(GET_FIELD_DESC);
2029           struct.get.write(oprot);
2030           oprot.writeFieldEnd();
2031         }
2032         oprot.writeFieldStop();
2033         oprot.writeStructEnd();
2034       }
2035 
2036     }
2037 
2038     private static class exists_argsTupleSchemeFactory implements SchemeFactory {
2039       public exists_argsTupleScheme getScheme() {
2040         return new exists_argsTupleScheme();
2041       }
2042     }
2043 
2044     private static class exists_argsTupleScheme extends TupleScheme<exists_args> {
2045 
2046       @Override
2047       public void write(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
2048         TTupleProtocol oprot = (TTupleProtocol) prot;
2049         oprot.writeBinary(struct.table);
2050         struct.get.write(oprot);
2051       }
2052 
2053       @Override
2054       public void read(org.apache.thrift.protocol.TProtocol prot, exists_args struct) throws org.apache.thrift.TException {
2055         TTupleProtocol iprot = (TTupleProtocol) prot;
2056         struct.table = iprot.readBinary();
2057         struct.setTableIsSet(true);
2058         struct.get = new TGet();
2059         struct.get.read(iprot);
2060         struct.setGetIsSet(true);
2061       }
2062     }
2063 
2064   }
2065 
2066   public static class exists_result implements org.apache.thrift.TBase<exists_result, exists_result._Fields>, java.io.Serializable, Cloneable   {
2067     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exists_result");
2068 
2069     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0);
2070     private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
2071 
2072     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2073     static {
2074       schemes.put(StandardScheme.class, new exists_resultStandardSchemeFactory());
2075       schemes.put(TupleScheme.class, new exists_resultTupleSchemeFactory());
2076     }
2077 
2078     public boolean success; // required
2079     public TIOError io; // required
2080 
2081     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
2082     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2083       SUCCESS((short)0, "success"),
2084       IO((short)1, "io");
2085 
2086       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2087 
2088       static {
2089         for (_Fields field : EnumSet.allOf(_Fields.class)) {
2090           byName.put(field.getFieldName(), field);
2091         }
2092       }
2093 
2094       /**
2095        * Find the _Fields constant that matches fieldId, or null if its not found.
2096        */
2097       public static _Fields findByThriftId(int fieldId) {
2098         switch(fieldId) {
2099           case 0: // SUCCESS
2100             return SUCCESS;
2101           case 1: // IO
2102             return IO;
2103           default:
2104             return null;
2105         }
2106       }
2107 
2108       /**
2109        * Find the _Fields constant that matches fieldId, throwing an exception
2110        * if it is not found.
2111        */
2112       public static _Fields findByThriftIdOrThrow(int fieldId) {
2113         _Fields fields = findByThriftId(fieldId);
2114         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2115         return fields;
2116       }
2117 
2118       /**
2119        * Find the _Fields constant that matches name, or null if its not found.
2120        */
2121       public static _Fields findByName(String name) {
2122         return byName.get(name);
2123       }
2124 
2125       private final short _thriftId;
2126       private final String _fieldName;
2127 
2128       _Fields(short thriftId, String fieldName) {
2129         _thriftId = thriftId;
2130         _fieldName = fieldName;
2131       }
2132 
2133       public short getThriftFieldId() {
2134         return _thriftId;
2135       }
2136 
2137       public String getFieldName() {
2138         return _fieldName;
2139       }
2140     }
2141 
2142     // isset id assignments
2143     private static final int __SUCCESS_ISSET_ID = 0;
2144     private BitSet __isset_bit_vector = new BitSet(1);
2145     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2146     static {
2147       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2148       tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
2149           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
2150       tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, 
2151           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
2152       metaDataMap = Collections.unmodifiableMap(tmpMap);
2153       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exists_result.class, metaDataMap);
2154     }
2155 
2156     public exists_result() {
2157     }
2158 
2159     public exists_result(
2160       boolean success,
2161       TIOError io)
2162     {
2163       this();
2164       this.success = success;
2165       setSuccessIsSet(true);
2166       this.io = io;
2167     }
2168 
2169     /**
2170      * Performs a deep copy on <i>other</i>.
2171      */
2172     public exists_result(exists_result other) {
2173       __isset_bit_vector.clear();
2174       __isset_bit_vector.or(other.__isset_bit_vector);
2175       this.success = other.success;
2176       if (other.isSetIo()) {
2177         this.io = new TIOError(other.io);
2178       }
2179     }
2180 
2181     public exists_result deepCopy() {
2182       return new exists_result(this);
2183     }
2184 
2185     @Override
2186     public void clear() {
2187       setSuccessIsSet(false);
2188       this.success = false;
2189       this.io = null;
2190     }
2191 
2192     public boolean isSuccess() {
2193       return this.success;
2194     }
2195 
2196     public exists_result setSuccess(boolean success) {
2197       this.success = success;
2198       setSuccessIsSet(true);
2199       return this;
2200     }
2201 
2202     public void unsetSuccess() {
2203       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
2204     }
2205 
2206     /** Returns true if field success is set (has been assigned a value) and false otherwise */
2207     public boolean isSetSuccess() {
2208       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
2209     }
2210 
2211     public void setSuccessIsSet(boolean value) {
2212       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
2213     }
2214 
2215     public TIOError getIo() {
2216       return this.io;
2217     }
2218 
2219     public exists_result setIo(TIOError io) {
2220       this.io = io;
2221       return this;
2222     }
2223 
2224     public void unsetIo() {
2225       this.io = null;
2226     }
2227 
2228     /** Returns true if field io is set (has been assigned a value) and false otherwise */
2229     public boolean isSetIo() {
2230       return this.io != null;
2231     }
2232 
2233     public void setIoIsSet(boolean value) {
2234       if (!value) {
2235         this.io = null;
2236       }
2237     }
2238 
2239     public void setFieldValue(_Fields field, Object value) {
2240       switch (field) {
2241       case SUCCESS:
2242         if (value == null) {
2243           unsetSuccess();
2244         } else {
2245           setSuccess((Boolean)value);
2246         }
2247         break;
2248 
2249       case IO:
2250         if (value == null) {
2251           unsetIo();
2252         } else {
2253           setIo((TIOError)value);
2254         }
2255         break;
2256 
2257       }
2258     }
2259 
2260     public Object getFieldValue(_Fields field) {
2261       switch (field) {
2262       case SUCCESS:
2263         return Boolean.valueOf(isSuccess());
2264 
2265       case IO:
2266         return getIo();
2267 
2268       }
2269       throw new IllegalStateException();
2270     }
2271 
2272     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
2273     public boolean isSet(_Fields field) {
2274       if (field == null) {
2275         throw new IllegalArgumentException();
2276       }
2277 
2278       switch (field) {
2279       case SUCCESS:
2280         return isSetSuccess();
2281       case IO:
2282         return isSetIo();
2283       }
2284       throw new IllegalStateException();
2285     }
2286 
2287     @Override
2288     public boolean equals(Object that) {
2289       if (that == null)
2290         return false;
2291       if (that instanceof exists_result)
2292         return this.equals((exists_result)that);
2293       return false;
2294     }
2295 
2296     public boolean equals(exists_result that) {
2297       if (that == null)
2298         return false;
2299 
2300       boolean this_present_success = true;
2301       boolean that_present_success = true;
2302       if (this_present_success || that_present_success) {
2303         if (!(this_present_success && that_present_success))
2304           return false;
2305         if (this.success != that.success)
2306           return false;
2307       }
2308 
2309       boolean this_present_io = true && this.isSetIo();
2310       boolean that_present_io = true && that.isSetIo();
2311       if (this_present_io || that_present_io) {
2312         if (!(this_present_io && that_present_io))
2313           return false;
2314         if (!this.io.equals(that.io))
2315           return false;
2316       }
2317 
2318       return true;
2319     }
2320 
2321     @Override
2322     public int hashCode() {
2323       return 0;
2324     }
2325 
2326     public int compareTo(exists_result other) {
2327       if (!getClass().equals(other.getClass())) {
2328         return getClass().getName().compareTo(other.getClass().getName());
2329       }
2330 
2331       int lastComparison = 0;
2332       exists_result typedOther = (exists_result)other;
2333 
2334       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
2335       if (lastComparison != 0) {
2336         return lastComparison;
2337       }
2338       if (isSetSuccess()) {
2339         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
2340         if (lastComparison != 0) {
2341           return lastComparison;
2342         }
2343       }
2344       lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
2345       if (lastComparison != 0) {
2346         return lastComparison;
2347       }
2348       if (isSetIo()) {
2349         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
2350         if (lastComparison != 0) {
2351           return lastComparison;
2352         }
2353       }
2354       return 0;
2355     }
2356 
2357     public _Fields fieldForId(int fieldId) {
2358       return _Fields.findByThriftId(fieldId);
2359     }
2360 
2361     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2362       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2363     }
2364 
2365     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2366       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2367       }
2368 
2369     @Override
2370     public String toString() {
2371       StringBuilder sb = new StringBuilder("exists_result(");
2372       boolean first = true;
2373 
2374       sb.append("success:");
2375       sb.append(this.success);
2376       first = false;
2377       if (!first) sb.append(", ");
2378       sb.append("io:");
2379       if (this.io == null) {
2380         sb.append("null");
2381       } else {
2382         sb.append(this.io);
2383       }
2384       first = false;
2385       sb.append(")");
2386       return sb.toString();
2387     }
2388 
2389     public void validate() throws org.apache.thrift.TException {
2390       // check for required fields
2391     }
2392 
2393     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2394       try {
2395         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2396       } catch (org.apache.thrift.TException te) {
2397         throw new java.io.IOException(te);
2398       }
2399     }
2400 
2401     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2402       try {
2403         // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
2404         __isset_bit_vector = new BitSet(1);
2405         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2406       } catch (org.apache.thrift.TException te) {
2407         throw new java.io.IOException(te);
2408       }
2409     }
2410 
2411     private static class exists_resultStandardSchemeFactory implements SchemeFactory {
2412       public exists_resultStandardScheme getScheme() {
2413         return new exists_resultStandardScheme();
2414       }
2415     }
2416 
2417     private static class exists_resultStandardScheme extends StandardScheme<exists_result> {
2418 
2419       public void read(org.apache.thrift.protocol.TProtocol iprot, exists_result struct) throws org.apache.thrift.TException {
2420         org.apache.thrift.protocol.TField schemeField;
2421         iprot.readStructBegin();
2422         while (true)
2423         {
2424           schemeField = iprot.readFieldBegin();
2425           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
2426             break;
2427           }
2428           switch (schemeField.id) {
2429             case 0: // SUCCESS
2430               if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
2431                 struct.success = iprot.readBool();
2432                 struct.setSuccessIsSet(true);
2433               } else { 
2434                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2435               }
2436               break;
2437             case 1: // IO
2438               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2439                 struct.io = new TIOError();
2440                 struct.io.read(iprot);
2441                 struct.setIoIsSet(true);
2442               } else { 
2443                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2444               }
2445               break;
2446             default:
2447               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2448           }
2449           iprot.readFieldEnd();
2450         }
2451         iprot.readStructEnd();
2452 
2453         // check for required fields of primitive type, which can't be checked in the validate method
2454         struct.validate();
2455       }
2456 
2457       public void write(org.apache.thrift.protocol.TProtocol oprot, exists_result struct) throws org.apache.thrift.TException {
2458         struct.validate();
2459 
2460         oprot.writeStructBegin(STRUCT_DESC);
2461         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
2462         oprot.writeBool(struct.success);
2463         oprot.writeFieldEnd();
2464         if (struct.io != null) {
2465           oprot.writeFieldBegin(IO_FIELD_DESC);
2466           struct.io.write(oprot);
2467           oprot.writeFieldEnd();
2468         }
2469         oprot.writeFieldStop();
2470         oprot.writeStructEnd();
2471       }
2472 
2473     }
2474 
2475     private static class exists_resultTupleSchemeFactory implements SchemeFactory {
2476       public exists_resultTupleScheme getScheme() {
2477         return new exists_resultTupleScheme();
2478       }
2479     }
2480 
2481     private static class exists_resultTupleScheme extends TupleScheme<exists_result> {
2482 
2483       @Override
2484       public void write(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2485         TTupleProtocol oprot = (TTupleProtocol) prot;
2486         BitSet optionals = new BitSet();
2487         if (struct.isSetSuccess()) {
2488           optionals.set(0);
2489         }
2490         if (struct.isSetIo()) {
2491           optionals.set(1);
2492         }
2493         oprot.writeBitSet(optionals, 2);
2494         if (struct.isSetSuccess()) {
2495           oprot.writeBool(struct.success);
2496         }
2497         if (struct.isSetIo()) {
2498           struct.io.write(oprot);
2499         }
2500       }
2501 
2502       @Override
2503       public void read(org.apache.thrift.protocol.TProtocol prot, exists_result struct) throws org.apache.thrift.TException {
2504         TTupleProtocol iprot = (TTupleProtocol) prot;
2505         BitSet incoming = iprot.readBitSet(2);
2506         if (incoming.get(0)) {
2507           struct.success = iprot.readBool();
2508           struct.setSuccessIsSet(true);
2509         }
2510         if (incoming.get(1)) {
2511           struct.io = new TIOError();
2512           struct.io.read(iprot);
2513           struct.setIoIsSet(true);
2514         }
2515       }
2516     }
2517 
2518   }
2519 
2520   public static class get_args implements org.apache.thrift.TBase<get_args, get_args._Fields>, java.io.Serializable, Cloneable   {
2521     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_args");
2522 
2523     private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
2524     private static final org.apache.thrift.protocol.TField GET_FIELD_DESC = new org.apache.thrift.protocol.TField("get", org.apache.thrift.protocol.TType.STRUCT, (short)2);
2525 
2526     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
2527     static {
2528       schemes.put(StandardScheme.class, new get_argsStandardSchemeFactory());
2529       schemes.put(TupleScheme.class, new get_argsTupleSchemeFactory());
2530     }
2531 
2532     /**
2533      * the table to get from
2534      */
2535     public ByteBuffer table; // required
2536     /**
2537      * the TGet to fetch
2538      */
2539     public TGet get; // required
2540 
2541     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
2542     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
2543       /**
2544        * the table to get from
2545        */
2546       TABLE((short)1, "table"),
2547       /**
2548        * the TGet to fetch
2549        */
2550       GET((short)2, "get");
2551 
2552       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2553 
2554       static {
2555         for (_Fields field : EnumSet.allOf(_Fields.class)) {
2556           byName.put(field.getFieldName(), field);
2557         }
2558       }
2559 
2560       /**
2561        * Find the _Fields constant that matches fieldId, or null if its not found.
2562        */
2563       public static _Fields findByThriftId(int fieldId) {
2564         switch(fieldId) {
2565           case 1: // TABLE
2566             return TABLE;
2567           case 2: // GET
2568             return GET;
2569           default:
2570             return null;
2571         }
2572       }
2573 
2574       /**
2575        * Find the _Fields constant that matches fieldId, throwing an exception
2576        * if it is not found.
2577        */
2578       public static _Fields findByThriftIdOrThrow(int fieldId) {
2579         _Fields fields = findByThriftId(fieldId);
2580         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2581         return fields;
2582       }
2583 
2584       /**
2585        * Find the _Fields constant that matches name, or null if its not found.
2586        */
2587       public static _Fields findByName(String name) {
2588         return byName.get(name);
2589       }
2590 
2591       private final short _thriftId;
2592       private final String _fieldName;
2593 
2594       _Fields(short thriftId, String fieldName) {
2595         _thriftId = thriftId;
2596         _fieldName = fieldName;
2597       }
2598 
2599       public short getThriftFieldId() {
2600         return _thriftId;
2601       }
2602 
2603       public String getFieldName() {
2604         return _fieldName;
2605       }
2606     }
2607 
2608     // isset id assignments
2609     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
2610     static {
2611       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
2612       tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED, 
2613           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
2614       tmpMap.put(_Fields.GET, new org.apache.thrift.meta_data.FieldMetaData("get", org.apache.thrift.TFieldRequirementType.REQUIRED, 
2615           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class)));
2616       metaDataMap = Collections.unmodifiableMap(tmpMap);
2617       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
2618     }
2619 
2620     public get_args() {
2621     }
2622 
2623     public get_args(
2624       ByteBuffer table,
2625       TGet get)
2626     {
2627       this();
2628       this.table = table;
2629       this.get = get;
2630     }
2631 
2632     /**
2633      * Performs a deep copy on <i>other</i>.
2634      */
2635     public get_args(get_args other) {
2636       if (other.isSetTable()) {
2637         this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
2638 ;
2639       }
2640       if (other.isSetGet()) {
2641         this.get = new TGet(other.get);
2642       }
2643     }
2644 
2645     public get_args deepCopy() {
2646       return new get_args(this);
2647     }
2648 
2649     @Override
2650     public void clear() {
2651       this.table = null;
2652       this.get = null;
2653     }
2654 
2655     /**
2656      * the table to get from
2657      */
2658     public byte[] getTable() {
2659       setTable(org.apache.thrift.TBaseHelper.rightSize(table));
2660       return table == null ? null : table.array();
2661     }
2662 
2663     public ByteBuffer bufferForTable() {
2664       return table;
2665     }
2666 
2667     /**
2668      * the table to get from
2669      */
2670     public get_args setTable(byte[] table) {
2671       setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
2672       return this;
2673     }
2674 
2675     public get_args setTable(ByteBuffer table) {
2676       this.table = table;
2677       return this;
2678     }
2679 
2680     public void unsetTable() {
2681       this.table = null;
2682     }
2683 
2684     /** Returns true if field table is set (has been assigned a value) and false otherwise */
2685     public boolean isSetTable() {
2686       return this.table != null;
2687     }
2688 
2689     public void setTableIsSet(boolean value) {
2690       if (!value) {
2691         this.table = null;
2692       }
2693     }
2694 
2695     /**
2696      * the TGet to fetch
2697      */
2698     public TGet getGet() {
2699       return this.get;
2700     }
2701 
2702     /**
2703      * the TGet to fetch
2704      */
2705     public get_args setGet(TGet get) {
2706       this.get = get;
2707       return this;
2708     }
2709 
2710     public void unsetGet() {
2711       this.get = null;
2712     }
2713 
2714     /** Returns true if field get is set (has been assigned a value) and false otherwise */
2715     public boolean isSetGet() {
2716       return this.get != null;
2717     }
2718 
2719     public void setGetIsSet(boolean value) {
2720       if (!value) {
2721         this.get = null;
2722       }
2723     }
2724 
2725     public void setFieldValue(_Fields field, Object value) {
2726       switch (field) {
2727       case TABLE:
2728         if (value == null) {
2729           unsetTable();
2730         } else {
2731           setTable((ByteBuffer)value);
2732         }
2733         break;
2734 
2735       case GET:
2736         if (value == null) {
2737           unsetGet();
2738         } else {
2739           setGet((TGet)value);
2740         }
2741         break;
2742 
2743       }
2744     }
2745 
2746     public Object getFieldValue(_Fields field) {
2747       switch (field) {
2748       case TABLE:
2749         return getTable();
2750 
2751       case GET:
2752         return getGet();
2753 
2754       }
2755       throw new IllegalStateException();
2756     }
2757 
2758     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
2759     public boolean isSet(_Fields field) {
2760       if (field == null) {
2761         throw new IllegalArgumentException();
2762       }
2763 
2764       switch (field) {
2765       case TABLE:
2766         return isSetTable();
2767       case GET:
2768         return isSetGet();
2769       }
2770       throw new IllegalStateException();
2771     }
2772 
2773     @Override
2774     public boolean equals(Object that) {
2775       if (that == null)
2776         return false;
2777       if (that instanceof get_args)
2778         return this.equals((get_args)that);
2779       return false;
2780     }
2781 
2782     public boolean equals(get_args that) {
2783       if (that == null)
2784         return false;
2785 
2786       boolean this_present_table = true && this.isSetTable();
2787       boolean that_present_table = true && that.isSetTable();
2788       if (this_present_table || that_present_table) {
2789         if (!(this_present_table && that_present_table))
2790           return false;
2791         if (!this.table.equals(that.table))
2792           return false;
2793       }
2794 
2795       boolean this_present_get = true && this.isSetGet();
2796       boolean that_present_get = true && that.isSetGet();
2797       if (this_present_get || that_present_get) {
2798         if (!(this_present_get && that_present_get))
2799           return false;
2800         if (!this.get.equals(that.get))
2801           return false;
2802       }
2803 
2804       return true;
2805     }
2806 
2807     @Override
2808     public int hashCode() {
2809       return 0;
2810     }
2811 
2812     public int compareTo(get_args other) {
2813       if (!getClass().equals(other.getClass())) {
2814         return getClass().getName().compareTo(other.getClass().getName());
2815       }
2816 
2817       int lastComparison = 0;
2818       get_args typedOther = (get_args)other;
2819 
2820       lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
2821       if (lastComparison != 0) {
2822         return lastComparison;
2823       }
2824       if (isSetTable()) {
2825         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
2826         if (lastComparison != 0) {
2827           return lastComparison;
2828         }
2829       }
2830       lastComparison = Boolean.valueOf(isSetGet()).compareTo(typedOther.isSetGet());
2831       if (lastComparison != 0) {
2832         return lastComparison;
2833       }
2834       if (isSetGet()) {
2835         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.get, typedOther.get);
2836         if (lastComparison != 0) {
2837           return lastComparison;
2838         }
2839       }
2840       return 0;
2841     }
2842 
2843     public _Fields fieldForId(int fieldId) {
2844       return _Fields.findByThriftId(fieldId);
2845     }
2846 
2847     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
2848       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2849     }
2850 
2851     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
2852       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2853     }
2854 
2855     @Override
2856     public String toString() {
2857       StringBuilder sb = new StringBuilder("get_args(");
2858       boolean first = true;
2859 
2860       sb.append("table:");
2861       if (this.table == null) {
2862         sb.append("null");
2863       } else {
2864         org.apache.thrift.TBaseHelper.toString(this.table, sb);
2865       }
2866       first = false;
2867       if (!first) sb.append(", ");
2868       sb.append("get:");
2869       if (this.get == null) {
2870         sb.append("null");
2871       } else {
2872         sb.append(this.get);
2873       }
2874       first = false;
2875       sb.append(")");
2876       return sb.toString();
2877     }
2878 
2879     public void validate() throws org.apache.thrift.TException {
2880       // check for required fields
2881       if (table == null) {
2882         throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
2883       }
2884       if (get == null) {
2885         throw new org.apache.thrift.protocol.TProtocolException("Required field 'get' was not present! Struct: " + toString());
2886       }
2887     }
2888 
2889     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
2890       try {
2891         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
2892       } catch (org.apache.thrift.TException te) {
2893         throw new java.io.IOException(te);
2894       }
2895     }
2896 
2897     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
2898       try {
2899         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
2900       } catch (org.apache.thrift.TException te) {
2901         throw new java.io.IOException(te);
2902       }
2903     }
2904 
2905     private static class get_argsStandardSchemeFactory implements SchemeFactory {
2906       public get_argsStandardScheme getScheme() {
2907         return new get_argsStandardScheme();
2908       }
2909     }
2910 
2911     private static class get_argsStandardScheme extends StandardScheme<get_args> {
2912 
2913       public void read(org.apache.thrift.protocol.TProtocol iprot, get_args struct) throws org.apache.thrift.TException {
2914         org.apache.thrift.protocol.TField schemeField;
2915         iprot.readStructBegin();
2916         while (true)
2917         {
2918           schemeField = iprot.readFieldBegin();
2919           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
2920             break;
2921           }
2922           switch (schemeField.id) {
2923             case 1: // TABLE
2924               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
2925                 struct.table = iprot.readBinary();
2926                 struct.setTableIsSet(true);
2927               } else { 
2928                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2929               }
2930               break;
2931             case 2: // GET
2932               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
2933                 struct.get = new TGet();
2934                 struct.get.read(iprot);
2935                 struct.setGetIsSet(true);
2936               } else { 
2937                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2938               }
2939               break;
2940             default:
2941               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
2942           }
2943           iprot.readFieldEnd();
2944         }
2945         iprot.readStructEnd();
2946 
2947         // check for required fields of primitive type, which can't be checked in the validate method
2948         struct.validate();
2949       }
2950 
2951       public void write(org.apache.thrift.protocol.TProtocol oprot, get_args struct) throws org.apache.thrift.TException {
2952         struct.validate();
2953 
2954         oprot.writeStructBegin(STRUCT_DESC);
2955         if (struct.table != null) {
2956           oprot.writeFieldBegin(TABLE_FIELD_DESC);
2957           oprot.writeBinary(struct.table);
2958           oprot.writeFieldEnd();
2959         }
2960         if (struct.get != null) {
2961           oprot.writeFieldBegin(GET_FIELD_DESC);
2962           struct.get.write(oprot);
2963           oprot.writeFieldEnd();
2964         }
2965         oprot.writeFieldStop();
2966         oprot.writeStructEnd();
2967       }
2968 
2969     }
2970 
2971     private static class get_argsTupleSchemeFactory implements SchemeFactory {
2972       public get_argsTupleScheme getScheme() {
2973         return new get_argsTupleScheme();
2974       }
2975     }
2976 
2977     private static class get_argsTupleScheme extends TupleScheme<get_args> {
2978 
2979       @Override
2980       public void write(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2981         TTupleProtocol oprot = (TTupleProtocol) prot;
2982         oprot.writeBinary(struct.table);
2983         struct.get.write(oprot);
2984       }
2985 
2986       @Override
2987       public void read(org.apache.thrift.protocol.TProtocol prot, get_args struct) throws org.apache.thrift.TException {
2988         TTupleProtocol iprot = (TTupleProtocol) prot;
2989         struct.table = iprot.readBinary();
2990         struct.setTableIsSet(true);
2991         struct.get = new TGet();
2992         struct.get.read(iprot);
2993         struct.setGetIsSet(true);
2994       }
2995     }
2996 
2997   }
2998 
2999   public static class get_result implements org.apache.thrift.TBase<get_result, get_result._Fields>, java.io.Serializable, Cloneable   {
3000     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_result");
3001 
3002     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
3003     private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
3004 
3005     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3006     static {
3007       schemes.put(StandardScheme.class, new get_resultStandardSchemeFactory());
3008       schemes.put(TupleScheme.class, new get_resultTupleSchemeFactory());
3009     }
3010 
3011     public TResult success; // required
3012     public TIOError io; // required
3013 
3014     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
3015     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3016       SUCCESS((short)0, "success"),
3017       IO((short)1, "io");
3018 
3019       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3020 
3021       static {
3022         for (_Fields field : EnumSet.allOf(_Fields.class)) {
3023           byName.put(field.getFieldName(), field);
3024         }
3025       }
3026 
3027       /**
3028        * Find the _Fields constant that matches fieldId, or null if its not found.
3029        */
3030       public static _Fields findByThriftId(int fieldId) {
3031         switch(fieldId) {
3032           case 0: // SUCCESS
3033             return SUCCESS;
3034           case 1: // IO
3035             return IO;
3036           default:
3037             return null;
3038         }
3039       }
3040 
3041       /**
3042        * Find the _Fields constant that matches fieldId, throwing an exception
3043        * if it is not found.
3044        */
3045       public static _Fields findByThriftIdOrThrow(int fieldId) {
3046         _Fields fields = findByThriftId(fieldId);
3047         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3048         return fields;
3049       }
3050 
3051       /**
3052        * Find the _Fields constant that matches name, or null if its not found.
3053        */
3054       public static _Fields findByName(String name) {
3055         return byName.get(name);
3056       }
3057 
3058       private final short _thriftId;
3059       private final String _fieldName;
3060 
3061       _Fields(short thriftId, String fieldName) {
3062         _thriftId = thriftId;
3063         _fieldName = fieldName;
3064       }
3065 
3066       public short getThriftFieldId() {
3067         return _thriftId;
3068       }
3069 
3070       public String getFieldName() {
3071         return _fieldName;
3072       }
3073     }
3074 
3075     // isset id assignments
3076     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3077     static {
3078       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3079       tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
3080           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class)));
3081       tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, 
3082           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
3083       metaDataMap = Collections.unmodifiableMap(tmpMap);
3084       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
3085     }
3086 
3087     public get_result() {
3088     }
3089 
3090     public get_result(
3091       TResult success,
3092       TIOError io)
3093     {
3094       this();
3095       this.success = success;
3096       this.io = io;
3097     }
3098 
3099     /**
3100      * Performs a deep copy on <i>other</i>.
3101      */
3102     public get_result(get_result other) {
3103       if (other.isSetSuccess()) {
3104         this.success = new TResult(other.success);
3105       }
3106       if (other.isSetIo()) {
3107         this.io = new TIOError(other.io);
3108       }
3109     }
3110 
3111     public get_result deepCopy() {
3112       return new get_result(this);
3113     }
3114 
3115     @Override
3116     public void clear() {
3117       this.success = null;
3118       this.io = null;
3119     }
3120 
3121     public TResult getSuccess() {
3122       return this.success;
3123     }
3124 
3125     public get_result setSuccess(TResult success) {
3126       this.success = success;
3127       return this;
3128     }
3129 
3130     public void unsetSuccess() {
3131       this.success = null;
3132     }
3133 
3134     /** Returns true if field success is set (has been assigned a value) and false otherwise */
3135     public boolean isSetSuccess() {
3136       return this.success != null;
3137     }
3138 
3139     public void setSuccessIsSet(boolean value) {
3140       if (!value) {
3141         this.success = null;
3142       }
3143     }
3144 
3145     public TIOError getIo() {
3146       return this.io;
3147     }
3148 
3149     public get_result setIo(TIOError io) {
3150       this.io = io;
3151       return this;
3152     }
3153 
3154     public void unsetIo() {
3155       this.io = null;
3156     }
3157 
3158     /** Returns true if field io is set (has been assigned a value) and false otherwise */
3159     public boolean isSetIo() {
3160       return this.io != null;
3161     }
3162 
3163     public void setIoIsSet(boolean value) {
3164       if (!value) {
3165         this.io = null;
3166       }
3167     }
3168 
3169     public void setFieldValue(_Fields field, Object value) {
3170       switch (field) {
3171       case SUCCESS:
3172         if (value == null) {
3173           unsetSuccess();
3174         } else {
3175           setSuccess((TResult)value);
3176         }
3177         break;
3178 
3179       case IO:
3180         if (value == null) {
3181           unsetIo();
3182         } else {
3183           setIo((TIOError)value);
3184         }
3185         break;
3186 
3187       }
3188     }
3189 
3190     public Object getFieldValue(_Fields field) {
3191       switch (field) {
3192       case SUCCESS:
3193         return getSuccess();
3194 
3195       case IO:
3196         return getIo();
3197 
3198       }
3199       throw new IllegalStateException();
3200     }
3201 
3202     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
3203     public boolean isSet(_Fields field) {
3204       if (field == null) {
3205         throw new IllegalArgumentException();
3206       }
3207 
3208       switch (field) {
3209       case SUCCESS:
3210         return isSetSuccess();
3211       case IO:
3212         return isSetIo();
3213       }
3214       throw new IllegalStateException();
3215     }
3216 
3217     @Override
3218     public boolean equals(Object that) {
3219       if (that == null)
3220         return false;
3221       if (that instanceof get_result)
3222         return this.equals((get_result)that);
3223       return false;
3224     }
3225 
3226     public boolean equals(get_result that) {
3227       if (that == null)
3228         return false;
3229 
3230       boolean this_present_success = true && this.isSetSuccess();
3231       boolean that_present_success = true && that.isSetSuccess();
3232       if (this_present_success || that_present_success) {
3233         if (!(this_present_success && that_present_success))
3234           return false;
3235         if (!this.success.equals(that.success))
3236           return false;
3237       }
3238 
3239       boolean this_present_io = true && this.isSetIo();
3240       boolean that_present_io = true && that.isSetIo();
3241       if (this_present_io || that_present_io) {
3242         if (!(this_present_io && that_present_io))
3243           return false;
3244         if (!this.io.equals(that.io))
3245           return false;
3246       }
3247 
3248       return true;
3249     }
3250 
3251     @Override
3252     public int hashCode() {
3253       return 0;
3254     }
3255 
3256     public int compareTo(get_result other) {
3257       if (!getClass().equals(other.getClass())) {
3258         return getClass().getName().compareTo(other.getClass().getName());
3259       }
3260 
3261       int lastComparison = 0;
3262       get_result typedOther = (get_result)other;
3263 
3264       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
3265       if (lastComparison != 0) {
3266         return lastComparison;
3267       }
3268       if (isSetSuccess()) {
3269         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
3270         if (lastComparison != 0) {
3271           return lastComparison;
3272         }
3273       }
3274       lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
3275       if (lastComparison != 0) {
3276         return lastComparison;
3277       }
3278       if (isSetIo()) {
3279         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
3280         if (lastComparison != 0) {
3281           return lastComparison;
3282         }
3283       }
3284       return 0;
3285     }
3286 
3287     public _Fields fieldForId(int fieldId) {
3288       return _Fields.findByThriftId(fieldId);
3289     }
3290 
3291     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3292       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3293     }
3294 
3295     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3296       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3297       }
3298 
3299     @Override
3300     public String toString() {
3301       StringBuilder sb = new StringBuilder("get_result(");
3302       boolean first = true;
3303 
3304       sb.append("success:");
3305       if (this.success == null) {
3306         sb.append("null");
3307       } else {
3308         sb.append(this.success);
3309       }
3310       first = false;
3311       if (!first) sb.append(", ");
3312       sb.append("io:");
3313       if (this.io == null) {
3314         sb.append("null");
3315       } else {
3316         sb.append(this.io);
3317       }
3318       first = false;
3319       sb.append(")");
3320       return sb.toString();
3321     }
3322 
3323     public void validate() throws org.apache.thrift.TException {
3324       // check for required fields
3325     }
3326 
3327     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3328       try {
3329         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3330       } catch (org.apache.thrift.TException te) {
3331         throw new java.io.IOException(te);
3332       }
3333     }
3334 
3335     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3336       try {
3337         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3338       } catch (org.apache.thrift.TException te) {
3339         throw new java.io.IOException(te);
3340       }
3341     }
3342 
3343     private static class get_resultStandardSchemeFactory implements SchemeFactory {
3344       public get_resultStandardScheme getScheme() {
3345         return new get_resultStandardScheme();
3346       }
3347     }
3348 
3349     private static class get_resultStandardScheme extends StandardScheme<get_result> {
3350 
3351       public void read(org.apache.thrift.protocol.TProtocol iprot, get_result struct) throws org.apache.thrift.TException {
3352         org.apache.thrift.protocol.TField schemeField;
3353         iprot.readStructBegin();
3354         while (true)
3355         {
3356           schemeField = iprot.readFieldBegin();
3357           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
3358             break;
3359           }
3360           switch (schemeField.id) {
3361             case 0: // SUCCESS
3362               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3363                 struct.success = new TResult();
3364                 struct.success.read(iprot);
3365                 struct.setSuccessIsSet(true);
3366               } else { 
3367                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3368               }
3369               break;
3370             case 1: // IO
3371               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
3372                 struct.io = new TIOError();
3373                 struct.io.read(iprot);
3374                 struct.setIoIsSet(true);
3375               } else { 
3376                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3377               }
3378               break;
3379             default:
3380               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3381           }
3382           iprot.readFieldEnd();
3383         }
3384         iprot.readStructEnd();
3385 
3386         // check for required fields of primitive type, which can't be checked in the validate method
3387         struct.validate();
3388       }
3389 
3390       public void write(org.apache.thrift.protocol.TProtocol oprot, get_result struct) throws org.apache.thrift.TException {
3391         struct.validate();
3392 
3393         oprot.writeStructBegin(STRUCT_DESC);
3394         if (struct.success != null) {
3395           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3396           struct.success.write(oprot);
3397           oprot.writeFieldEnd();
3398         }
3399         if (struct.io != null) {
3400           oprot.writeFieldBegin(IO_FIELD_DESC);
3401           struct.io.write(oprot);
3402           oprot.writeFieldEnd();
3403         }
3404         oprot.writeFieldStop();
3405         oprot.writeStructEnd();
3406       }
3407 
3408     }
3409 
3410     private static class get_resultTupleSchemeFactory implements SchemeFactory {
3411       public get_resultTupleScheme getScheme() {
3412         return new get_resultTupleScheme();
3413       }
3414     }
3415 
3416     private static class get_resultTupleScheme extends TupleScheme<get_result> {
3417 
3418       @Override
3419       public void write(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3420         TTupleProtocol oprot = (TTupleProtocol) prot;
3421         BitSet optionals = new BitSet();
3422         if (struct.isSetSuccess()) {
3423           optionals.set(0);
3424         }
3425         if (struct.isSetIo()) {
3426           optionals.set(1);
3427         }
3428         oprot.writeBitSet(optionals, 2);
3429         if (struct.isSetSuccess()) {
3430           struct.success.write(oprot);
3431         }
3432         if (struct.isSetIo()) {
3433           struct.io.write(oprot);
3434         }
3435       }
3436 
3437       @Override
3438       public void read(org.apache.thrift.protocol.TProtocol prot, get_result struct) throws org.apache.thrift.TException {
3439         TTupleProtocol iprot = (TTupleProtocol) prot;
3440         BitSet incoming = iprot.readBitSet(2);
3441         if (incoming.get(0)) {
3442           struct.success = new TResult();
3443           struct.success.read(iprot);
3444           struct.setSuccessIsSet(true);
3445         }
3446         if (incoming.get(1)) {
3447           struct.io = new TIOError();
3448           struct.io.read(iprot);
3449           struct.setIoIsSet(true);
3450         }
3451       }
3452     }
3453 
3454   }
3455 
3456   public static class getMultiple_args implements org.apache.thrift.TBase<getMultiple_args, getMultiple_args._Fields>, java.io.Serializable, Cloneable   {
3457     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_args");
3458 
3459     private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
3460     private static final org.apache.thrift.protocol.TField GETS_FIELD_DESC = new org.apache.thrift.protocol.TField("gets", org.apache.thrift.protocol.TType.LIST, (short)2);
3461 
3462     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
3463     static {
3464       schemes.put(StandardScheme.class, new getMultiple_argsStandardSchemeFactory());
3465       schemes.put(TupleScheme.class, new getMultiple_argsTupleSchemeFactory());
3466     }
3467 
3468     /**
3469      * the table to get from
3470      */
3471     public ByteBuffer table; // required
3472     /**
3473      * a list of TGets to fetch, the Result list
3474      * will have the Results at corresponding positions
3475      * or null if there was an error
3476      */
3477     public List<TGet> gets; // required
3478 
3479     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
3480     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
3481       /**
3482        * the table to get from
3483        */
3484       TABLE((short)1, "table"),
3485       /**
3486        * a list of TGets to fetch, the Result list
3487        * will have the Results at corresponding positions
3488        * or null if there was an error
3489        */
3490       GETS((short)2, "gets");
3491 
3492       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3493 
3494       static {
3495         for (_Fields field : EnumSet.allOf(_Fields.class)) {
3496           byName.put(field.getFieldName(), field);
3497         }
3498       }
3499 
3500       /**
3501        * Find the _Fields constant that matches fieldId, or null if its not found.
3502        */
3503       public static _Fields findByThriftId(int fieldId) {
3504         switch(fieldId) {
3505           case 1: // TABLE
3506             return TABLE;
3507           case 2: // GETS
3508             return GETS;
3509           default:
3510             return null;
3511         }
3512       }
3513 
3514       /**
3515        * Find the _Fields constant that matches fieldId, throwing an exception
3516        * if it is not found.
3517        */
3518       public static _Fields findByThriftIdOrThrow(int fieldId) {
3519         _Fields fields = findByThriftId(fieldId);
3520         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3521         return fields;
3522       }
3523 
3524       /**
3525        * Find the _Fields constant that matches name, or null if its not found.
3526        */
3527       public static _Fields findByName(String name) {
3528         return byName.get(name);
3529       }
3530 
3531       private final short _thriftId;
3532       private final String _fieldName;
3533 
3534       _Fields(short thriftId, String fieldName) {
3535         _thriftId = thriftId;
3536         _fieldName = fieldName;
3537       }
3538 
3539       public short getThriftFieldId() {
3540         return _thriftId;
3541       }
3542 
3543       public String getFieldName() {
3544         return _fieldName;
3545       }
3546     }
3547 
3548     // isset id assignments
3549     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
3550     static {
3551       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
3552       tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED, 
3553           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
3554       tmpMap.put(_Fields.GETS, new org.apache.thrift.meta_data.FieldMetaData("gets", org.apache.thrift.TFieldRequirementType.REQUIRED, 
3555           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
3556               new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGet.class))));
3557       metaDataMap = Collections.unmodifiableMap(tmpMap);
3558       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_args.class, metaDataMap);
3559     }
3560 
3561     public getMultiple_args() {
3562     }
3563 
3564     public getMultiple_args(
3565       ByteBuffer table,
3566       List<TGet> gets)
3567     {
3568       this();
3569       this.table = table;
3570       this.gets = gets;
3571     }
3572 
3573     /**
3574      * Performs a deep copy on <i>other</i>.
3575      */
3576     public getMultiple_args(getMultiple_args other) {
3577       if (other.isSetTable()) {
3578         this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
3579 ;
3580       }
3581       if (other.isSetGets()) {
3582         List<TGet> __this__gets = new ArrayList<TGet>();
3583         for (TGet other_element : other.gets) {
3584           __this__gets.add(new TGet(other_element));
3585         }
3586         this.gets = __this__gets;
3587       }
3588     }
3589 
3590     public getMultiple_args deepCopy() {
3591       return new getMultiple_args(this);
3592     }
3593 
3594     @Override
3595     public void clear() {
3596       this.table = null;
3597       this.gets = null;
3598     }
3599 
3600     /**
3601      * the table to get from
3602      */
3603     public byte[] getTable() {
3604       setTable(org.apache.thrift.TBaseHelper.rightSize(table));
3605       return table == null ? null : table.array();
3606     }
3607 
3608     public ByteBuffer bufferForTable() {
3609       return table;
3610     }
3611 
3612     /**
3613      * the table to get from
3614      */
3615     public getMultiple_args setTable(byte[] table) {
3616       setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
3617       return this;
3618     }
3619 
3620     public getMultiple_args setTable(ByteBuffer table) {
3621       this.table = table;
3622       return this;
3623     }
3624 
3625     public void unsetTable() {
3626       this.table = null;
3627     }
3628 
3629     /** Returns true if field table is set (has been assigned a value) and false otherwise */
3630     public boolean isSetTable() {
3631       return this.table != null;
3632     }
3633 
3634     public void setTableIsSet(boolean value) {
3635       if (!value) {
3636         this.table = null;
3637       }
3638     }
3639 
3640     public int getGetsSize() {
3641       return (this.gets == null) ? 0 : this.gets.size();
3642     }
3643 
3644     public java.util.Iterator<TGet> getGetsIterator() {
3645       return (this.gets == null) ? null : this.gets.iterator();
3646     }
3647 
3648     public void addToGets(TGet elem) {
3649       if (this.gets == null) {
3650         this.gets = new ArrayList<TGet>();
3651       }
3652       this.gets.add(elem);
3653     }
3654 
3655     /**
3656      * a list of TGets to fetch, the Result list
3657      * will have the Results at corresponding positions
3658      * or null if there was an error
3659      */
3660     public List<TGet> getGets() {
3661       return this.gets;
3662     }
3663 
3664     /**
3665      * a list of TGets to fetch, the Result list
3666      * will have the Results at corresponding positions
3667      * or null if there was an error
3668      */
3669     public getMultiple_args setGets(List<TGet> gets) {
3670       this.gets = gets;
3671       return this;
3672     }
3673 
3674     public void unsetGets() {
3675       this.gets = null;
3676     }
3677 
3678     /** Returns true if field gets is set (has been assigned a value) and false otherwise */
3679     public boolean isSetGets() {
3680       return this.gets != null;
3681     }
3682 
3683     public void setGetsIsSet(boolean value) {
3684       if (!value) {
3685         this.gets = null;
3686       }
3687     }
3688 
3689     public void setFieldValue(_Fields field, Object value) {
3690       switch (field) {
3691       case TABLE:
3692         if (value == null) {
3693           unsetTable();
3694         } else {
3695           setTable((ByteBuffer)value);
3696         }
3697         break;
3698 
3699       case GETS:
3700         if (value == null) {
3701           unsetGets();
3702         } else {
3703           setGets((List<TGet>)value);
3704         }
3705         break;
3706 
3707       }
3708     }
3709 
3710     public Object getFieldValue(_Fields field) {
3711       switch (field) {
3712       case TABLE:
3713         return getTable();
3714 
3715       case GETS:
3716         return getGets();
3717 
3718       }
3719       throw new IllegalStateException();
3720     }
3721 
3722     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
3723     public boolean isSet(_Fields field) {
3724       if (field == null) {
3725         throw new IllegalArgumentException();
3726       }
3727 
3728       switch (field) {
3729       case TABLE:
3730         return isSetTable();
3731       case GETS:
3732         return isSetGets();
3733       }
3734       throw new IllegalStateException();
3735     }
3736 
3737     @Override
3738     public boolean equals(Object that) {
3739       if (that == null)
3740         return false;
3741       if (that instanceof getMultiple_args)
3742         return this.equals((getMultiple_args)that);
3743       return false;
3744     }
3745 
3746     public boolean equals(getMultiple_args that) {
3747       if (that == null)
3748         return false;
3749 
3750       boolean this_present_table = true && this.isSetTable();
3751       boolean that_present_table = true && that.isSetTable();
3752       if (this_present_table || that_present_table) {
3753         if (!(this_present_table && that_present_table))
3754           return false;
3755         if (!this.table.equals(that.table))
3756           return false;
3757       }
3758 
3759       boolean this_present_gets = true && this.isSetGets();
3760       boolean that_present_gets = true && that.isSetGets();
3761       if (this_present_gets || that_present_gets) {
3762         if (!(this_present_gets && that_present_gets))
3763           return false;
3764         if (!this.gets.equals(that.gets))
3765           return false;
3766       }
3767 
3768       return true;
3769     }
3770 
3771     @Override
3772     public int hashCode() {
3773       return 0;
3774     }
3775 
3776     public int compareTo(getMultiple_args other) {
3777       if (!getClass().equals(other.getClass())) {
3778         return getClass().getName().compareTo(other.getClass().getName());
3779       }
3780 
3781       int lastComparison = 0;
3782       getMultiple_args typedOther = (getMultiple_args)other;
3783 
3784       lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
3785       if (lastComparison != 0) {
3786         return lastComparison;
3787       }
3788       if (isSetTable()) {
3789         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
3790         if (lastComparison != 0) {
3791           return lastComparison;
3792         }
3793       }
3794       lastComparison = Boolean.valueOf(isSetGets()).compareTo(typedOther.isSetGets());
3795       if (lastComparison != 0) {
3796         return lastComparison;
3797       }
3798       if (isSetGets()) {
3799         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gets, typedOther.gets);
3800         if (lastComparison != 0) {
3801           return lastComparison;
3802         }
3803       }
3804       return 0;
3805     }
3806 
3807     public _Fields fieldForId(int fieldId) {
3808       return _Fields.findByThriftId(fieldId);
3809     }
3810 
3811     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
3812       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3813     }
3814 
3815     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
3816       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3817     }
3818 
3819     @Override
3820     public String toString() {
3821       StringBuilder sb = new StringBuilder("getMultiple_args(");
3822       boolean first = true;
3823 
3824       sb.append("table:");
3825       if (this.table == null) {
3826         sb.append("null");
3827       } else {
3828         org.apache.thrift.TBaseHelper.toString(this.table, sb);
3829       }
3830       first = false;
3831       if (!first) sb.append(", ");
3832       sb.append("gets:");
3833       if (this.gets == null) {
3834         sb.append("null");
3835       } else {
3836         sb.append(this.gets);
3837       }
3838       first = false;
3839       sb.append(")");
3840       return sb.toString();
3841     }
3842 
3843     public void validate() throws org.apache.thrift.TException {
3844       // check for required fields
3845       if (table == null) {
3846         throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
3847       }
3848       if (gets == null) {
3849         throw new org.apache.thrift.protocol.TProtocolException("Required field 'gets' was not present! Struct: " + toString());
3850       }
3851     }
3852 
3853     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
3854       try {
3855         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
3856       } catch (org.apache.thrift.TException te) {
3857         throw new java.io.IOException(te);
3858       }
3859     }
3860 
3861     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
3862       try {
3863         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
3864       } catch (org.apache.thrift.TException te) {
3865         throw new java.io.IOException(te);
3866       }
3867     }
3868 
3869     private static class getMultiple_argsStandardSchemeFactory implements SchemeFactory {
3870       public getMultiple_argsStandardScheme getScheme() {
3871         return new getMultiple_argsStandardScheme();
3872       }
3873     }
3874 
3875     private static class getMultiple_argsStandardScheme extends StandardScheme<getMultiple_args> {
3876 
3877       public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_args struct) throws org.apache.thrift.TException {
3878         org.apache.thrift.protocol.TField schemeField;
3879         iprot.readStructBegin();
3880         while (true)
3881         {
3882           schemeField = iprot.readFieldBegin();
3883           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
3884             break;
3885           }
3886           switch (schemeField.id) {
3887             case 1: // TABLE
3888               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
3889                 struct.table = iprot.readBinary();
3890                 struct.setTableIsSet(true);
3891               } else { 
3892                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3893               }
3894               break;
3895             case 2: // GETS
3896               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
3897                 {
3898                   org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
3899                   struct.gets = new ArrayList<TGet>(_list96.size);
3900                   for (int _i97 = 0; _i97 < _list96.size; ++_i97)
3901                   {
3902                     TGet _elem98; // required
3903                     _elem98 = new TGet();
3904                     _elem98.read(iprot);
3905                     struct.gets.add(_elem98);
3906                   }
3907                   iprot.readListEnd();
3908                 }
3909                 struct.setGetsIsSet(true);
3910               } else { 
3911                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3912               }
3913               break;
3914             default:
3915               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
3916           }
3917           iprot.readFieldEnd();
3918         }
3919         iprot.readStructEnd();
3920 
3921         // check for required fields of primitive type, which can't be checked in the validate method
3922         struct.validate();
3923       }
3924 
3925       public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_args struct) throws org.apache.thrift.TException {
3926         struct.validate();
3927 
3928         oprot.writeStructBegin(STRUCT_DESC);
3929         if (struct.table != null) {
3930           oprot.writeFieldBegin(TABLE_FIELD_DESC);
3931           oprot.writeBinary(struct.table);
3932           oprot.writeFieldEnd();
3933         }
3934         if (struct.gets != null) {
3935           oprot.writeFieldBegin(GETS_FIELD_DESC);
3936           {
3937             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.gets.size()));
3938             for (TGet _iter99 : struct.gets)
3939             {
3940               _iter99.write(oprot);
3941             }
3942             oprot.writeListEnd();
3943           }
3944           oprot.writeFieldEnd();
3945         }
3946         oprot.writeFieldStop();
3947         oprot.writeStructEnd();
3948       }
3949 
3950     }
3951 
3952     private static class getMultiple_argsTupleSchemeFactory implements SchemeFactory {
3953       public getMultiple_argsTupleScheme getScheme() {
3954         return new getMultiple_argsTupleScheme();
3955       }
3956     }
3957 
3958     private static class getMultiple_argsTupleScheme extends TupleScheme<getMultiple_args> {
3959 
3960       @Override
3961       public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3962         TTupleProtocol oprot = (TTupleProtocol) prot;
3963         oprot.writeBinary(struct.table);
3964         {
3965           oprot.writeI32(struct.gets.size());
3966           for (TGet _iter100 : struct.gets)
3967           {
3968             _iter100.write(oprot);
3969           }
3970         }
3971       }
3972 
3973       @Override
3974       public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_args struct) throws org.apache.thrift.TException {
3975         TTupleProtocol iprot = (TTupleProtocol) prot;
3976         struct.table = iprot.readBinary();
3977         struct.setTableIsSet(true);
3978         {
3979           org.apache.thrift.protocol.TList _list101 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
3980           struct.gets = new ArrayList<TGet>(_list101.size);
3981           for (int _i102 = 0; _i102 < _list101.size; ++_i102)
3982           {
3983             TGet _elem103; // required
3984             _elem103 = new TGet();
3985             _elem103.read(iprot);
3986             struct.gets.add(_elem103);
3987           }
3988         }
3989         struct.setGetsIsSet(true);
3990       }
3991     }
3992 
3993   }
3994 
3995   public static class getMultiple_result implements org.apache.thrift.TBase<getMultiple_result, getMultiple_result._Fields>, java.io.Serializable, Cloneable   {
3996     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMultiple_result");
3997 
3998     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
3999     private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
4000 
4001     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4002     static {
4003       schemes.put(StandardScheme.class, new getMultiple_resultStandardSchemeFactory());
4004       schemes.put(TupleScheme.class, new getMultiple_resultTupleSchemeFactory());
4005     }
4006 
4007     public List<TResult> success; // required
4008     public TIOError io; // required
4009 
4010     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4011     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4012       SUCCESS((short)0, "success"),
4013       IO((short)1, "io");
4014 
4015       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4016 
4017       static {
4018         for (_Fields field : EnumSet.allOf(_Fields.class)) {
4019           byName.put(field.getFieldName(), field);
4020         }
4021       }
4022 
4023       /**
4024        * Find the _Fields constant that matches fieldId, or null if its not found.
4025        */
4026       public static _Fields findByThriftId(int fieldId) {
4027         switch(fieldId) {
4028           case 0: // SUCCESS
4029             return SUCCESS;
4030           case 1: // IO
4031             return IO;
4032           default:
4033             return null;
4034         }
4035       }
4036 
4037       /**
4038        * Find the _Fields constant that matches fieldId, throwing an exception
4039        * if it is not found.
4040        */
4041       public static _Fields findByThriftIdOrThrow(int fieldId) {
4042         _Fields fields = findByThriftId(fieldId);
4043         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4044         return fields;
4045       }
4046 
4047       /**
4048        * Find the _Fields constant that matches name, or null if its not found.
4049        */
4050       public static _Fields findByName(String name) {
4051         return byName.get(name);
4052       }
4053 
4054       private final short _thriftId;
4055       private final String _fieldName;
4056 
4057       _Fields(short thriftId, String fieldName) {
4058         _thriftId = thriftId;
4059         _fieldName = fieldName;
4060       }
4061 
4062       public short getThriftFieldId() {
4063         return _thriftId;
4064       }
4065 
4066       public String getFieldName() {
4067         return _fieldName;
4068       }
4069     }
4070 
4071     // isset id assignments
4072     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4073     static {
4074       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4075       tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
4076           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
4077               new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TResult.class))));
4078       tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, 
4079           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
4080       metaDataMap = Collections.unmodifiableMap(tmpMap);
4081       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMultiple_result.class, metaDataMap);
4082     }
4083 
4084     public getMultiple_result() {
4085     }
4086 
4087     public getMultiple_result(
4088       List<TResult> success,
4089       TIOError io)
4090     {
4091       this();
4092       this.success = success;
4093       this.io = io;
4094     }
4095 
4096     /**
4097      * Performs a deep copy on <i>other</i>.
4098      */
4099     public getMultiple_result(getMultiple_result other) {
4100       if (other.isSetSuccess()) {
4101         List<TResult> __this__success = new ArrayList<TResult>();
4102         for (TResult other_element : other.success) {
4103           __this__success.add(new TResult(other_element));
4104         }
4105         this.success = __this__success;
4106       }
4107       if (other.isSetIo()) {
4108         this.io = new TIOError(other.io);
4109       }
4110     }
4111 
4112     public getMultiple_result deepCopy() {
4113       return new getMultiple_result(this);
4114     }
4115 
4116     @Override
4117     public void clear() {
4118       this.success = null;
4119       this.io = null;
4120     }
4121 
4122     public int getSuccessSize() {
4123       return (this.success == null) ? 0 : this.success.size();
4124     }
4125 
4126     public java.util.Iterator<TResult> getSuccessIterator() {
4127       return (this.success == null) ? null : this.success.iterator();
4128     }
4129 
4130     public void addToSuccess(TResult elem) {
4131       if (this.success == null) {
4132         this.success = new ArrayList<TResult>();
4133       }
4134       this.success.add(elem);
4135     }
4136 
4137     public List<TResult> getSuccess() {
4138       return this.success;
4139     }
4140 
4141     public getMultiple_result setSuccess(List<TResult> success) {
4142       this.success = success;
4143       return this;
4144     }
4145 
4146     public void unsetSuccess() {
4147       this.success = null;
4148     }
4149 
4150     /** Returns true if field success is set (has been assigned a value) and false otherwise */
4151     public boolean isSetSuccess() {
4152       return this.success != null;
4153     }
4154 
4155     public void setSuccessIsSet(boolean value) {
4156       if (!value) {
4157         this.success = null;
4158       }
4159     }
4160 
4161     public TIOError getIo() {
4162       return this.io;
4163     }
4164 
4165     public getMultiple_result setIo(TIOError io) {
4166       this.io = io;
4167       return this;
4168     }
4169 
4170     public void unsetIo() {
4171       this.io = null;
4172     }
4173 
4174     /** Returns true if field io is set (has been assigned a value) and false otherwise */
4175     public boolean isSetIo() {
4176       return this.io != null;
4177     }
4178 
4179     public void setIoIsSet(boolean value) {
4180       if (!value) {
4181         this.io = null;
4182       }
4183     }
4184 
4185     public void setFieldValue(_Fields field, Object value) {
4186       switch (field) {
4187       case SUCCESS:
4188         if (value == null) {
4189           unsetSuccess();
4190         } else {
4191           setSuccess((List<TResult>)value);
4192         }
4193         break;
4194 
4195       case IO:
4196         if (value == null) {
4197           unsetIo();
4198         } else {
4199           setIo((TIOError)value);
4200         }
4201         break;
4202 
4203       }
4204     }
4205 
4206     public Object getFieldValue(_Fields field) {
4207       switch (field) {
4208       case SUCCESS:
4209         return getSuccess();
4210 
4211       case IO:
4212         return getIo();
4213 
4214       }
4215       throw new IllegalStateException();
4216     }
4217 
4218     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
4219     public boolean isSet(_Fields field) {
4220       if (field == null) {
4221         throw new IllegalArgumentException();
4222       }
4223 
4224       switch (field) {
4225       case SUCCESS:
4226         return isSetSuccess();
4227       case IO:
4228         return isSetIo();
4229       }
4230       throw new IllegalStateException();
4231     }
4232 
4233     @Override
4234     public boolean equals(Object that) {
4235       if (that == null)
4236         return false;
4237       if (that instanceof getMultiple_result)
4238         return this.equals((getMultiple_result)that);
4239       return false;
4240     }
4241 
4242     public boolean equals(getMultiple_result that) {
4243       if (that == null)
4244         return false;
4245 
4246       boolean this_present_success = true && this.isSetSuccess();
4247       boolean that_present_success = true && that.isSetSuccess();
4248       if (this_present_success || that_present_success) {
4249         if (!(this_present_success && that_present_success))
4250           return false;
4251         if (!this.success.equals(that.success))
4252           return false;
4253       }
4254 
4255       boolean this_present_io = true && this.isSetIo();
4256       boolean that_present_io = true && that.isSetIo();
4257       if (this_present_io || that_present_io) {
4258         if (!(this_present_io && that_present_io))
4259           return false;
4260         if (!this.io.equals(that.io))
4261           return false;
4262       }
4263 
4264       return true;
4265     }
4266 
4267     @Override
4268     public int hashCode() {
4269       return 0;
4270     }
4271 
4272     public int compareTo(getMultiple_result other) {
4273       if (!getClass().equals(other.getClass())) {
4274         return getClass().getName().compareTo(other.getClass().getName());
4275       }
4276 
4277       int lastComparison = 0;
4278       getMultiple_result typedOther = (getMultiple_result)other;
4279 
4280       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
4281       if (lastComparison != 0) {
4282         return lastComparison;
4283       }
4284       if (isSetSuccess()) {
4285         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
4286         if (lastComparison != 0) {
4287           return lastComparison;
4288         }
4289       }
4290       lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
4291       if (lastComparison != 0) {
4292         return lastComparison;
4293       }
4294       if (isSetIo()) {
4295         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
4296         if (lastComparison != 0) {
4297           return lastComparison;
4298         }
4299       }
4300       return 0;
4301     }
4302 
4303     public _Fields fieldForId(int fieldId) {
4304       return _Fields.findByThriftId(fieldId);
4305     }
4306 
4307     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4308       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4309     }
4310 
4311     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4312       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4313       }
4314 
4315     @Override
4316     public String toString() {
4317       StringBuilder sb = new StringBuilder("getMultiple_result(");
4318       boolean first = true;
4319 
4320       sb.append("success:");
4321       if (this.success == null) {
4322         sb.append("null");
4323       } else {
4324         sb.append(this.success);
4325       }
4326       first = false;
4327       if (!first) sb.append(", ");
4328       sb.append("io:");
4329       if (this.io == null) {
4330         sb.append("null");
4331       } else {
4332         sb.append(this.io);
4333       }
4334       first = false;
4335       sb.append(")");
4336       return sb.toString();
4337     }
4338 
4339     public void validate() throws org.apache.thrift.TException {
4340       // check for required fields
4341     }
4342 
4343     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4344       try {
4345         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4346       } catch (org.apache.thrift.TException te) {
4347         throw new java.io.IOException(te);
4348       }
4349     }
4350 
4351     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4352       try {
4353         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4354       } catch (org.apache.thrift.TException te) {
4355         throw new java.io.IOException(te);
4356       }
4357     }
4358 
4359     private static class getMultiple_resultStandardSchemeFactory implements SchemeFactory {
4360       public getMultiple_resultStandardScheme getScheme() {
4361         return new getMultiple_resultStandardScheme();
4362       }
4363     }
4364 
4365     private static class getMultiple_resultStandardScheme extends StandardScheme<getMultiple_result> {
4366 
4367       public void read(org.apache.thrift.protocol.TProtocol iprot, getMultiple_result struct) throws org.apache.thrift.TException {
4368         org.apache.thrift.protocol.TField schemeField;
4369         iprot.readStructBegin();
4370         while (true)
4371         {
4372           schemeField = iprot.readFieldBegin();
4373           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
4374             break;
4375           }
4376           switch (schemeField.id) {
4377             case 0: // SUCCESS
4378               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
4379                 {
4380                   org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();
4381                   struct.success = new ArrayList<TResult>(_list104.size);
4382                   for (int _i105 = 0; _i105 < _list104.size; ++_i105)
4383                   {
4384                     TResult _elem106; // required
4385                     _elem106 = new TResult();
4386                     _elem106.read(iprot);
4387                     struct.success.add(_elem106);
4388                   }
4389                   iprot.readListEnd();
4390                 }
4391                 struct.setSuccessIsSet(true);
4392               } else { 
4393                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4394               }
4395               break;
4396             case 1: // IO
4397               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4398                 struct.io = new TIOError();
4399                 struct.io.read(iprot);
4400                 struct.setIoIsSet(true);
4401               } else { 
4402                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4403               }
4404               break;
4405             default:
4406               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4407           }
4408           iprot.readFieldEnd();
4409         }
4410         iprot.readStructEnd();
4411 
4412         // check for required fields of primitive type, which can't be checked in the validate method
4413         struct.validate();
4414       }
4415 
4416       public void write(org.apache.thrift.protocol.TProtocol oprot, getMultiple_result struct) throws org.apache.thrift.TException {
4417         struct.validate();
4418 
4419         oprot.writeStructBegin(STRUCT_DESC);
4420         if (struct.success != null) {
4421           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4422           {
4423             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
4424             for (TResult _iter107 : struct.success)
4425             {
4426               _iter107.write(oprot);
4427             }
4428             oprot.writeListEnd();
4429           }
4430           oprot.writeFieldEnd();
4431         }
4432         if (struct.io != null) {
4433           oprot.writeFieldBegin(IO_FIELD_DESC);
4434           struct.io.write(oprot);
4435           oprot.writeFieldEnd();
4436         }
4437         oprot.writeFieldStop();
4438         oprot.writeStructEnd();
4439       }
4440 
4441     }
4442 
4443     private static class getMultiple_resultTupleSchemeFactory implements SchemeFactory {
4444       public getMultiple_resultTupleScheme getScheme() {
4445         return new getMultiple_resultTupleScheme();
4446       }
4447     }
4448 
4449     private static class getMultiple_resultTupleScheme extends TupleScheme<getMultiple_result> {
4450 
4451       @Override
4452       public void write(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4453         TTupleProtocol oprot = (TTupleProtocol) prot;
4454         BitSet optionals = new BitSet();
4455         if (struct.isSetSuccess()) {
4456           optionals.set(0);
4457         }
4458         if (struct.isSetIo()) {
4459           optionals.set(1);
4460         }
4461         oprot.writeBitSet(optionals, 2);
4462         if (struct.isSetSuccess()) {
4463           {
4464             oprot.writeI32(struct.success.size());
4465             for (TResult _iter108 : struct.success)
4466             {
4467               _iter108.write(oprot);
4468             }
4469           }
4470         }
4471         if (struct.isSetIo()) {
4472           struct.io.write(oprot);
4473         }
4474       }
4475 
4476       @Override
4477       public void read(org.apache.thrift.protocol.TProtocol prot, getMultiple_result struct) throws org.apache.thrift.TException {
4478         TTupleProtocol iprot = (TTupleProtocol) prot;
4479         BitSet incoming = iprot.readBitSet(2);
4480         if (incoming.get(0)) {
4481           {
4482             org.apache.thrift.protocol.TList _list109 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
4483             struct.success = new ArrayList<TResult>(_list109.size);
4484             for (int _i110 = 0; _i110 < _list109.size; ++_i110)
4485             {
4486               TResult _elem111; // required
4487               _elem111 = new TResult();
4488               _elem111.read(iprot);
4489               struct.success.add(_elem111);
4490             }
4491           }
4492           struct.setSuccessIsSet(true);
4493         }
4494         if (incoming.get(1)) {
4495           struct.io = new TIOError();
4496           struct.io.read(iprot);
4497           struct.setIoIsSet(true);
4498         }
4499       }
4500     }
4501 
4502   }
4503 
4504   public static class put_args implements org.apache.thrift.TBase<put_args, put_args._Fields>, java.io.Serializable, Cloneable   {
4505     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_args");
4506 
4507     private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
4508     private static final org.apache.thrift.protocol.TField PUT_FIELD_DESC = new org.apache.thrift.protocol.TField("put", org.apache.thrift.protocol.TType.STRUCT, (short)2);
4509 
4510     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4511     static {
4512       schemes.put(StandardScheme.class, new put_argsStandardSchemeFactory());
4513       schemes.put(TupleScheme.class, new put_argsTupleSchemeFactory());
4514     }
4515 
4516     /**
4517      * the table to put data in
4518      */
4519     public ByteBuffer table; // required
4520     /**
4521      * the TPut to put
4522      */
4523     public TPut put; // required
4524 
4525     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4526     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4527       /**
4528        * the table to put data in
4529        */
4530       TABLE((short)1, "table"),
4531       /**
4532        * the TPut to put
4533        */
4534       PUT((short)2, "put");
4535 
4536       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4537 
4538       static {
4539         for (_Fields field : EnumSet.allOf(_Fields.class)) {
4540           byName.put(field.getFieldName(), field);
4541         }
4542       }
4543 
4544       /**
4545        * Find the _Fields constant that matches fieldId, or null if its not found.
4546        */
4547       public static _Fields findByThriftId(int fieldId) {
4548         switch(fieldId) {
4549           case 1: // TABLE
4550             return TABLE;
4551           case 2: // PUT
4552             return PUT;
4553           default:
4554             return null;
4555         }
4556       }
4557 
4558       /**
4559        * Find the _Fields constant that matches fieldId, throwing an exception
4560        * if it is not found.
4561        */
4562       public static _Fields findByThriftIdOrThrow(int fieldId) {
4563         _Fields fields = findByThriftId(fieldId);
4564         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4565         return fields;
4566       }
4567 
4568       /**
4569        * Find the _Fields constant that matches name, or null if its not found.
4570        */
4571       public static _Fields findByName(String name) {
4572         return byName.get(name);
4573       }
4574 
4575       private final short _thriftId;
4576       private final String _fieldName;
4577 
4578       _Fields(short thriftId, String fieldName) {
4579         _thriftId = thriftId;
4580         _fieldName = fieldName;
4581       }
4582 
4583       public short getThriftFieldId() {
4584         return _thriftId;
4585       }
4586 
4587       public String getFieldName() {
4588         return _fieldName;
4589       }
4590     }
4591 
4592     // isset id assignments
4593     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
4594     static {
4595       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
4596       tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED, 
4597           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
4598       tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED, 
4599           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
4600       metaDataMap = Collections.unmodifiableMap(tmpMap);
4601       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_args.class, metaDataMap);
4602     }
4603 
4604     public put_args() {
4605     }
4606 
4607     public put_args(
4608       ByteBuffer table,
4609       TPut put)
4610     {
4611       this();
4612       this.table = table;
4613       this.put = put;
4614     }
4615 
4616     /**
4617      * Performs a deep copy on <i>other</i>.
4618      */
4619     public put_args(put_args other) {
4620       if (other.isSetTable()) {
4621         this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
4622 ;
4623       }
4624       if (other.isSetPut()) {
4625         this.put = new TPut(other.put);
4626       }
4627     }
4628 
4629     public put_args deepCopy() {
4630       return new put_args(this);
4631     }
4632 
4633     @Override
4634     public void clear() {
4635       this.table = null;
4636       this.put = null;
4637     }
4638 
4639     /**
4640      * the table to put data in
4641      */
4642     public byte[] getTable() {
4643       setTable(org.apache.thrift.TBaseHelper.rightSize(table));
4644       return table == null ? null : table.array();
4645     }
4646 
4647     public ByteBuffer bufferForTable() {
4648       return table;
4649     }
4650 
4651     /**
4652      * the table to put data in
4653      */
4654     public put_args setTable(byte[] table) {
4655       setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
4656       return this;
4657     }
4658 
4659     public put_args setTable(ByteBuffer table) {
4660       this.table = table;
4661       return this;
4662     }
4663 
4664     public void unsetTable() {
4665       this.table = null;
4666     }
4667 
4668     /** Returns true if field table is set (has been assigned a value) and false otherwise */
4669     public boolean isSetTable() {
4670       return this.table != null;
4671     }
4672 
4673     public void setTableIsSet(boolean value) {
4674       if (!value) {
4675         this.table = null;
4676       }
4677     }
4678 
4679     /**
4680      * the TPut to put
4681      */
4682     public TPut getPut() {
4683       return this.put;
4684     }
4685 
4686     /**
4687      * the TPut to put
4688      */
4689     public put_args setPut(TPut put) {
4690       this.put = put;
4691       return this;
4692     }
4693 
4694     public void unsetPut() {
4695       this.put = null;
4696     }
4697 
4698     /** Returns true if field put is set (has been assigned a value) and false otherwise */
4699     public boolean isSetPut() {
4700       return this.put != null;
4701     }
4702 
4703     public void setPutIsSet(boolean value) {
4704       if (!value) {
4705         this.put = null;
4706       }
4707     }
4708 
4709     public void setFieldValue(_Fields field, Object value) {
4710       switch (field) {
4711       case TABLE:
4712         if (value == null) {
4713           unsetTable();
4714         } else {
4715           setTable((ByteBuffer)value);
4716         }
4717         break;
4718 
4719       case PUT:
4720         if (value == null) {
4721           unsetPut();
4722         } else {
4723           setPut((TPut)value);
4724         }
4725         break;
4726 
4727       }
4728     }
4729 
4730     public Object getFieldValue(_Fields field) {
4731       switch (field) {
4732       case TABLE:
4733         return getTable();
4734 
4735       case PUT:
4736         return getPut();
4737 
4738       }
4739       throw new IllegalStateException();
4740     }
4741 
4742     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
4743     public boolean isSet(_Fields field) {
4744       if (field == null) {
4745         throw new IllegalArgumentException();
4746       }
4747 
4748       switch (field) {
4749       case TABLE:
4750         return isSetTable();
4751       case PUT:
4752         return isSetPut();
4753       }
4754       throw new IllegalStateException();
4755     }
4756 
4757     @Override
4758     public boolean equals(Object that) {
4759       if (that == null)
4760         return false;
4761       if (that instanceof put_args)
4762         return this.equals((put_args)that);
4763       return false;
4764     }
4765 
4766     public boolean equals(put_args that) {
4767       if (that == null)
4768         return false;
4769 
4770       boolean this_present_table = true && this.isSetTable();
4771       boolean that_present_table = true && that.isSetTable();
4772       if (this_present_table || that_present_table) {
4773         if (!(this_present_table && that_present_table))
4774           return false;
4775         if (!this.table.equals(that.table))
4776           return false;
4777       }
4778 
4779       boolean this_present_put = true && this.isSetPut();
4780       boolean that_present_put = true && that.isSetPut();
4781       if (this_present_put || that_present_put) {
4782         if (!(this_present_put && that_present_put))
4783           return false;
4784         if (!this.put.equals(that.put))
4785           return false;
4786       }
4787 
4788       return true;
4789     }
4790 
4791     @Override
4792     public int hashCode() {
4793       return 0;
4794     }
4795 
4796     public int compareTo(put_args other) {
4797       if (!getClass().equals(other.getClass())) {
4798         return getClass().getName().compareTo(other.getClass().getName());
4799       }
4800 
4801       int lastComparison = 0;
4802       put_args typedOther = (put_args)other;
4803 
4804       lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
4805       if (lastComparison != 0) {
4806         return lastComparison;
4807       }
4808       if (isSetTable()) {
4809         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
4810         if (lastComparison != 0) {
4811           return lastComparison;
4812         }
4813       }
4814       lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
4815       if (lastComparison != 0) {
4816         return lastComparison;
4817       }
4818       if (isSetPut()) {
4819         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
4820         if (lastComparison != 0) {
4821           return lastComparison;
4822         }
4823       }
4824       return 0;
4825     }
4826 
4827     public _Fields fieldForId(int fieldId) {
4828       return _Fields.findByThriftId(fieldId);
4829     }
4830 
4831     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
4832       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4833     }
4834 
4835     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
4836       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4837     }
4838 
4839     @Override
4840     public String toString() {
4841       StringBuilder sb = new StringBuilder("put_args(");
4842       boolean first = true;
4843 
4844       sb.append("table:");
4845       if (this.table == null) {
4846         sb.append("null");
4847       } else {
4848         org.apache.thrift.TBaseHelper.toString(this.table, sb);
4849       }
4850       first = false;
4851       if (!first) sb.append(", ");
4852       sb.append("put:");
4853       if (this.put == null) {
4854         sb.append("null");
4855       } else {
4856         sb.append(this.put);
4857       }
4858       first = false;
4859       sb.append(")");
4860       return sb.toString();
4861     }
4862 
4863     public void validate() throws org.apache.thrift.TException {
4864       // check for required fields
4865       if (table == null) {
4866         throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
4867       }
4868       if (put == null) {
4869         throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
4870       }
4871     }
4872 
4873     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
4874       try {
4875         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
4876       } catch (org.apache.thrift.TException te) {
4877         throw new java.io.IOException(te);
4878       }
4879     }
4880 
4881     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
4882       try {
4883         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
4884       } catch (org.apache.thrift.TException te) {
4885         throw new java.io.IOException(te);
4886       }
4887     }
4888 
4889     private static class put_argsStandardSchemeFactory implements SchemeFactory {
4890       public put_argsStandardScheme getScheme() {
4891         return new put_argsStandardScheme();
4892       }
4893     }
4894 
4895     private static class put_argsStandardScheme extends StandardScheme<put_args> {
4896 
4897       public void read(org.apache.thrift.protocol.TProtocol iprot, put_args struct) throws org.apache.thrift.TException {
4898         org.apache.thrift.protocol.TField schemeField;
4899         iprot.readStructBegin();
4900         while (true)
4901         {
4902           schemeField = iprot.readFieldBegin();
4903           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
4904             break;
4905           }
4906           switch (schemeField.id) {
4907             case 1: // TABLE
4908               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
4909                 struct.table = iprot.readBinary();
4910                 struct.setTableIsSet(true);
4911               } else { 
4912                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4913               }
4914               break;
4915             case 2: // PUT
4916               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
4917                 struct.put = new TPut();
4918                 struct.put.read(iprot);
4919                 struct.setPutIsSet(true);
4920               } else { 
4921                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4922               }
4923               break;
4924             default:
4925               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
4926           }
4927           iprot.readFieldEnd();
4928         }
4929         iprot.readStructEnd();
4930 
4931         // check for required fields of primitive type, which can't be checked in the validate method
4932         struct.validate();
4933       }
4934 
4935       public void write(org.apache.thrift.protocol.TProtocol oprot, put_args struct) throws org.apache.thrift.TException {
4936         struct.validate();
4937 
4938         oprot.writeStructBegin(STRUCT_DESC);
4939         if (struct.table != null) {
4940           oprot.writeFieldBegin(TABLE_FIELD_DESC);
4941           oprot.writeBinary(struct.table);
4942           oprot.writeFieldEnd();
4943         }
4944         if (struct.put != null) {
4945           oprot.writeFieldBegin(PUT_FIELD_DESC);
4946           struct.put.write(oprot);
4947           oprot.writeFieldEnd();
4948         }
4949         oprot.writeFieldStop();
4950         oprot.writeStructEnd();
4951       }
4952 
4953     }
4954 
4955     private static class put_argsTupleSchemeFactory implements SchemeFactory {
4956       public put_argsTupleScheme getScheme() {
4957         return new put_argsTupleScheme();
4958       }
4959     }
4960 
4961     private static class put_argsTupleScheme extends TupleScheme<put_args> {
4962 
4963       @Override
4964       public void write(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4965         TTupleProtocol oprot = (TTupleProtocol) prot;
4966         oprot.writeBinary(struct.table);
4967         struct.put.write(oprot);
4968       }
4969 
4970       @Override
4971       public void read(org.apache.thrift.protocol.TProtocol prot, put_args struct) throws org.apache.thrift.TException {
4972         TTupleProtocol iprot = (TTupleProtocol) prot;
4973         struct.table = iprot.readBinary();
4974         struct.setTableIsSet(true);
4975         struct.put = new TPut();
4976         struct.put.read(iprot);
4977         struct.setPutIsSet(true);
4978       }
4979     }
4980 
4981   }
4982 
4983   public static class put_result implements org.apache.thrift.TBase<put_result, put_result._Fields>, java.io.Serializable, Cloneable   {
4984     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("put_result");
4985 
4986     private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
4987 
4988     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
4989     static {
4990       schemes.put(StandardScheme.class, new put_resultStandardSchemeFactory());
4991       schemes.put(TupleScheme.class, new put_resultTupleSchemeFactory());
4992     }
4993 
4994     public TIOError io; // required
4995 
4996     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4997     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
4998       IO((short)1, "io");
4999 
5000       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5001 
5002       static {
5003         for (_Fields field : EnumSet.allOf(_Fields.class)) {
5004           byName.put(field.getFieldName(), field);
5005         }
5006       }
5007 
5008       /**
5009        * Find the _Fields constant that matches fieldId, or null if its not found.
5010        */
5011       public static _Fields findByThriftId(int fieldId) {
5012         switch(fieldId) {
5013           case 1: // IO
5014             return IO;
5015           default:
5016             return null;
5017         }
5018       }
5019 
5020       /**
5021        * Find the _Fields constant that matches fieldId, throwing an exception
5022        * if it is not found.
5023        */
5024       public static _Fields findByThriftIdOrThrow(int fieldId) {
5025         _Fields fields = findByThriftId(fieldId);
5026         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5027         return fields;
5028       }
5029 
5030       /**
5031        * Find the _Fields constant that matches name, or null if its not found.
5032        */
5033       public static _Fields findByName(String name) {
5034         return byName.get(name);
5035       }
5036 
5037       private final short _thriftId;
5038       private final String _fieldName;
5039 
5040       _Fields(short thriftId, String fieldName) {
5041         _thriftId = thriftId;
5042         _fieldName = fieldName;
5043       }
5044 
5045       public short getThriftFieldId() {
5046         return _thriftId;
5047       }
5048 
5049       public String getFieldName() {
5050         return _fieldName;
5051       }
5052     }
5053 
5054     // isset id assignments
5055     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
5056     static {
5057       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
5058       tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, 
5059           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
5060       metaDataMap = Collections.unmodifiableMap(tmpMap);
5061       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_result.class, metaDataMap);
5062     }
5063 
5064     public put_result() {
5065     }
5066 
5067     public put_result(
5068       TIOError io)
5069     {
5070       this();
5071       this.io = io;
5072     }
5073 
5074     /**
5075      * Performs a deep copy on <i>other</i>.
5076      */
5077     public put_result(put_result other) {
5078       if (other.isSetIo()) {
5079         this.io = new TIOError(other.io);
5080       }
5081     }
5082 
5083     public put_result deepCopy() {
5084       return new put_result(this);
5085     }
5086 
5087     @Override
5088     public void clear() {
5089       this.io = null;
5090     }
5091 
5092     public TIOError getIo() {
5093       return this.io;
5094     }
5095 
5096     public put_result setIo(TIOError io) {
5097       this.io = io;
5098       return this;
5099     }
5100 
5101     public void unsetIo() {
5102       this.io = null;
5103     }
5104 
5105     /** Returns true if field io is set (has been assigned a value) and false otherwise */
5106     public boolean isSetIo() {
5107       return this.io != null;
5108     }
5109 
5110     public void setIoIsSet(boolean value) {
5111       if (!value) {
5112         this.io = null;
5113       }
5114     }
5115 
5116     public void setFieldValue(_Fields field, Object value) {
5117       switch (field) {
5118       case IO:
5119         if (value == null) {
5120           unsetIo();
5121         } else {
5122           setIo((TIOError)value);
5123         }
5124         break;
5125 
5126       }
5127     }
5128 
5129     public Object getFieldValue(_Fields field) {
5130       switch (field) {
5131       case IO:
5132         return getIo();
5133 
5134       }
5135       throw new IllegalStateException();
5136     }
5137 
5138     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
5139     public boolean isSet(_Fields field) {
5140       if (field == null) {
5141         throw new IllegalArgumentException();
5142       }
5143 
5144       switch (field) {
5145       case IO:
5146         return isSetIo();
5147       }
5148       throw new IllegalStateException();
5149     }
5150 
5151     @Override
5152     public boolean equals(Object that) {
5153       if (that == null)
5154         return false;
5155       if (that instanceof put_result)
5156         return this.equals((put_result)that);
5157       return false;
5158     }
5159 
5160     public boolean equals(put_result that) {
5161       if (that == null)
5162         return false;
5163 
5164       boolean this_present_io = true && this.isSetIo();
5165       boolean that_present_io = true && that.isSetIo();
5166       if (this_present_io || that_present_io) {
5167         if (!(this_present_io && that_present_io))
5168           return false;
5169         if (!this.io.equals(that.io))
5170           return false;
5171       }
5172 
5173       return true;
5174     }
5175 
5176     @Override
5177     public int hashCode() {
5178       return 0;
5179     }
5180 
5181     public int compareTo(put_result other) {
5182       if (!getClass().equals(other.getClass())) {
5183         return getClass().getName().compareTo(other.getClass().getName());
5184       }
5185 
5186       int lastComparison = 0;
5187       put_result typedOther = (put_result)other;
5188 
5189       lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
5190       if (lastComparison != 0) {
5191         return lastComparison;
5192       }
5193       if (isSetIo()) {
5194         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
5195         if (lastComparison != 0) {
5196           return lastComparison;
5197         }
5198       }
5199       return 0;
5200     }
5201 
5202     public _Fields fieldForId(int fieldId) {
5203       return _Fields.findByThriftId(fieldId);
5204     }
5205 
5206     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
5207       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
5208     }
5209 
5210     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
5211       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
5212       }
5213 
5214     @Override
5215     public String toString() {
5216       StringBuilder sb = new StringBuilder("put_result(");
5217       boolean first = true;
5218 
5219       sb.append("io:");
5220       if (this.io == null) {
5221         sb.append("null");
5222       } else {
5223         sb.append(this.io);
5224       }
5225       first = false;
5226       sb.append(")");
5227       return sb.toString();
5228     }
5229 
5230     public void validate() throws org.apache.thrift.TException {
5231       // check for required fields
5232     }
5233 
5234     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
5235       try {
5236         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
5237       } catch (org.apache.thrift.TException te) {
5238         throw new java.io.IOException(te);
5239       }
5240     }
5241 
5242     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
5243       try {
5244         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
5245       } catch (org.apache.thrift.TException te) {
5246         throw new java.io.IOException(te);
5247       }
5248     }
5249 
5250     private static class put_resultStandardSchemeFactory implements SchemeFactory {
5251       public put_resultStandardScheme getScheme() {
5252         return new put_resultStandardScheme();
5253       }
5254     }
5255 
5256     private static class put_resultStandardScheme extends StandardScheme<put_result> {
5257 
5258       public void read(org.apache.thrift.protocol.TProtocol iprot, put_result struct) throws org.apache.thrift.TException {
5259         org.apache.thrift.protocol.TField schemeField;
5260         iprot.readStructBegin();
5261         while (true)
5262         {
5263           schemeField = iprot.readFieldBegin();
5264           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
5265             break;
5266           }
5267           switch (schemeField.id) {
5268             case 1: // IO
5269               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
5270                 struct.io = new TIOError();
5271                 struct.io.read(iprot);
5272                 struct.setIoIsSet(true);
5273               } else { 
5274                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5275               }
5276               break;
5277             default:
5278               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
5279           }
5280           iprot.readFieldEnd();
5281         }
5282         iprot.readStructEnd();
5283 
5284         // check for required fields of primitive type, which can't be checked in the validate method
5285         struct.validate();
5286       }
5287 
5288       public void write(org.apache.thrift.protocol.TProtocol oprot, put_result struct) throws org.apache.thrift.TException {
5289         struct.validate();
5290 
5291         oprot.writeStructBegin(STRUCT_DESC);
5292         if (struct.io != null) {
5293           oprot.writeFieldBegin(IO_FIELD_DESC);
5294           struct.io.write(oprot);
5295           oprot.writeFieldEnd();
5296         }
5297         oprot.writeFieldStop();
5298         oprot.writeStructEnd();
5299       }
5300 
5301     }
5302 
5303     private static class put_resultTupleSchemeFactory implements SchemeFactory {
5304       public put_resultTupleScheme getScheme() {
5305         return new put_resultTupleScheme();
5306       }
5307     }
5308 
5309     private static class put_resultTupleScheme extends TupleScheme<put_result> {
5310 
5311       @Override
5312       public void write(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5313         TTupleProtocol oprot = (TTupleProtocol) prot;
5314         BitSet optionals = new BitSet();
5315         if (struct.isSetIo()) {
5316           optionals.set(0);
5317         }
5318         oprot.writeBitSet(optionals, 1);
5319         if (struct.isSetIo()) {
5320           struct.io.write(oprot);
5321         }
5322       }
5323 
5324       @Override
5325       public void read(org.apache.thrift.protocol.TProtocol prot, put_result struct) throws org.apache.thrift.TException {
5326         TTupleProtocol iprot = (TTupleProtocol) prot;
5327         BitSet incoming = iprot.readBitSet(1);
5328         if (incoming.get(0)) {
5329           struct.io = new TIOError();
5330           struct.io.read(iprot);
5331           struct.setIoIsSet(true);
5332         }
5333       }
5334     }
5335 
5336   }
5337 
5338   public static class checkAndPut_args implements org.apache.thrift.TBase<checkAndPut_args, checkAndPut_args._Fields>, java.io.Serializable, Cloneable   {
5339     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_args");
5340 
5341     private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
5342     private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2);
5343     private static final org.apache.thrift.protocol.TField FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)3);
5344     private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)4);
5345     private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)5);
5346     private static final org.apache.thrift.protocol.TField PUT_FIELD_DESC = new org.apache.thrift.protocol.TField("put", org.apache.thrift.protocol.TType.STRUCT, (short)6);
5347 
5348     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
5349     static {
5350       schemes.put(StandardScheme.class, new checkAndPut_argsStandardSchemeFactory());
5351       schemes.put(TupleScheme.class, new checkAndPut_argsTupleSchemeFactory());
5352     }
5353 
5354     /**
5355      * to check in and put to
5356      */
5357     public ByteBuffer table; // required
5358     /**
5359      * row to check
5360      */
5361     public ByteBuffer row; // required
5362     /**
5363      * column family to check
5364      */
5365     public ByteBuffer family; // required
5366     /**
5367      * column qualifier to check
5368      */
5369     public ByteBuffer qualifier; // required
5370     /**
5371      * the expected value, if not provided the
5372      * check is for the non-existence of the
5373      * column in question
5374      */
5375     public ByteBuffer value; // required
5376     /**
5377      * the TPut to put if the check succeeds
5378      */
5379     public TPut put; // required
5380 
5381     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
5382     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
5383       /**
5384        * to check in and put to
5385        */
5386       TABLE((short)1, "table"),
5387       /**
5388        * row to check
5389        */
5390       ROW((short)2, "row"),
5391       /**
5392        * column family to check
5393        */
5394       FAMILY((short)3, "family"),
5395       /**
5396        * column qualifier to check
5397        */
5398       QUALIFIER((short)4, "qualifier"),
5399       /**
5400        * the expected value, if not provided the
5401        * check is for the non-existence of the
5402        * column in question
5403        */
5404       VALUE((short)5, "value"),
5405       /**
5406        * the TPut to put if the check succeeds
5407        */
5408       PUT((short)6, "put");
5409 
5410       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5411 
5412       static {
5413         for (_Fields field : EnumSet.allOf(_Fields.class)) {
5414           byName.put(field.getFieldName(), field);
5415         }
5416       }
5417 
5418       /**
5419        * Find the _Fields constant that matches fieldId, or null if its not found.
5420        */
5421       public static _Fields findByThriftId(int fieldId) {
5422         switch(fieldId) {
5423           case 1: // TABLE
5424             return TABLE;
5425           case 2: // ROW
5426             return ROW;
5427           case 3: // FAMILY
5428             return FAMILY;
5429           case 4: // QUALIFIER
5430             return QUALIFIER;
5431           case 5: // VALUE
5432             return VALUE;
5433           case 6: // PUT
5434             return PUT;
5435           default:
5436             return null;
5437         }
5438       }
5439 
5440       /**
5441        * Find the _Fields constant that matches fieldId, throwing an exception
5442        * if it is not found.
5443        */
5444       public static _Fields findByThriftIdOrThrow(int fieldId) {
5445         _Fields fields = findByThriftId(fieldId);
5446         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5447         return fields;
5448       }
5449 
5450       /**
5451        * Find the _Fields constant that matches name, or null if its not found.
5452        */
5453       public static _Fields findByName(String name) {
5454         return byName.get(name);
5455       }
5456 
5457       private final short _thriftId;
5458       private final String _fieldName;
5459 
5460       _Fields(short thriftId, String fieldName) {
5461         _thriftId = thriftId;
5462         _fieldName = fieldName;
5463       }
5464 
5465       public short getThriftFieldId() {
5466         return _thriftId;
5467       }
5468 
5469       public String getFieldName() {
5470         return _fieldName;
5471       }
5472     }
5473 
5474     // isset id assignments
5475     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
5476     static {
5477       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
5478       tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED, 
5479           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
5480       tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED, 
5481           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
5482       tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED, 
5483           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
5484       tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED, 
5485           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
5486       tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT, 
5487           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
5488       tmpMap.put(_Fields.PUT, new org.apache.thrift.meta_data.FieldMetaData("put", org.apache.thrift.TFieldRequirementType.REQUIRED, 
5489           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class)));
5490       metaDataMap = Collections.unmodifiableMap(tmpMap);
5491       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_args.class, metaDataMap);
5492     }
5493 
5494     public checkAndPut_args() {
5495     }
5496 
5497     public checkAndPut_args(
5498       ByteBuffer table,
5499       ByteBuffer row,
5500       ByteBuffer family,
5501       ByteBuffer qualifier,
5502       ByteBuffer value,
5503       TPut put)
5504     {
5505       this();
5506       this.table = table;
5507       this.row = row;
5508       this.family = family;
5509       this.qualifier = qualifier;
5510       this.value = value;
5511       this.put = put;
5512     }
5513 
5514     /**
5515      * Performs a deep copy on <i>other</i>.
5516      */
5517     public checkAndPut_args(checkAndPut_args other) {
5518       if (other.isSetTable()) {
5519         this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
5520 ;
5521       }
5522       if (other.isSetRow()) {
5523         this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
5524 ;
5525       }
5526       if (other.isSetFamily()) {
5527         this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
5528 ;
5529       }
5530       if (other.isSetQualifier()) {
5531         this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
5532 ;
5533       }
5534       if (other.isSetValue()) {
5535         this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
5536 ;
5537       }
5538       if (other.isSetPut()) {
5539         this.put = new TPut(other.put);
5540       }
5541     }
5542 
5543     public checkAndPut_args deepCopy() {
5544       return new checkAndPut_args(this);
5545     }
5546 
5547     @Override
5548     public void clear() {
5549       this.table = null;
5550       this.row = null;
5551       this.family = null;
5552       this.qualifier = null;
5553       this.value = null;
5554       this.put = null;
5555     }
5556 
5557     /**
5558      * to check in and put to
5559      */
5560     public byte[] getTable() {
5561       setTable(org.apache.thrift.TBaseHelper.rightSize(table));
5562       return table == null ? null : table.array();
5563     }
5564 
5565     public ByteBuffer bufferForTable() {
5566       return table;
5567     }
5568 
5569     /**
5570      * to check in and put to
5571      */
5572     public checkAndPut_args setTable(byte[] table) {
5573       setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
5574       return this;
5575     }
5576 
5577     public checkAndPut_args setTable(ByteBuffer table) {
5578       this.table = table;
5579       return this;
5580     }
5581 
5582     public void unsetTable() {
5583       this.table = null;
5584     }
5585 
5586     /** Returns true if field table is set (has been assigned a value) and false otherwise */
5587     public boolean isSetTable() {
5588       return this.table != null;
5589     }
5590 
5591     public void setTableIsSet(boolean value) {
5592       if (!value) {
5593         this.table = null;
5594       }
5595     }
5596 
5597     /**
5598      * row to check
5599      */
5600     public byte[] getRow() {
5601       setRow(org.apache.thrift.TBaseHelper.rightSize(row));
5602       return row == null ? null : row.array();
5603     }
5604 
5605     public ByteBuffer bufferForRow() {
5606       return row;
5607     }
5608 
5609     /**
5610      * row to check
5611      */
5612     public checkAndPut_args setRow(byte[] row) {
5613       setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
5614       return this;
5615     }
5616 
5617     public checkAndPut_args setRow(ByteBuffer row) {
5618       this.row = row;
5619       return this;
5620     }
5621 
5622     public void unsetRow() {
5623       this.row = null;
5624     }
5625 
5626     /** Returns true if field row is set (has been assigned a value) and false otherwise */
5627     public boolean isSetRow() {
5628       return this.row != null;
5629     }
5630 
5631     public void setRowIsSet(boolean value) {
5632       if (!value) {
5633         this.row = null;
5634       }
5635     }
5636 
5637     /**
5638      * column family to check
5639      */
5640     public byte[] getFamily() {
5641       setFamily(org.apache.thrift.TBaseHelper.rightSize(family));
5642       return family == null ? null : family.array();
5643     }
5644 
5645     public ByteBuffer bufferForFamily() {
5646       return family;
5647     }
5648 
5649     /**
5650      * column family to check
5651      */
5652     public checkAndPut_args setFamily(byte[] family) {
5653       setFamily(family == null ? (ByteBuffer)null : ByteBuffer.wrap(family));
5654       return this;
5655     }
5656 
5657     public checkAndPut_args setFamily(ByteBuffer family) {
5658       this.family = family;
5659       return this;
5660     }
5661 
5662     public void unsetFamily() {
5663       this.family = null;
5664     }
5665 
5666     /** Returns true if field family is set (has been assigned a value) and false otherwise */
5667     public boolean isSetFamily() {
5668       return this.family != null;
5669     }
5670 
5671     public void setFamilyIsSet(boolean value) {
5672       if (!value) {
5673         this.family = null;
5674       }
5675     }
5676 
5677     /**
5678      * column qualifier to check
5679      */
5680     public byte[] getQualifier() {
5681       setQualifier(org.apache.thrift.TBaseHelper.rightSize(qualifier));
5682       return qualifier == null ? null : qualifier.array();
5683     }
5684 
5685     public ByteBuffer bufferForQualifier() {
5686       return qualifier;
5687     }
5688 
5689     /**
5690      * column qualifier to check
5691      */
5692     public checkAndPut_args setQualifier(byte[] qualifier) {
5693       setQualifier(qualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(qualifier));
5694       return this;
5695     }
5696 
5697     public checkAndPut_args setQualifier(ByteBuffer qualifier) {
5698       this.qualifier = qualifier;
5699       return this;
5700     }
5701 
5702     public void unsetQualifier() {
5703       this.qualifier = null;
5704     }
5705 
5706     /** Returns true if field qualifier is set (has been assigned a value) and false otherwise */
5707     public boolean isSetQualifier() {
5708       return this.qualifier != null;
5709     }
5710 
5711     public void setQualifierIsSet(boolean value) {
5712       if (!value) {
5713         this.qualifier = null;
5714       }
5715     }
5716 
5717     /**
5718      * the expected value, if not provided the
5719      * check is for the non-existence of the
5720      * column in question
5721      */
5722     public byte[] getValue() {
5723       setValue(org.apache.thrift.TBaseHelper.rightSize(value));
5724       return value == null ? null : value.array();
5725     }
5726 
5727     public ByteBuffer bufferForValue() {
5728       return value;
5729     }
5730 
5731     /**
5732      * the expected value, if not provided the
5733      * check is for the non-existence of the
5734      * column in question
5735      */
5736     public checkAndPut_args setValue(byte[] value) {
5737       setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
5738       return this;
5739     }
5740 
5741     public checkAndPut_args setValue(ByteBuffer value) {
5742       this.value = value;
5743       return this;
5744     }
5745 
5746     public void unsetValue() {
5747       this.value = null;
5748     }
5749 
5750     /** Returns true if field value is set (has been assigned a value) and false otherwise */
5751     public boolean isSetValue() {
5752       return this.value != null;
5753     }
5754 
5755     public void setValueIsSet(boolean value) {
5756       if (!value) {
5757         this.value = null;
5758       }
5759     }
5760 
5761     /**
5762      * the TPut to put if the check succeeds
5763      */
5764     public TPut getPut() {
5765       return this.put;
5766     }
5767 
5768     /**
5769      * the TPut to put if the check succeeds
5770      */
5771     public checkAndPut_args setPut(TPut put) {
5772       this.put = put;
5773       return this;
5774     }
5775 
5776     public void unsetPut() {
5777       this.put = null;
5778     }
5779 
5780     /** Returns true if field put is set (has been assigned a value) and false otherwise */
5781     public boolean isSetPut() {
5782       return this.put != null;
5783     }
5784 
5785     public void setPutIsSet(boolean value) {
5786       if (!value) {
5787         this.put = null;
5788       }
5789     }
5790 
5791     public void setFieldValue(_Fields field, Object value) {
5792       switch (field) {
5793       case TABLE:
5794         if (value == null) {
5795           unsetTable();
5796         } else {
5797           setTable((ByteBuffer)value);
5798         }
5799         break;
5800 
5801       case ROW:
5802         if (value == null) {
5803           unsetRow();
5804         } else {
5805           setRow((ByteBuffer)value);
5806         }
5807         break;
5808 
5809       case FAMILY:
5810         if (value == null) {
5811           unsetFamily();
5812         } else {
5813           setFamily((ByteBuffer)value);
5814         }
5815         break;
5816 
5817       case QUALIFIER:
5818         if (value == null) {
5819           unsetQualifier();
5820         } else {
5821           setQualifier((ByteBuffer)value);
5822         }
5823         break;
5824 
5825       case VALUE:
5826         if (value == null) {
5827           unsetValue();
5828         } else {
5829           setValue((ByteBuffer)value);
5830         }
5831         break;
5832 
5833       case PUT:
5834         if (value == null) {
5835           unsetPut();
5836         } else {
5837           setPut((TPut)value);
5838         }
5839         break;
5840 
5841       }
5842     }
5843 
5844     public Object getFieldValue(_Fields field) {
5845       switch (field) {
5846       case TABLE:
5847         return getTable();
5848 
5849       case ROW:
5850         return getRow();
5851 
5852       case FAMILY:
5853         return getFamily();
5854 
5855       case QUALIFIER:
5856         return getQualifier();
5857 
5858       case VALUE:
5859         return getValue();
5860 
5861       case PUT:
5862         return getPut();
5863 
5864       }
5865       throw new IllegalStateException();
5866     }
5867 
5868     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
5869     public boolean isSet(_Fields field) {
5870       if (field == null) {
5871         throw new IllegalArgumentException();
5872       }
5873 
5874       switch (field) {
5875       case TABLE:
5876         return isSetTable();
5877       case ROW:
5878         return isSetRow();
5879       case FAMILY:
5880         return isSetFamily();
5881       case QUALIFIER:
5882         return isSetQualifier();
5883       case VALUE:
5884         return isSetValue();
5885       case PUT:
5886         return isSetPut();
5887       }
5888       throw new IllegalStateException();
5889     }
5890 
5891     @Override
5892     public boolean equals(Object that) {
5893       if (that == null)
5894         return false;
5895       if (that instanceof checkAndPut_args)
5896         return this.equals((checkAndPut_args)that);
5897       return false;
5898     }
5899 
5900     public boolean equals(checkAndPut_args that) {
5901       if (that == null)
5902         return false;
5903 
5904       boolean this_present_table = true && this.isSetTable();
5905       boolean that_present_table = true && that.isSetTable();
5906       if (this_present_table || that_present_table) {
5907         if (!(this_present_table && that_present_table))
5908           return false;
5909         if (!this.table.equals(that.table))
5910           return false;
5911       }
5912 
5913       boolean this_present_row = true && this.isSetRow();
5914       boolean that_present_row = true && that.isSetRow();
5915       if (this_present_row || that_present_row) {
5916         if (!(this_present_row && that_present_row))
5917           return false;
5918         if (!this.row.equals(that.row))
5919           return false;
5920       }
5921 
5922       boolean this_present_family = true && this.isSetFamily();
5923       boolean that_present_family = true && that.isSetFamily();
5924       if (this_present_family || that_present_family) {
5925         if (!(this_present_family && that_present_family))
5926           return false;
5927         if (!this.family.equals(that.family))
5928           return false;
5929       }
5930 
5931       boolean this_present_qualifier = true && this.isSetQualifier();
5932       boolean that_present_qualifier = true && that.isSetQualifier();
5933       if (this_present_qualifier || that_present_qualifier) {
5934         if (!(this_present_qualifier && that_present_qualifier))
5935           return false;
5936         if (!this.qualifier.equals(that.qualifier))
5937           return false;
5938       }
5939 
5940       boolean this_present_value = true && this.isSetValue();
5941       boolean that_present_value = true && that.isSetValue();
5942       if (this_present_value || that_present_value) {
5943         if (!(this_present_value && that_present_value))
5944           return false;
5945         if (!this.value.equals(that.value))
5946           return false;
5947       }
5948 
5949       boolean this_present_put = true && this.isSetPut();
5950       boolean that_present_put = true && that.isSetPut();
5951       if (this_present_put || that_present_put) {
5952         if (!(this_present_put && that_present_put))
5953           return false;
5954         if (!this.put.equals(that.put))
5955           return false;
5956       }
5957 
5958       return true;
5959     }
5960 
5961     @Override
5962     public int hashCode() {
5963       return 0;
5964     }
5965 
5966     public int compareTo(checkAndPut_args other) {
5967       if (!getClass().equals(other.getClass())) {
5968         return getClass().getName().compareTo(other.getClass().getName());
5969       }
5970 
5971       int lastComparison = 0;
5972       checkAndPut_args typedOther = (checkAndPut_args)other;
5973 
5974       lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
5975       if (lastComparison != 0) {
5976         return lastComparison;
5977       }
5978       if (isSetTable()) {
5979         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
5980         if (lastComparison != 0) {
5981           return lastComparison;
5982         }
5983       }
5984       lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
5985       if (lastComparison != 0) {
5986         return lastComparison;
5987       }
5988       if (isSetRow()) {
5989         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
5990         if (lastComparison != 0) {
5991           return lastComparison;
5992         }
5993       }
5994       lastComparison = Boolean.valueOf(isSetFamily()).compareTo(typedOther.isSetFamily());
5995       if (lastComparison != 0) {
5996         return lastComparison;
5997       }
5998       if (isSetFamily()) {
5999         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.family, typedOther.family);
6000         if (lastComparison != 0) {
6001           return lastComparison;
6002         }
6003       }
6004       lastComparison = Boolean.valueOf(isSetQualifier()).compareTo(typedOther.isSetQualifier());
6005       if (lastComparison != 0) {
6006         return lastComparison;
6007       }
6008       if (isSetQualifier()) {
6009         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.qualifier, typedOther.qualifier);
6010         if (lastComparison != 0) {
6011           return lastComparison;
6012         }
6013       }
6014       lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
6015       if (lastComparison != 0) {
6016         return lastComparison;
6017       }
6018       if (isSetValue()) {
6019         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
6020         if (lastComparison != 0) {
6021           return lastComparison;
6022         }
6023       }
6024       lastComparison = Boolean.valueOf(isSetPut()).compareTo(typedOther.isSetPut());
6025       if (lastComparison != 0) {
6026         return lastComparison;
6027       }
6028       if (isSetPut()) {
6029         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.put, typedOther.put);
6030         if (lastComparison != 0) {
6031           return lastComparison;
6032         }
6033       }
6034       return 0;
6035     }
6036 
6037     public _Fields fieldForId(int fieldId) {
6038       return _Fields.findByThriftId(fieldId);
6039     }
6040 
6041     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6042       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6043     }
6044 
6045     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6046       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6047     }
6048 
6049     @Override
6050     public String toString() {
6051       StringBuilder sb = new StringBuilder("checkAndPut_args(");
6052       boolean first = true;
6053 
6054       sb.append("table:");
6055       if (this.table == null) {
6056         sb.append("null");
6057       } else {
6058         org.apache.thrift.TBaseHelper.toString(this.table, sb);
6059       }
6060       first = false;
6061       if (!first) sb.append(", ");
6062       sb.append("row:");
6063       if (this.row == null) {
6064         sb.append("null");
6065       } else {
6066         org.apache.thrift.TBaseHelper.toString(this.row, sb);
6067       }
6068       first = false;
6069       if (!first) sb.append(", ");
6070       sb.append("family:");
6071       if (this.family == null) {
6072         sb.append("null");
6073       } else {
6074         org.apache.thrift.TBaseHelper.toString(this.family, sb);
6075       }
6076       first = false;
6077       if (!first) sb.append(", ");
6078       sb.append("qualifier:");
6079       if (this.qualifier == null) {
6080         sb.append("null");
6081       } else {
6082         org.apache.thrift.TBaseHelper.toString(this.qualifier, sb);
6083       }
6084       first = false;
6085       if (!first) sb.append(", ");
6086       sb.append("value:");
6087       if (this.value == null) {
6088         sb.append("null");
6089       } else {
6090         org.apache.thrift.TBaseHelper.toString(this.value, sb);
6091       }
6092       first = false;
6093       if (!first) sb.append(", ");
6094       sb.append("put:");
6095       if (this.put == null) {
6096         sb.append("null");
6097       } else {
6098         sb.append(this.put);
6099       }
6100       first = false;
6101       sb.append(")");
6102       return sb.toString();
6103     }
6104 
6105     public void validate() throws org.apache.thrift.TException {
6106       // check for required fields
6107       if (table == null) {
6108         throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
6109       }
6110       if (row == null) {
6111         throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' was not present! Struct: " + toString());
6112       }
6113       if (family == null) {
6114         throw new org.apache.thrift.protocol.TProtocolException("Required field 'family' was not present! Struct: " + toString());
6115       }
6116       if (qualifier == null) {
6117         throw new org.apache.thrift.protocol.TProtocolException("Required field 'qualifier' was not present! Struct: " + toString());
6118       }
6119       if (put == null) {
6120         throw new org.apache.thrift.protocol.TProtocolException("Required field 'put' was not present! Struct: " + toString());
6121       }
6122     }
6123 
6124     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6125       try {
6126         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6127       } catch (org.apache.thrift.TException te) {
6128         throw new java.io.IOException(te);
6129       }
6130     }
6131 
6132     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6133       try {
6134         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6135       } catch (org.apache.thrift.TException te) {
6136         throw new java.io.IOException(te);
6137       }
6138     }
6139 
6140     private static class checkAndPut_argsStandardSchemeFactory implements SchemeFactory {
6141       public checkAndPut_argsStandardScheme getScheme() {
6142         return new checkAndPut_argsStandardScheme();
6143       }
6144     }
6145 
6146     private static class checkAndPut_argsStandardScheme extends StandardScheme<checkAndPut_args> {
6147 
6148       public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6149         org.apache.thrift.protocol.TField schemeField;
6150         iprot.readStructBegin();
6151         while (true)
6152         {
6153           schemeField = iprot.readFieldBegin();
6154           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
6155             break;
6156           }
6157           switch (schemeField.id) {
6158             case 1: // TABLE
6159               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6160                 struct.table = iprot.readBinary();
6161                 struct.setTableIsSet(true);
6162               } else { 
6163                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6164               }
6165               break;
6166             case 2: // ROW
6167               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6168                 struct.row = iprot.readBinary();
6169                 struct.setRowIsSet(true);
6170               } else { 
6171                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6172               }
6173               break;
6174             case 3: // FAMILY
6175               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6176                 struct.family = iprot.readBinary();
6177                 struct.setFamilyIsSet(true);
6178               } else { 
6179                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6180               }
6181               break;
6182             case 4: // QUALIFIER
6183               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6184                 struct.qualifier = iprot.readBinary();
6185                 struct.setQualifierIsSet(true);
6186               } else { 
6187                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6188               }
6189               break;
6190             case 5: // VALUE
6191               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
6192                 struct.value = iprot.readBinary();
6193                 struct.setValueIsSet(true);
6194               } else { 
6195                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6196               }
6197               break;
6198             case 6: // PUT
6199               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6200                 struct.put = new TPut();
6201                 struct.put.read(iprot);
6202                 struct.setPutIsSet(true);
6203               } else { 
6204                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6205               }
6206               break;
6207             default:
6208               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6209           }
6210           iprot.readFieldEnd();
6211         }
6212         iprot.readStructEnd();
6213 
6214         // check for required fields of primitive type, which can't be checked in the validate method
6215         struct.validate();
6216       }
6217 
6218       public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_args struct) throws org.apache.thrift.TException {
6219         struct.validate();
6220 
6221         oprot.writeStructBegin(STRUCT_DESC);
6222         if (struct.table != null) {
6223           oprot.writeFieldBegin(TABLE_FIELD_DESC);
6224           oprot.writeBinary(struct.table);
6225           oprot.writeFieldEnd();
6226         }
6227         if (struct.row != null) {
6228           oprot.writeFieldBegin(ROW_FIELD_DESC);
6229           oprot.writeBinary(struct.row);
6230           oprot.writeFieldEnd();
6231         }
6232         if (struct.family != null) {
6233           oprot.writeFieldBegin(FAMILY_FIELD_DESC);
6234           oprot.writeBinary(struct.family);
6235           oprot.writeFieldEnd();
6236         }
6237         if (struct.qualifier != null) {
6238           oprot.writeFieldBegin(QUALIFIER_FIELD_DESC);
6239           oprot.writeBinary(struct.qualifier);
6240           oprot.writeFieldEnd();
6241         }
6242         if (struct.value != null) {
6243           oprot.writeFieldBegin(VALUE_FIELD_DESC);
6244           oprot.writeBinary(struct.value);
6245           oprot.writeFieldEnd();
6246         }
6247         if (struct.put != null) {
6248           oprot.writeFieldBegin(PUT_FIELD_DESC);
6249           struct.put.write(oprot);
6250           oprot.writeFieldEnd();
6251         }
6252         oprot.writeFieldStop();
6253         oprot.writeStructEnd();
6254       }
6255 
6256     }
6257 
6258     private static class checkAndPut_argsTupleSchemeFactory implements SchemeFactory {
6259       public checkAndPut_argsTupleScheme getScheme() {
6260         return new checkAndPut_argsTupleScheme();
6261       }
6262     }
6263 
6264     private static class checkAndPut_argsTupleScheme extends TupleScheme<checkAndPut_args> {
6265 
6266       @Override
6267       public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6268         TTupleProtocol oprot = (TTupleProtocol) prot;
6269         oprot.writeBinary(struct.table);
6270         oprot.writeBinary(struct.row);
6271         oprot.writeBinary(struct.family);
6272         oprot.writeBinary(struct.qualifier);
6273         struct.put.write(oprot);
6274         BitSet optionals = new BitSet();
6275         if (struct.isSetValue()) {
6276           optionals.set(0);
6277         }
6278         oprot.writeBitSet(optionals, 1);
6279         if (struct.isSetValue()) {
6280           oprot.writeBinary(struct.value);
6281         }
6282       }
6283 
6284       @Override
6285       public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_args struct) throws org.apache.thrift.TException {
6286         TTupleProtocol iprot = (TTupleProtocol) prot;
6287         struct.table = iprot.readBinary();
6288         struct.setTableIsSet(true);
6289         struct.row = iprot.readBinary();
6290         struct.setRowIsSet(true);
6291         struct.family = iprot.readBinary();
6292         struct.setFamilyIsSet(true);
6293         struct.qualifier = iprot.readBinary();
6294         struct.setQualifierIsSet(true);
6295         struct.put = new TPut();
6296         struct.put.read(iprot);
6297         struct.setPutIsSet(true);
6298         BitSet incoming = iprot.readBitSet(1);
6299         if (incoming.get(0)) {
6300           struct.value = iprot.readBinary();
6301           struct.setValueIsSet(true);
6302         }
6303       }
6304     }
6305 
6306   }
6307 
6308   public static class checkAndPut_result implements org.apache.thrift.TBase<checkAndPut_result, checkAndPut_result._Fields>, java.io.Serializable, Cloneable   {
6309     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndPut_result");
6310 
6311     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0);
6312     private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
6313 
6314     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6315     static {
6316       schemes.put(StandardScheme.class, new checkAndPut_resultStandardSchemeFactory());
6317       schemes.put(TupleScheme.class, new checkAndPut_resultTupleSchemeFactory());
6318     }
6319 
6320     public boolean success; // required
6321     public TIOError io; // required
6322 
6323     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
6324     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6325       SUCCESS((short)0, "success"),
6326       IO((short)1, "io");
6327 
6328       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6329 
6330       static {
6331         for (_Fields field : EnumSet.allOf(_Fields.class)) {
6332           byName.put(field.getFieldName(), field);
6333         }
6334       }
6335 
6336       /**
6337        * Find the _Fields constant that matches fieldId, or null if its not found.
6338        */
6339       public static _Fields findByThriftId(int fieldId) {
6340         switch(fieldId) {
6341           case 0: // SUCCESS
6342             return SUCCESS;
6343           case 1: // IO
6344             return IO;
6345           default:
6346             return null;
6347         }
6348       }
6349 
6350       /**
6351        * Find the _Fields constant that matches fieldId, throwing an exception
6352        * if it is not found.
6353        */
6354       public static _Fields findByThriftIdOrThrow(int fieldId) {
6355         _Fields fields = findByThriftId(fieldId);
6356         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6357         return fields;
6358       }
6359 
6360       /**
6361        * Find the _Fields constant that matches name, or null if its not found.
6362        */
6363       public static _Fields findByName(String name) {
6364         return byName.get(name);
6365       }
6366 
6367       private final short _thriftId;
6368       private final String _fieldName;
6369 
6370       _Fields(short thriftId, String fieldName) {
6371         _thriftId = thriftId;
6372         _fieldName = fieldName;
6373       }
6374 
6375       public short getThriftFieldId() {
6376         return _thriftId;
6377       }
6378 
6379       public String getFieldName() {
6380         return _fieldName;
6381       }
6382     }
6383 
6384     // isset id assignments
6385     private static final int __SUCCESS_ISSET_ID = 0;
6386     private BitSet __isset_bit_vector = new BitSet(1);
6387     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6388     static {
6389       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6390       tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
6391           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
6392       tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, 
6393           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
6394       metaDataMap = Collections.unmodifiableMap(tmpMap);
6395       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndPut_result.class, metaDataMap);
6396     }
6397 
6398     public checkAndPut_result() {
6399     }
6400 
6401     public checkAndPut_result(
6402       boolean success,
6403       TIOError io)
6404     {
6405       this();
6406       this.success = success;
6407       setSuccessIsSet(true);
6408       this.io = io;
6409     }
6410 
6411     /**
6412      * Performs a deep copy on <i>other</i>.
6413      */
6414     public checkAndPut_result(checkAndPut_result other) {
6415       __isset_bit_vector.clear();
6416       __isset_bit_vector.or(other.__isset_bit_vector);
6417       this.success = other.success;
6418       if (other.isSetIo()) {
6419         this.io = new TIOError(other.io);
6420       }
6421     }
6422 
6423     public checkAndPut_result deepCopy() {
6424       return new checkAndPut_result(this);
6425     }
6426 
6427     @Override
6428     public void clear() {
6429       setSuccessIsSet(false);
6430       this.success = false;
6431       this.io = null;
6432     }
6433 
6434     public boolean isSuccess() {
6435       return this.success;
6436     }
6437 
6438     public checkAndPut_result setSuccess(boolean success) {
6439       this.success = success;
6440       setSuccessIsSet(true);
6441       return this;
6442     }
6443 
6444     public void unsetSuccess() {
6445       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
6446     }
6447 
6448     /** Returns true if field success is set (has been assigned a value) and false otherwise */
6449     public boolean isSetSuccess() {
6450       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
6451     }
6452 
6453     public void setSuccessIsSet(boolean value) {
6454       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
6455     }
6456 
6457     public TIOError getIo() {
6458       return this.io;
6459     }
6460 
6461     public checkAndPut_result setIo(TIOError io) {
6462       this.io = io;
6463       return this;
6464     }
6465 
6466     public void unsetIo() {
6467       this.io = null;
6468     }
6469 
6470     /** Returns true if field io is set (has been assigned a value) and false otherwise */
6471     public boolean isSetIo() {
6472       return this.io != null;
6473     }
6474 
6475     public void setIoIsSet(boolean value) {
6476       if (!value) {
6477         this.io = null;
6478       }
6479     }
6480 
6481     public void setFieldValue(_Fields field, Object value) {
6482       switch (field) {
6483       case SUCCESS:
6484         if (value == null) {
6485           unsetSuccess();
6486         } else {
6487           setSuccess((Boolean)value);
6488         }
6489         break;
6490 
6491       case IO:
6492         if (value == null) {
6493           unsetIo();
6494         } else {
6495           setIo((TIOError)value);
6496         }
6497         break;
6498 
6499       }
6500     }
6501 
6502     public Object getFieldValue(_Fields field) {
6503       switch (field) {
6504       case SUCCESS:
6505         return Boolean.valueOf(isSuccess());
6506 
6507       case IO:
6508         return getIo();
6509 
6510       }
6511       throw new IllegalStateException();
6512     }
6513 
6514     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
6515     public boolean isSet(_Fields field) {
6516       if (field == null) {
6517         throw new IllegalArgumentException();
6518       }
6519 
6520       switch (field) {
6521       case SUCCESS:
6522         return isSetSuccess();
6523       case IO:
6524         return isSetIo();
6525       }
6526       throw new IllegalStateException();
6527     }
6528 
6529     @Override
6530     public boolean equals(Object that) {
6531       if (that == null)
6532         return false;
6533       if (that instanceof checkAndPut_result)
6534         return this.equals((checkAndPut_result)that);
6535       return false;
6536     }
6537 
6538     public boolean equals(checkAndPut_result that) {
6539       if (that == null)
6540         return false;
6541 
6542       boolean this_present_success = true;
6543       boolean that_present_success = true;
6544       if (this_present_success || that_present_success) {
6545         if (!(this_present_success && that_present_success))
6546           return false;
6547         if (this.success != that.success)
6548           return false;
6549       }
6550 
6551       boolean this_present_io = true && this.isSetIo();
6552       boolean that_present_io = true && that.isSetIo();
6553       if (this_present_io || that_present_io) {
6554         if (!(this_present_io && that_present_io))
6555           return false;
6556         if (!this.io.equals(that.io))
6557           return false;
6558       }
6559 
6560       return true;
6561     }
6562 
6563     @Override
6564     public int hashCode() {
6565       return 0;
6566     }
6567 
6568     public int compareTo(checkAndPut_result other) {
6569       if (!getClass().equals(other.getClass())) {
6570         return getClass().getName().compareTo(other.getClass().getName());
6571       }
6572 
6573       int lastComparison = 0;
6574       checkAndPut_result typedOther = (checkAndPut_result)other;
6575 
6576       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
6577       if (lastComparison != 0) {
6578         return lastComparison;
6579       }
6580       if (isSetSuccess()) {
6581         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
6582         if (lastComparison != 0) {
6583           return lastComparison;
6584         }
6585       }
6586       lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
6587       if (lastComparison != 0) {
6588         return lastComparison;
6589       }
6590       if (isSetIo()) {
6591         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
6592         if (lastComparison != 0) {
6593           return lastComparison;
6594         }
6595       }
6596       return 0;
6597     }
6598 
6599     public _Fields fieldForId(int fieldId) {
6600       return _Fields.findByThriftId(fieldId);
6601     }
6602 
6603     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
6604       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
6605     }
6606 
6607     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
6608       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
6609       }
6610 
6611     @Override
6612     public String toString() {
6613       StringBuilder sb = new StringBuilder("checkAndPut_result(");
6614       boolean first = true;
6615 
6616       sb.append("success:");
6617       sb.append(this.success);
6618       first = false;
6619       if (!first) sb.append(", ");
6620       sb.append("io:");
6621       if (this.io == null) {
6622         sb.append("null");
6623       } else {
6624         sb.append(this.io);
6625       }
6626       first = false;
6627       sb.append(")");
6628       return sb.toString();
6629     }
6630 
6631     public void validate() throws org.apache.thrift.TException {
6632       // check for required fields
6633     }
6634 
6635     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
6636       try {
6637         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
6638       } catch (org.apache.thrift.TException te) {
6639         throw new java.io.IOException(te);
6640       }
6641     }
6642 
6643     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
6644       try {
6645         // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
6646         __isset_bit_vector = new BitSet(1);
6647         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
6648       } catch (org.apache.thrift.TException te) {
6649         throw new java.io.IOException(te);
6650       }
6651     }
6652 
6653     private static class checkAndPut_resultStandardSchemeFactory implements SchemeFactory {
6654       public checkAndPut_resultStandardScheme getScheme() {
6655         return new checkAndPut_resultStandardScheme();
6656       }
6657     }
6658 
6659     private static class checkAndPut_resultStandardScheme extends StandardScheme<checkAndPut_result> {
6660 
6661       public void read(org.apache.thrift.protocol.TProtocol iprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6662         org.apache.thrift.protocol.TField schemeField;
6663         iprot.readStructBegin();
6664         while (true)
6665         {
6666           schemeField = iprot.readFieldBegin();
6667           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
6668             break;
6669           }
6670           switch (schemeField.id) {
6671             case 0: // SUCCESS
6672               if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
6673                 struct.success = iprot.readBool();
6674                 struct.setSuccessIsSet(true);
6675               } else { 
6676                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6677               }
6678               break;
6679             case 1: // IO
6680               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
6681                 struct.io = new TIOError();
6682                 struct.io.read(iprot);
6683                 struct.setIoIsSet(true);
6684               } else { 
6685                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6686               }
6687               break;
6688             default:
6689               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
6690           }
6691           iprot.readFieldEnd();
6692         }
6693         iprot.readStructEnd();
6694 
6695         // check for required fields of primitive type, which can't be checked in the validate method
6696         struct.validate();
6697       }
6698 
6699       public void write(org.apache.thrift.protocol.TProtocol oprot, checkAndPut_result struct) throws org.apache.thrift.TException {
6700         struct.validate();
6701 
6702         oprot.writeStructBegin(STRUCT_DESC);
6703         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6704         oprot.writeBool(struct.success);
6705         oprot.writeFieldEnd();
6706         if (struct.io != null) {
6707           oprot.writeFieldBegin(IO_FIELD_DESC);
6708           struct.io.write(oprot);
6709           oprot.writeFieldEnd();
6710         }
6711         oprot.writeFieldStop();
6712         oprot.writeStructEnd();
6713       }
6714 
6715     }
6716 
6717     private static class checkAndPut_resultTupleSchemeFactory implements SchemeFactory {
6718       public checkAndPut_resultTupleScheme getScheme() {
6719         return new checkAndPut_resultTupleScheme();
6720       }
6721     }
6722 
6723     private static class checkAndPut_resultTupleScheme extends TupleScheme<checkAndPut_result> {
6724 
6725       @Override
6726       public void write(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6727         TTupleProtocol oprot = (TTupleProtocol) prot;
6728         BitSet optionals = new BitSet();
6729         if (struct.isSetSuccess()) {
6730           optionals.set(0);
6731         }
6732         if (struct.isSetIo()) {
6733           optionals.set(1);
6734         }
6735         oprot.writeBitSet(optionals, 2);
6736         if (struct.isSetSuccess()) {
6737           oprot.writeBool(struct.success);
6738         }
6739         if (struct.isSetIo()) {
6740           struct.io.write(oprot);
6741         }
6742       }
6743 
6744       @Override
6745       public void read(org.apache.thrift.protocol.TProtocol prot, checkAndPut_result struct) throws org.apache.thrift.TException {
6746         TTupleProtocol iprot = (TTupleProtocol) prot;
6747         BitSet incoming = iprot.readBitSet(2);
6748         if (incoming.get(0)) {
6749           struct.success = iprot.readBool();
6750           struct.setSuccessIsSet(true);
6751         }
6752         if (incoming.get(1)) {
6753           struct.io = new TIOError();
6754           struct.io.read(iprot);
6755           struct.setIoIsSet(true);
6756         }
6757       }
6758     }
6759 
6760   }
6761 
6762   public static class putMultiple_args implements org.apache.thrift.TBase<putMultiple_args, putMultiple_args._Fields>, java.io.Serializable, Cloneable   {
6763     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_args");
6764 
6765     private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
6766     private static final org.apache.thrift.protocol.TField PUTS_FIELD_DESC = new org.apache.thrift.protocol.TField("puts", org.apache.thrift.protocol.TType.LIST, (short)2);
6767 
6768     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
6769     static {
6770       schemes.put(StandardScheme.class, new putMultiple_argsStandardSchemeFactory());
6771       schemes.put(TupleScheme.class, new putMultiple_argsTupleSchemeFactory());
6772     }
6773 
6774     /**
6775      * the table to put data in
6776      */
6777     public ByteBuffer table; // required
6778     /**
6779      * a list of TPuts to commit
6780      */
6781     public List<TPut> puts; // required
6782 
6783     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
6784     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
6785       /**
6786        * the table to put data in
6787        */
6788       TABLE((short)1, "table"),
6789       /**
6790        * a list of TPuts to commit
6791        */
6792       PUTS((short)2, "puts");
6793 
6794       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6795 
6796       static {
6797         for (_Fields field : EnumSet.allOf(_Fields.class)) {
6798           byName.put(field.getFieldName(), field);
6799         }
6800       }
6801 
6802       /**
6803        * Find the _Fields constant that matches fieldId, or null if its not found.
6804        */
6805       public static _Fields findByThriftId(int fieldId) {
6806         switch(fieldId) {
6807           case 1: // TABLE
6808             return TABLE;
6809           case 2: // PUTS
6810             return PUTS;
6811           default:
6812             return null;
6813         }
6814       }
6815 
6816       /**
6817        * Find the _Fields constant that matches fieldId, throwing an exception
6818        * if it is not found.
6819        */
6820       public static _Fields findByThriftIdOrThrow(int fieldId) {
6821         _Fields fields = findByThriftId(fieldId);
6822         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6823         return fields;
6824       }
6825 
6826       /**
6827        * Find the _Fields constant that matches name, or null if its not found.
6828        */
6829       public static _Fields findByName(String name) {
6830         return byName.get(name);
6831       }
6832 
6833       private final short _thriftId;
6834       private final String _fieldName;
6835 
6836       _Fields(short thriftId, String fieldName) {
6837         _thriftId = thriftId;
6838         _fieldName = fieldName;
6839       }
6840 
6841       public short getThriftFieldId() {
6842         return _thriftId;
6843       }
6844 
6845       public String getFieldName() {
6846         return _fieldName;
6847       }
6848     }
6849 
6850     // isset id assignments
6851     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
6852     static {
6853       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
6854       tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED, 
6855           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
6856       tmpMap.put(_Fields.PUTS, new org.apache.thrift.meta_data.FieldMetaData("puts", org.apache.thrift.TFieldRequirementType.REQUIRED, 
6857           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
6858               new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TPut.class))));
6859       metaDataMap = Collections.unmodifiableMap(tmpMap);
6860       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_args.class, metaDataMap);
6861     }
6862 
6863     public putMultiple_args() {
6864     }
6865 
6866     public putMultiple_args(
6867       ByteBuffer table,
6868       List<TPut> puts)
6869     {
6870       this();
6871       this.table = table;
6872       this.puts = puts;
6873     }
6874 
6875     /**
6876      * Performs a deep copy on <i>other</i>.
6877      */
6878     public putMultiple_args(putMultiple_args other) {
6879       if (other.isSetTable()) {
6880         this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
6881 ;
6882       }
6883       if (other.isSetPuts()) {
6884         List<TPut> __this__puts = new ArrayList<TPut>();
6885         for (TPut other_element : other.puts) {
6886           __this__puts.add(new TPut(other_element));
6887         }
6888         this.puts = __this__puts;
6889       }
6890     }
6891 
6892     public putMultiple_args deepCopy() {
6893       return new putMultiple_args(this);
6894     }
6895 
6896     @Override
6897     public void clear() {
6898       this.table = null;
6899       this.puts = null;
6900     }
6901 
6902     /**
6903      * the table to put data in
6904      */
6905     public byte[] getTable() {
6906       setTable(org.apache.thrift.TBaseHelper.rightSize(table));
6907       return table == null ? null : table.array();
6908     }
6909 
6910     public ByteBuffer bufferForTable() {
6911       return table;
6912     }
6913 
6914     /**
6915      * the table to put data in
6916      */
6917     public putMultiple_args setTable(byte[] table) {
6918       setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
6919       return this;
6920     }
6921 
6922     public putMultiple_args setTable(ByteBuffer table) {
6923       this.table = table;
6924       return this;
6925     }
6926 
6927     public void unsetTable() {
6928       this.table = null;
6929     }
6930 
6931     /** Returns true if field table is set (has been assigned a value) and false otherwise */
6932     public boolean isSetTable() {
6933       return this.table != null;
6934     }
6935 
6936     public void setTableIsSet(boolean value) {
6937       if (!value) {
6938         this.table = null;
6939       }
6940     }
6941 
6942     public int getPutsSize() {
6943       return (this.puts == null) ? 0 : this.puts.size();
6944     }
6945 
6946     public java.util.Iterator<TPut> getPutsIterator() {
6947       return (this.puts == null) ? null : this.puts.iterator();
6948     }
6949 
6950     public void addToPuts(TPut elem) {
6951       if (this.puts == null) {
6952         this.puts = new ArrayList<TPut>();
6953       }
6954       this.puts.add(elem);
6955     }
6956 
6957     /**
6958      * a list of TPuts to commit
6959      */
6960     public List<TPut> getPuts() {
6961       return this.puts;
6962     }
6963 
6964     /**
6965      * a list of TPuts to commit
6966      */
6967     public putMultiple_args setPuts(List<TPut> puts) {
6968       this.puts = puts;
6969       return this;
6970     }
6971 
6972     public void unsetPuts() {
6973       this.puts = null;
6974     }
6975 
6976     /** Returns true if field puts is set (has been assigned a value) and false otherwise */
6977     public boolean isSetPuts() {
6978       return this.puts != null;
6979     }
6980 
6981     public void setPutsIsSet(boolean value) {
6982       if (!value) {
6983         this.puts = null;
6984       }
6985     }
6986 
6987     public void setFieldValue(_Fields field, Object value) {
6988       switch (field) {
6989       case TABLE:
6990         if (value == null) {
6991           unsetTable();
6992         } else {
6993           setTable((ByteBuffer)value);
6994         }
6995         break;
6996 
6997       case PUTS:
6998         if (value == null) {
6999           unsetPuts();
7000         } else {
7001           setPuts((List<TPut>)value);
7002         }
7003         break;
7004 
7005       }
7006     }
7007 
7008     public Object getFieldValue(_Fields field) {
7009       switch (field) {
7010       case TABLE:
7011         return getTable();
7012 
7013       case PUTS:
7014         return getPuts();
7015 
7016       }
7017       throw new IllegalStateException();
7018     }
7019 
7020     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
7021     public boolean isSet(_Fields field) {
7022       if (field == null) {
7023         throw new IllegalArgumentException();
7024       }
7025 
7026       switch (field) {
7027       case TABLE:
7028         return isSetTable();
7029       case PUTS:
7030         return isSetPuts();
7031       }
7032       throw new IllegalStateException();
7033     }
7034 
7035     @Override
7036     public boolean equals(Object that) {
7037       if (that == null)
7038         return false;
7039       if (that instanceof putMultiple_args)
7040         return this.equals((putMultiple_args)that);
7041       return false;
7042     }
7043 
7044     public boolean equals(putMultiple_args that) {
7045       if (that == null)
7046         return false;
7047 
7048       boolean this_present_table = true && this.isSetTable();
7049       boolean that_present_table = true && that.isSetTable();
7050       if (this_present_table || that_present_table) {
7051         if (!(this_present_table && that_present_table))
7052           return false;
7053         if (!this.table.equals(that.table))
7054           return false;
7055       }
7056 
7057       boolean this_present_puts = true && this.isSetPuts();
7058       boolean that_present_puts = true && that.isSetPuts();
7059       if (this_present_puts || that_present_puts) {
7060         if (!(this_present_puts && that_present_puts))
7061           return false;
7062         if (!this.puts.equals(that.puts))
7063           return false;
7064       }
7065 
7066       return true;
7067     }
7068 
7069     @Override
7070     public int hashCode() {
7071       return 0;
7072     }
7073 
7074     public int compareTo(putMultiple_args other) {
7075       if (!getClass().equals(other.getClass())) {
7076         return getClass().getName().compareTo(other.getClass().getName());
7077       }
7078 
7079       int lastComparison = 0;
7080       putMultiple_args typedOther = (putMultiple_args)other;
7081 
7082       lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
7083       if (lastComparison != 0) {
7084         return lastComparison;
7085       }
7086       if (isSetTable()) {
7087         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
7088         if (lastComparison != 0) {
7089           return lastComparison;
7090         }
7091       }
7092       lastComparison = Boolean.valueOf(isSetPuts()).compareTo(typedOther.isSetPuts());
7093       if (lastComparison != 0) {
7094         return lastComparison;
7095       }
7096       if (isSetPuts()) {
7097         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.puts, typedOther.puts);
7098         if (lastComparison != 0) {
7099           return lastComparison;
7100         }
7101       }
7102       return 0;
7103     }
7104 
7105     public _Fields fieldForId(int fieldId) {
7106       return _Fields.findByThriftId(fieldId);
7107     }
7108 
7109     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7110       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7111     }
7112 
7113     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7114       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7115     }
7116 
7117     @Override
7118     public String toString() {
7119       StringBuilder sb = new StringBuilder("putMultiple_args(");
7120       boolean first = true;
7121 
7122       sb.append("table:");
7123       if (this.table == null) {
7124         sb.append("null");
7125       } else {
7126         org.apache.thrift.TBaseHelper.toString(this.table, sb);
7127       }
7128       first = false;
7129       if (!first) sb.append(", ");
7130       sb.append("puts:");
7131       if (this.puts == null) {
7132         sb.append("null");
7133       } else {
7134         sb.append(this.puts);
7135       }
7136       first = false;
7137       sb.append(")");
7138       return sb.toString();
7139     }
7140 
7141     public void validate() throws org.apache.thrift.TException {
7142       // check for required fields
7143       if (table == null) {
7144         throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
7145       }
7146       if (puts == null) {
7147         throw new org.apache.thrift.protocol.TProtocolException("Required field 'puts' was not present! Struct: " + toString());
7148       }
7149     }
7150 
7151     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7152       try {
7153         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7154       } catch (org.apache.thrift.TException te) {
7155         throw new java.io.IOException(te);
7156       }
7157     }
7158 
7159     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7160       try {
7161         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7162       } catch (org.apache.thrift.TException te) {
7163         throw new java.io.IOException(te);
7164       }
7165     }
7166 
7167     private static class putMultiple_argsStandardSchemeFactory implements SchemeFactory {
7168       public putMultiple_argsStandardScheme getScheme() {
7169         return new putMultiple_argsStandardScheme();
7170       }
7171     }
7172 
7173     private static class putMultiple_argsStandardScheme extends StandardScheme<putMultiple_args> {
7174 
7175       public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_args struct) throws org.apache.thrift.TException {
7176         org.apache.thrift.protocol.TField schemeField;
7177         iprot.readStructBegin();
7178         while (true)
7179         {
7180           schemeField = iprot.readFieldBegin();
7181           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
7182             break;
7183           }
7184           switch (schemeField.id) {
7185             case 1: // TABLE
7186               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
7187                 struct.table = iprot.readBinary();
7188                 struct.setTableIsSet(true);
7189               } else { 
7190                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7191               }
7192               break;
7193             case 2: // PUTS
7194               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
7195                 {
7196                   org.apache.thrift.protocol.TList _list112 = iprot.readListBegin();
7197                   struct.puts = new ArrayList<TPut>(_list112.size);
7198                   for (int _i113 = 0; _i113 < _list112.size; ++_i113)
7199                   {
7200                     TPut _elem114; // required
7201                     _elem114 = new TPut();
7202                     _elem114.read(iprot);
7203                     struct.puts.add(_elem114);
7204                   }
7205                   iprot.readListEnd();
7206                 }
7207                 struct.setPutsIsSet(true);
7208               } else { 
7209                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7210               }
7211               break;
7212             default:
7213               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7214           }
7215           iprot.readFieldEnd();
7216         }
7217         iprot.readStructEnd();
7218 
7219         // check for required fields of primitive type, which can't be checked in the validate method
7220         struct.validate();
7221       }
7222 
7223       public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_args struct) throws org.apache.thrift.TException {
7224         struct.validate();
7225 
7226         oprot.writeStructBegin(STRUCT_DESC);
7227         if (struct.table != null) {
7228           oprot.writeFieldBegin(TABLE_FIELD_DESC);
7229           oprot.writeBinary(struct.table);
7230           oprot.writeFieldEnd();
7231         }
7232         if (struct.puts != null) {
7233           oprot.writeFieldBegin(PUTS_FIELD_DESC);
7234           {
7235             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.puts.size()));
7236             for (TPut _iter115 : struct.puts)
7237             {
7238               _iter115.write(oprot);
7239             }
7240             oprot.writeListEnd();
7241           }
7242           oprot.writeFieldEnd();
7243         }
7244         oprot.writeFieldStop();
7245         oprot.writeStructEnd();
7246       }
7247 
7248     }
7249 
7250     private static class putMultiple_argsTupleSchemeFactory implements SchemeFactory {
7251       public putMultiple_argsTupleScheme getScheme() {
7252         return new putMultiple_argsTupleScheme();
7253       }
7254     }
7255 
7256     private static class putMultiple_argsTupleScheme extends TupleScheme<putMultiple_args> {
7257 
7258       @Override
7259       public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7260         TTupleProtocol oprot = (TTupleProtocol) prot;
7261         oprot.writeBinary(struct.table);
7262         {
7263           oprot.writeI32(struct.puts.size());
7264           for (TPut _iter116 : struct.puts)
7265           {
7266             _iter116.write(oprot);
7267           }
7268         }
7269       }
7270 
7271       @Override
7272       public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_args struct) throws org.apache.thrift.TException {
7273         TTupleProtocol iprot = (TTupleProtocol) prot;
7274         struct.table = iprot.readBinary();
7275         struct.setTableIsSet(true);
7276         {
7277           org.apache.thrift.protocol.TList _list117 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
7278           struct.puts = new ArrayList<TPut>(_list117.size);
7279           for (int _i118 = 0; _i118 < _list117.size; ++_i118)
7280           {
7281             TPut _elem119; // required
7282             _elem119 = new TPut();
7283             _elem119.read(iprot);
7284             struct.puts.add(_elem119);
7285           }
7286         }
7287         struct.setPutsIsSet(true);
7288       }
7289     }
7290 
7291   }
7292 
7293   public static class putMultiple_result implements org.apache.thrift.TBase<putMultiple_result, putMultiple_result._Fields>, java.io.Serializable, Cloneable   {
7294     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("putMultiple_result");
7295 
7296     private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
7297 
7298     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7299     static {
7300       schemes.put(StandardScheme.class, new putMultiple_resultStandardSchemeFactory());
7301       schemes.put(TupleScheme.class, new putMultiple_resultTupleSchemeFactory());
7302     }
7303 
7304     public TIOError io; // required
7305 
7306     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
7307     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7308       IO((short)1, "io");
7309 
7310       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7311 
7312       static {
7313         for (_Fields field : EnumSet.allOf(_Fields.class)) {
7314           byName.put(field.getFieldName(), field);
7315         }
7316       }
7317 
7318       /**
7319        * Find the _Fields constant that matches fieldId, or null if its not found.
7320        */
7321       public static _Fields findByThriftId(int fieldId) {
7322         switch(fieldId) {
7323           case 1: // IO
7324             return IO;
7325           default:
7326             return null;
7327         }
7328       }
7329 
7330       /**
7331        * Find the _Fields constant that matches fieldId, throwing an exception
7332        * if it is not found.
7333        */
7334       public static _Fields findByThriftIdOrThrow(int fieldId) {
7335         _Fields fields = findByThriftId(fieldId);
7336         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7337         return fields;
7338       }
7339 
7340       /**
7341        * Find the _Fields constant that matches name, or null if its not found.
7342        */
7343       public static _Fields findByName(String name) {
7344         return byName.get(name);
7345       }
7346 
7347       private final short _thriftId;
7348       private final String _fieldName;
7349 
7350       _Fields(short thriftId, String fieldName) {
7351         _thriftId = thriftId;
7352         _fieldName = fieldName;
7353       }
7354 
7355       public short getThriftFieldId() {
7356         return _thriftId;
7357       }
7358 
7359       public String getFieldName() {
7360         return _fieldName;
7361       }
7362     }
7363 
7364     // isset id assignments
7365     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7366     static {
7367       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7368       tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, 
7369           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
7370       metaDataMap = Collections.unmodifiableMap(tmpMap);
7371       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(putMultiple_result.class, metaDataMap);
7372     }
7373 
7374     public putMultiple_result() {
7375     }
7376 
7377     public putMultiple_result(
7378       TIOError io)
7379     {
7380       this();
7381       this.io = io;
7382     }
7383 
7384     /**
7385      * Performs a deep copy on <i>other</i>.
7386      */
7387     public putMultiple_result(putMultiple_result other) {
7388       if (other.isSetIo()) {
7389         this.io = new TIOError(other.io);
7390       }
7391     }
7392 
7393     public putMultiple_result deepCopy() {
7394       return new putMultiple_result(this);
7395     }
7396 
7397     @Override
7398     public void clear() {
7399       this.io = null;
7400     }
7401 
7402     public TIOError getIo() {
7403       return this.io;
7404     }
7405 
7406     public putMultiple_result setIo(TIOError io) {
7407       this.io = io;
7408       return this;
7409     }
7410 
7411     public void unsetIo() {
7412       this.io = null;
7413     }
7414 
7415     /** Returns true if field io is set (has been assigned a value) and false otherwise */
7416     public boolean isSetIo() {
7417       return this.io != null;
7418     }
7419 
7420     public void setIoIsSet(boolean value) {
7421       if (!value) {
7422         this.io = null;
7423       }
7424     }
7425 
7426     public void setFieldValue(_Fields field, Object value) {
7427       switch (field) {
7428       case IO:
7429         if (value == null) {
7430           unsetIo();
7431         } else {
7432           setIo((TIOError)value);
7433         }
7434         break;
7435 
7436       }
7437     }
7438 
7439     public Object getFieldValue(_Fields field) {
7440       switch (field) {
7441       case IO:
7442         return getIo();
7443 
7444       }
7445       throw new IllegalStateException();
7446     }
7447 
7448     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
7449     public boolean isSet(_Fields field) {
7450       if (field == null) {
7451         throw new IllegalArgumentException();
7452       }
7453 
7454       switch (field) {
7455       case IO:
7456         return isSetIo();
7457       }
7458       throw new IllegalStateException();
7459     }
7460 
7461     @Override
7462     public boolean equals(Object that) {
7463       if (that == null)
7464         return false;
7465       if (that instanceof putMultiple_result)
7466         return this.equals((putMultiple_result)that);
7467       return false;
7468     }
7469 
7470     public boolean equals(putMultiple_result that) {
7471       if (that == null)
7472         return false;
7473 
7474       boolean this_present_io = true && this.isSetIo();
7475       boolean that_present_io = true && that.isSetIo();
7476       if (this_present_io || that_present_io) {
7477         if (!(this_present_io && that_present_io))
7478           return false;
7479         if (!this.io.equals(that.io))
7480           return false;
7481       }
7482 
7483       return true;
7484     }
7485 
7486     @Override
7487     public int hashCode() {
7488       return 0;
7489     }
7490 
7491     public int compareTo(putMultiple_result other) {
7492       if (!getClass().equals(other.getClass())) {
7493         return getClass().getName().compareTo(other.getClass().getName());
7494       }
7495 
7496       int lastComparison = 0;
7497       putMultiple_result typedOther = (putMultiple_result)other;
7498 
7499       lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
7500       if (lastComparison != 0) {
7501         return lastComparison;
7502       }
7503       if (isSetIo()) {
7504         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
7505         if (lastComparison != 0) {
7506           return lastComparison;
7507         }
7508       }
7509       return 0;
7510     }
7511 
7512     public _Fields fieldForId(int fieldId) {
7513       return _Fields.findByThriftId(fieldId);
7514     }
7515 
7516     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7517       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7518     }
7519 
7520     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7521       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7522       }
7523 
7524     @Override
7525     public String toString() {
7526       StringBuilder sb = new StringBuilder("putMultiple_result(");
7527       boolean first = true;
7528 
7529       sb.append("io:");
7530       if (this.io == null) {
7531         sb.append("null");
7532       } else {
7533         sb.append(this.io);
7534       }
7535       first = false;
7536       sb.append(")");
7537       return sb.toString();
7538     }
7539 
7540     public void validate() throws org.apache.thrift.TException {
7541       // check for required fields
7542     }
7543 
7544     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
7545       try {
7546         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
7547       } catch (org.apache.thrift.TException te) {
7548         throw new java.io.IOException(te);
7549       }
7550     }
7551 
7552     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
7553       try {
7554         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
7555       } catch (org.apache.thrift.TException te) {
7556         throw new java.io.IOException(te);
7557       }
7558     }
7559 
7560     private static class putMultiple_resultStandardSchemeFactory implements SchemeFactory {
7561       public putMultiple_resultStandardScheme getScheme() {
7562         return new putMultiple_resultStandardScheme();
7563       }
7564     }
7565 
7566     private static class putMultiple_resultStandardScheme extends StandardScheme<putMultiple_result> {
7567 
7568       public void read(org.apache.thrift.protocol.TProtocol iprot, putMultiple_result struct) throws org.apache.thrift.TException {
7569         org.apache.thrift.protocol.TField schemeField;
7570         iprot.readStructBegin();
7571         while (true)
7572         {
7573           schemeField = iprot.readFieldBegin();
7574           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
7575             break;
7576           }
7577           switch (schemeField.id) {
7578             case 1: // IO
7579               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
7580                 struct.io = new TIOError();
7581                 struct.io.read(iprot);
7582                 struct.setIoIsSet(true);
7583               } else { 
7584                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7585               }
7586               break;
7587             default:
7588               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
7589           }
7590           iprot.readFieldEnd();
7591         }
7592         iprot.readStructEnd();
7593 
7594         // check for required fields of primitive type, which can't be checked in the validate method
7595         struct.validate();
7596       }
7597 
7598       public void write(org.apache.thrift.protocol.TProtocol oprot, putMultiple_result struct) throws org.apache.thrift.TException {
7599         struct.validate();
7600 
7601         oprot.writeStructBegin(STRUCT_DESC);
7602         if (struct.io != null) {
7603           oprot.writeFieldBegin(IO_FIELD_DESC);
7604           struct.io.write(oprot);
7605           oprot.writeFieldEnd();
7606         }
7607         oprot.writeFieldStop();
7608         oprot.writeStructEnd();
7609       }
7610 
7611     }
7612 
7613     private static class putMultiple_resultTupleSchemeFactory implements SchemeFactory {
7614       public putMultiple_resultTupleScheme getScheme() {
7615         return new putMultiple_resultTupleScheme();
7616       }
7617     }
7618 
7619     private static class putMultiple_resultTupleScheme extends TupleScheme<putMultiple_result> {
7620 
7621       @Override
7622       public void write(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7623         TTupleProtocol oprot = (TTupleProtocol) prot;
7624         BitSet optionals = new BitSet();
7625         if (struct.isSetIo()) {
7626           optionals.set(0);
7627         }
7628         oprot.writeBitSet(optionals, 1);
7629         if (struct.isSetIo()) {
7630           struct.io.write(oprot);
7631         }
7632       }
7633 
7634       @Override
7635       public void read(org.apache.thrift.protocol.TProtocol prot, putMultiple_result struct) throws org.apache.thrift.TException {
7636         TTupleProtocol iprot = (TTupleProtocol) prot;
7637         BitSet incoming = iprot.readBitSet(1);
7638         if (incoming.get(0)) {
7639           struct.io = new TIOError();
7640           struct.io.read(iprot);
7641           struct.setIoIsSet(true);
7642         }
7643       }
7644     }
7645 
7646   }
7647 
7648   public static class deleteSingle_args implements org.apache.thrift.TBase<deleteSingle_args, deleteSingle_args._Fields>, java.io.Serializable, Cloneable   {
7649     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_args");
7650 
7651     private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
7652     private static final org.apache.thrift.protocol.TField DELETE_SINGLE_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteSingle", org.apache.thrift.protocol.TType.STRUCT, (short)2);
7653 
7654     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
7655     static {
7656       schemes.put(StandardScheme.class, new deleteSingle_argsStandardSchemeFactory());
7657       schemes.put(TupleScheme.class, new deleteSingle_argsTupleSchemeFactory());
7658     }
7659 
7660     /**
7661      * the table to delete from
7662      */
7663     public ByteBuffer table; // required
7664     /**
7665      * the TDelete to delete
7666      */
7667     public TDelete deleteSingle; // required
7668 
7669     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
7670     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
7671       /**
7672        * the table to delete from
7673        */
7674       TABLE((short)1, "table"),
7675       /**
7676        * the TDelete to delete
7677        */
7678       DELETE_SINGLE((short)2, "deleteSingle");
7679 
7680       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7681 
7682       static {
7683         for (_Fields field : EnumSet.allOf(_Fields.class)) {
7684           byName.put(field.getFieldName(), field);
7685         }
7686       }
7687 
7688       /**
7689        * Find the _Fields constant that matches fieldId, or null if its not found.
7690        */
7691       public static _Fields findByThriftId(int fieldId) {
7692         switch(fieldId) {
7693           case 1: // TABLE
7694             return TABLE;
7695           case 2: // DELETE_SINGLE
7696             return DELETE_SINGLE;
7697           default:
7698             return null;
7699         }
7700       }
7701 
7702       /**
7703        * Find the _Fields constant that matches fieldId, throwing an exception
7704        * if it is not found.
7705        */
7706       public static _Fields findByThriftIdOrThrow(int fieldId) {
7707         _Fields fields = findByThriftId(fieldId);
7708         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7709         return fields;
7710       }
7711 
7712       /**
7713        * Find the _Fields constant that matches name, or null if its not found.
7714        */
7715       public static _Fields findByName(String name) {
7716         return byName.get(name);
7717       }
7718 
7719       private final short _thriftId;
7720       private final String _fieldName;
7721 
7722       _Fields(short thriftId, String fieldName) {
7723         _thriftId = thriftId;
7724         _fieldName = fieldName;
7725       }
7726 
7727       public short getThriftFieldId() {
7728         return _thriftId;
7729       }
7730 
7731       public String getFieldName() {
7732         return _fieldName;
7733       }
7734     }
7735 
7736     // isset id assignments
7737     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
7738     static {
7739       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
7740       tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED, 
7741           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
7742       tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED, 
7743           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
7744       metaDataMap = Collections.unmodifiableMap(tmpMap);
7745       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_args.class, metaDataMap);
7746     }
7747 
7748     public deleteSingle_args() {
7749     }
7750 
7751     public deleteSingle_args(
7752       ByteBuffer table,
7753       TDelete deleteSingle)
7754     {
7755       this();
7756       this.table = table;
7757       this.deleteSingle = deleteSingle;
7758     }
7759 
7760     /**
7761      * Performs a deep copy on <i>other</i>.
7762      */
7763     public deleteSingle_args(deleteSingle_args other) {
7764       if (other.isSetTable()) {
7765         this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
7766 ;
7767       }
7768       if (other.isSetDeleteSingle()) {
7769         this.deleteSingle = new TDelete(other.deleteSingle);
7770       }
7771     }
7772 
7773     public deleteSingle_args deepCopy() {
7774       return new deleteSingle_args(this);
7775     }
7776 
7777     @Override
7778     public void clear() {
7779       this.table = null;
7780       this.deleteSingle = null;
7781     }
7782 
7783     /**
7784      * the table to delete from
7785      */
7786     public byte[] getTable() {
7787       setTable(org.apache.thrift.TBaseHelper.rightSize(table));
7788       return table == null ? null : table.array();
7789     }
7790 
7791     public ByteBuffer bufferForTable() {
7792       return table;
7793     }
7794 
7795     /**
7796      * the table to delete from
7797      */
7798     public deleteSingle_args setTable(byte[] table) {
7799       setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
7800       return this;
7801     }
7802 
7803     public deleteSingle_args setTable(ByteBuffer table) {
7804       this.table = table;
7805       return this;
7806     }
7807 
7808     public void unsetTable() {
7809       this.table = null;
7810     }
7811 
7812     /** Returns true if field table is set (has been assigned a value) and false otherwise */
7813     public boolean isSetTable() {
7814       return this.table != null;
7815     }
7816 
7817     public void setTableIsSet(boolean value) {
7818       if (!value) {
7819         this.table = null;
7820       }
7821     }
7822 
7823     /**
7824      * the TDelete to delete
7825      */
7826     public TDelete getDeleteSingle() {
7827       return this.deleteSingle;
7828     }
7829 
7830     /**
7831      * the TDelete to delete
7832      */
7833     public deleteSingle_args setDeleteSingle(TDelete deleteSingle) {
7834       this.deleteSingle = deleteSingle;
7835       return this;
7836     }
7837 
7838     public void unsetDeleteSingle() {
7839       this.deleteSingle = null;
7840     }
7841 
7842     /** Returns true if field deleteSingle is set (has been assigned a value) and false otherwise */
7843     public boolean isSetDeleteSingle() {
7844       return this.deleteSingle != null;
7845     }
7846 
7847     public void setDeleteSingleIsSet(boolean value) {
7848       if (!value) {
7849         this.deleteSingle = null;
7850       }
7851     }
7852 
7853     public void setFieldValue(_Fields field, Object value) {
7854       switch (field) {
7855       case TABLE:
7856         if (value == null) {
7857           unsetTable();
7858         } else {
7859           setTable((ByteBuffer)value);
7860         }
7861         break;
7862 
7863       case DELETE_SINGLE:
7864         if (value == null) {
7865           unsetDeleteSingle();
7866         } else {
7867           setDeleteSingle((TDelete)value);
7868         }
7869         break;
7870 
7871       }
7872     }
7873 
7874     public Object getFieldValue(_Fields field) {
7875       switch (field) {
7876       case TABLE:
7877         return getTable();
7878 
7879       case DELETE_SINGLE:
7880         return getDeleteSingle();
7881 
7882       }
7883       throw new IllegalStateException();
7884     }
7885 
7886     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
7887     public boolean isSet(_Fields field) {
7888       if (field == null) {
7889         throw new IllegalArgumentException();
7890       }
7891 
7892       switch (field) {
7893       case TABLE:
7894         return isSetTable();
7895       case DELETE_SINGLE:
7896         return isSetDeleteSingle();
7897       }
7898       throw new IllegalStateException();
7899     }
7900 
7901     @Override
7902     public boolean equals(Object that) {
7903       if (that == null)
7904         return false;
7905       if (that instanceof deleteSingle_args)
7906         return this.equals((deleteSingle_args)that);
7907       return false;
7908     }
7909 
7910     public boolean equals(deleteSingle_args that) {
7911       if (that == null)
7912         return false;
7913 
7914       boolean this_present_table = true && this.isSetTable();
7915       boolean that_present_table = true && that.isSetTable();
7916       if (this_present_table || that_present_table) {
7917         if (!(this_present_table && that_present_table))
7918           return false;
7919         if (!this.table.equals(that.table))
7920           return false;
7921       }
7922 
7923       boolean this_present_deleteSingle = true && this.isSetDeleteSingle();
7924       boolean that_present_deleteSingle = true && that.isSetDeleteSingle();
7925       if (this_present_deleteSingle || that_present_deleteSingle) {
7926         if (!(this_present_deleteSingle && that_present_deleteSingle))
7927           return false;
7928         if (!this.deleteSingle.equals(that.deleteSingle))
7929           return false;
7930       }
7931 
7932       return true;
7933     }
7934 
7935     @Override
7936     public int hashCode() {
7937       return 0;
7938     }
7939 
7940     public int compareTo(deleteSingle_args other) {
7941       if (!getClass().equals(other.getClass())) {
7942         return getClass().getName().compareTo(other.getClass().getName());
7943       }
7944 
7945       int lastComparison = 0;
7946       deleteSingle_args typedOther = (deleteSingle_args)other;
7947 
7948       lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
7949       if (lastComparison != 0) {
7950         return lastComparison;
7951       }
7952       if (isSetTable()) {
7953         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
7954         if (lastComparison != 0) {
7955           return lastComparison;
7956         }
7957       }
7958       lastComparison = Boolean.valueOf(isSetDeleteSingle()).compareTo(typedOther.isSetDeleteSingle());
7959       if (lastComparison != 0) {
7960         return lastComparison;
7961       }
7962       if (isSetDeleteSingle()) {
7963         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteSingle, typedOther.deleteSingle);
7964         if (lastComparison != 0) {
7965           return lastComparison;
7966         }
7967       }
7968       return 0;
7969     }
7970 
7971     public _Fields fieldForId(int fieldId) {
7972       return _Fields.findByThriftId(fieldId);
7973     }
7974 
7975     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
7976       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
7977     }
7978 
7979     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
7980       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
7981     }
7982 
7983     @Override
7984     public String toString() {
7985       StringBuilder sb = new StringBuilder("deleteSingle_args(");
7986       boolean first = true;
7987 
7988       sb.append("table:");
7989       if (this.table == null) {
7990         sb.append("null");
7991       } else {
7992         org.apache.thrift.TBaseHelper.toString(this.table, sb);
7993       }
7994       first = false;
7995       if (!first) sb.append(", ");
7996       sb.append("deleteSingle:");
7997       if (this.deleteSingle == null) {
7998         sb.append("null");
7999       } else {
8000         sb.append(this.deleteSingle);
8001       }
8002       first = false;
8003       sb.append(")");
8004       return sb.toString();
8005     }
8006 
8007     public void validate() throws org.apache.thrift.TException {
8008       // check for required fields
8009       if (table == null) {
8010         throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
8011       }
8012       if (deleteSingle == null) {
8013         throw new org.apache.thrift.protocol.TProtocolException("Required field 'deleteSingle' was not present! Struct: " + toString());
8014       }
8015     }
8016 
8017     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8018       try {
8019         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8020       } catch (org.apache.thrift.TException te) {
8021         throw new java.io.IOException(te);
8022       }
8023     }
8024 
8025     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8026       try {
8027         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8028       } catch (org.apache.thrift.TException te) {
8029         throw new java.io.IOException(te);
8030       }
8031     }
8032 
8033     private static class deleteSingle_argsStandardSchemeFactory implements SchemeFactory {
8034       public deleteSingle_argsStandardScheme getScheme() {
8035         return new deleteSingle_argsStandardScheme();
8036       }
8037     }
8038 
8039     private static class deleteSingle_argsStandardScheme extends StandardScheme<deleteSingle_args> {
8040 
8041       public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_args struct) throws org.apache.thrift.TException {
8042         org.apache.thrift.protocol.TField schemeField;
8043         iprot.readStructBegin();
8044         while (true)
8045         {
8046           schemeField = iprot.readFieldBegin();
8047           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
8048             break;
8049           }
8050           switch (schemeField.id) {
8051             case 1: // TABLE
8052               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
8053                 struct.table = iprot.readBinary();
8054                 struct.setTableIsSet(true);
8055               } else { 
8056                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8057               }
8058               break;
8059             case 2: // DELETE_SINGLE
8060               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
8061                 struct.deleteSingle = new TDelete();
8062                 struct.deleteSingle.read(iprot);
8063                 struct.setDeleteSingleIsSet(true);
8064               } else { 
8065                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8066               }
8067               break;
8068             default:
8069               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8070           }
8071           iprot.readFieldEnd();
8072         }
8073         iprot.readStructEnd();
8074 
8075         // check for required fields of primitive type, which can't be checked in the validate method
8076         struct.validate();
8077       }
8078 
8079       public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_args struct) throws org.apache.thrift.TException {
8080         struct.validate();
8081 
8082         oprot.writeStructBegin(STRUCT_DESC);
8083         if (struct.table != null) {
8084           oprot.writeFieldBegin(TABLE_FIELD_DESC);
8085           oprot.writeBinary(struct.table);
8086           oprot.writeFieldEnd();
8087         }
8088         if (struct.deleteSingle != null) {
8089           oprot.writeFieldBegin(DELETE_SINGLE_FIELD_DESC);
8090           struct.deleteSingle.write(oprot);
8091           oprot.writeFieldEnd();
8092         }
8093         oprot.writeFieldStop();
8094         oprot.writeStructEnd();
8095       }
8096 
8097     }
8098 
8099     private static class deleteSingle_argsTupleSchemeFactory implements SchemeFactory {
8100       public deleteSingle_argsTupleScheme getScheme() {
8101         return new deleteSingle_argsTupleScheme();
8102       }
8103     }
8104 
8105     private static class deleteSingle_argsTupleScheme extends TupleScheme<deleteSingle_args> {
8106 
8107       @Override
8108       public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
8109         TTupleProtocol oprot = (TTupleProtocol) prot;
8110         oprot.writeBinary(struct.table);
8111         struct.deleteSingle.write(oprot);
8112       }
8113 
8114       @Override
8115       public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_args struct) throws org.apache.thrift.TException {
8116         TTupleProtocol iprot = (TTupleProtocol) prot;
8117         struct.table = iprot.readBinary();
8118         struct.setTableIsSet(true);
8119         struct.deleteSingle = new TDelete();
8120         struct.deleteSingle.read(iprot);
8121         struct.setDeleteSingleIsSet(true);
8122       }
8123     }
8124 
8125   }
8126 
8127   public static class deleteSingle_result implements org.apache.thrift.TBase<deleteSingle_result, deleteSingle_result._Fields>, java.io.Serializable, Cloneable   {
8128     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteSingle_result");
8129 
8130     private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
8131 
8132     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8133     static {
8134       schemes.put(StandardScheme.class, new deleteSingle_resultStandardSchemeFactory());
8135       schemes.put(TupleScheme.class, new deleteSingle_resultTupleSchemeFactory());
8136     }
8137 
8138     public TIOError io; // required
8139 
8140     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
8141     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8142       IO((short)1, "io");
8143 
8144       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8145 
8146       static {
8147         for (_Fields field : EnumSet.allOf(_Fields.class)) {
8148           byName.put(field.getFieldName(), field);
8149         }
8150       }
8151 
8152       /**
8153        * Find the _Fields constant that matches fieldId, or null if its not found.
8154        */
8155       public static _Fields findByThriftId(int fieldId) {
8156         switch(fieldId) {
8157           case 1: // IO
8158             return IO;
8159           default:
8160             return null;
8161         }
8162       }
8163 
8164       /**
8165        * Find the _Fields constant that matches fieldId, throwing an exception
8166        * if it is not found.
8167        */
8168       public static _Fields findByThriftIdOrThrow(int fieldId) {
8169         _Fields fields = findByThriftId(fieldId);
8170         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8171         return fields;
8172       }
8173 
8174       /**
8175        * Find the _Fields constant that matches name, or null if its not found.
8176        */
8177       public static _Fields findByName(String name) {
8178         return byName.get(name);
8179       }
8180 
8181       private final short _thriftId;
8182       private final String _fieldName;
8183 
8184       _Fields(short thriftId, String fieldName) {
8185         _thriftId = thriftId;
8186         _fieldName = fieldName;
8187       }
8188 
8189       public short getThriftFieldId() {
8190         return _thriftId;
8191       }
8192 
8193       public String getFieldName() {
8194         return _fieldName;
8195       }
8196     }
8197 
8198     // isset id assignments
8199     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8200     static {
8201       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8202       tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, 
8203           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
8204       metaDataMap = Collections.unmodifiableMap(tmpMap);
8205       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteSingle_result.class, metaDataMap);
8206     }
8207 
8208     public deleteSingle_result() {
8209     }
8210 
8211     public deleteSingle_result(
8212       TIOError io)
8213     {
8214       this();
8215       this.io = io;
8216     }
8217 
8218     /**
8219      * Performs a deep copy on <i>other</i>.
8220      */
8221     public deleteSingle_result(deleteSingle_result other) {
8222       if (other.isSetIo()) {
8223         this.io = new TIOError(other.io);
8224       }
8225     }
8226 
8227     public deleteSingle_result deepCopy() {
8228       return new deleteSingle_result(this);
8229     }
8230 
8231     @Override
8232     public void clear() {
8233       this.io = null;
8234     }
8235 
8236     public TIOError getIo() {
8237       return this.io;
8238     }
8239 
8240     public deleteSingle_result setIo(TIOError io) {
8241       this.io = io;
8242       return this;
8243     }
8244 
8245     public void unsetIo() {
8246       this.io = null;
8247     }
8248 
8249     /** Returns true if field io is set (has been assigned a value) and false otherwise */
8250     public boolean isSetIo() {
8251       return this.io != null;
8252     }
8253 
8254     public void setIoIsSet(boolean value) {
8255       if (!value) {
8256         this.io = null;
8257       }
8258     }
8259 
8260     public void setFieldValue(_Fields field, Object value) {
8261       switch (field) {
8262       case IO:
8263         if (value == null) {
8264           unsetIo();
8265         } else {
8266           setIo((TIOError)value);
8267         }
8268         break;
8269 
8270       }
8271     }
8272 
8273     public Object getFieldValue(_Fields field) {
8274       switch (field) {
8275       case IO:
8276         return getIo();
8277 
8278       }
8279       throw new IllegalStateException();
8280     }
8281 
8282     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
8283     public boolean isSet(_Fields field) {
8284       if (field == null) {
8285         throw new IllegalArgumentException();
8286       }
8287 
8288       switch (field) {
8289       case IO:
8290         return isSetIo();
8291       }
8292       throw new IllegalStateException();
8293     }
8294 
8295     @Override
8296     public boolean equals(Object that) {
8297       if (that == null)
8298         return false;
8299       if (that instanceof deleteSingle_result)
8300         return this.equals((deleteSingle_result)that);
8301       return false;
8302     }
8303 
8304     public boolean equals(deleteSingle_result that) {
8305       if (that == null)
8306         return false;
8307 
8308       boolean this_present_io = true && this.isSetIo();
8309       boolean that_present_io = true && that.isSetIo();
8310       if (this_present_io || that_present_io) {
8311         if (!(this_present_io && that_present_io))
8312           return false;
8313         if (!this.io.equals(that.io))
8314           return false;
8315       }
8316 
8317       return true;
8318     }
8319 
8320     @Override
8321     public int hashCode() {
8322       return 0;
8323     }
8324 
8325     public int compareTo(deleteSingle_result other) {
8326       if (!getClass().equals(other.getClass())) {
8327         return getClass().getName().compareTo(other.getClass().getName());
8328       }
8329 
8330       int lastComparison = 0;
8331       deleteSingle_result typedOther = (deleteSingle_result)other;
8332 
8333       lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
8334       if (lastComparison != 0) {
8335         return lastComparison;
8336       }
8337       if (isSetIo()) {
8338         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
8339         if (lastComparison != 0) {
8340           return lastComparison;
8341         }
8342       }
8343       return 0;
8344     }
8345 
8346     public _Fields fieldForId(int fieldId) {
8347       return _Fields.findByThriftId(fieldId);
8348     }
8349 
8350     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8351       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8352     }
8353 
8354     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8355       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8356       }
8357 
8358     @Override
8359     public String toString() {
8360       StringBuilder sb = new StringBuilder("deleteSingle_result(");
8361       boolean first = true;
8362 
8363       sb.append("io:");
8364       if (this.io == null) {
8365         sb.append("null");
8366       } else {
8367         sb.append(this.io);
8368       }
8369       first = false;
8370       sb.append(")");
8371       return sb.toString();
8372     }
8373 
8374     public void validate() throws org.apache.thrift.TException {
8375       // check for required fields
8376     }
8377 
8378     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8379       try {
8380         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8381       } catch (org.apache.thrift.TException te) {
8382         throw new java.io.IOException(te);
8383       }
8384     }
8385 
8386     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8387       try {
8388         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8389       } catch (org.apache.thrift.TException te) {
8390         throw new java.io.IOException(te);
8391       }
8392     }
8393 
8394     private static class deleteSingle_resultStandardSchemeFactory implements SchemeFactory {
8395       public deleteSingle_resultStandardScheme getScheme() {
8396         return new deleteSingle_resultStandardScheme();
8397       }
8398     }
8399 
8400     private static class deleteSingle_resultStandardScheme extends StandardScheme<deleteSingle_result> {
8401 
8402       public void read(org.apache.thrift.protocol.TProtocol iprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8403         org.apache.thrift.protocol.TField schemeField;
8404         iprot.readStructBegin();
8405         while (true)
8406         {
8407           schemeField = iprot.readFieldBegin();
8408           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
8409             break;
8410           }
8411           switch (schemeField.id) {
8412             case 1: // IO
8413               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
8414                 struct.io = new TIOError();
8415                 struct.io.read(iprot);
8416                 struct.setIoIsSet(true);
8417               } else { 
8418                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8419               }
8420               break;
8421             default:
8422               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8423           }
8424           iprot.readFieldEnd();
8425         }
8426         iprot.readStructEnd();
8427 
8428         // check for required fields of primitive type, which can't be checked in the validate method
8429         struct.validate();
8430       }
8431 
8432       public void write(org.apache.thrift.protocol.TProtocol oprot, deleteSingle_result struct) throws org.apache.thrift.TException {
8433         struct.validate();
8434 
8435         oprot.writeStructBegin(STRUCT_DESC);
8436         if (struct.io != null) {
8437           oprot.writeFieldBegin(IO_FIELD_DESC);
8438           struct.io.write(oprot);
8439           oprot.writeFieldEnd();
8440         }
8441         oprot.writeFieldStop();
8442         oprot.writeStructEnd();
8443       }
8444 
8445     }
8446 
8447     private static class deleteSingle_resultTupleSchemeFactory implements SchemeFactory {
8448       public deleteSingle_resultTupleScheme getScheme() {
8449         return new deleteSingle_resultTupleScheme();
8450       }
8451     }
8452 
8453     private static class deleteSingle_resultTupleScheme extends TupleScheme<deleteSingle_result> {
8454 
8455       @Override
8456       public void write(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8457         TTupleProtocol oprot = (TTupleProtocol) prot;
8458         BitSet optionals = new BitSet();
8459         if (struct.isSetIo()) {
8460           optionals.set(0);
8461         }
8462         oprot.writeBitSet(optionals, 1);
8463         if (struct.isSetIo()) {
8464           struct.io.write(oprot);
8465         }
8466       }
8467 
8468       @Override
8469       public void read(org.apache.thrift.protocol.TProtocol prot, deleteSingle_result struct) throws org.apache.thrift.TException {
8470         TTupleProtocol iprot = (TTupleProtocol) prot;
8471         BitSet incoming = iprot.readBitSet(1);
8472         if (incoming.get(0)) {
8473           struct.io = new TIOError();
8474           struct.io.read(iprot);
8475           struct.setIoIsSet(true);
8476         }
8477       }
8478     }
8479 
8480   }
8481 
8482   public static class deleteMultiple_args implements org.apache.thrift.TBase<deleteMultiple_args, deleteMultiple_args._Fields>, java.io.Serializable, Cloneable   {
8483     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_args");
8484 
8485     private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
8486     private static final org.apache.thrift.protocol.TField DELETES_FIELD_DESC = new org.apache.thrift.protocol.TField("deletes", org.apache.thrift.protocol.TType.LIST, (short)2);
8487 
8488     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
8489     static {
8490       schemes.put(StandardScheme.class, new deleteMultiple_argsStandardSchemeFactory());
8491       schemes.put(TupleScheme.class, new deleteMultiple_argsTupleSchemeFactory());
8492     }
8493 
8494     /**
8495      * the table to delete from
8496      */
8497     public ByteBuffer table; // required
8498     /**
8499      * list of TDeletes to delete
8500      */
8501     public List<TDelete> deletes; // required
8502 
8503     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
8504     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
8505       /**
8506        * the table to delete from
8507        */
8508       TABLE((short)1, "table"),
8509       /**
8510        * list of TDeletes to delete
8511        */
8512       DELETES((short)2, "deletes");
8513 
8514       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8515 
8516       static {
8517         for (_Fields field : EnumSet.allOf(_Fields.class)) {
8518           byName.put(field.getFieldName(), field);
8519         }
8520       }
8521 
8522       /**
8523        * Find the _Fields constant that matches fieldId, or null if its not found.
8524        */
8525       public static _Fields findByThriftId(int fieldId) {
8526         switch(fieldId) {
8527           case 1: // TABLE
8528             return TABLE;
8529           case 2: // DELETES
8530             return DELETES;
8531           default:
8532             return null;
8533         }
8534       }
8535 
8536       /**
8537        * Find the _Fields constant that matches fieldId, throwing an exception
8538        * if it is not found.
8539        */
8540       public static _Fields findByThriftIdOrThrow(int fieldId) {
8541         _Fields fields = findByThriftId(fieldId);
8542         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8543         return fields;
8544       }
8545 
8546       /**
8547        * Find the _Fields constant that matches name, or null if its not found.
8548        */
8549       public static _Fields findByName(String name) {
8550         return byName.get(name);
8551       }
8552 
8553       private final short _thriftId;
8554       private final String _fieldName;
8555 
8556       _Fields(short thriftId, String fieldName) {
8557         _thriftId = thriftId;
8558         _fieldName = fieldName;
8559       }
8560 
8561       public short getThriftFieldId() {
8562         return _thriftId;
8563       }
8564 
8565       public String getFieldName() {
8566         return _fieldName;
8567       }
8568     }
8569 
8570     // isset id assignments
8571     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
8572     static {
8573       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
8574       tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED, 
8575           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
8576       tmpMap.put(_Fields.DELETES, new org.apache.thrift.meta_data.FieldMetaData("deletes", org.apache.thrift.TFieldRequirementType.REQUIRED, 
8577           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
8578               new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
8579       metaDataMap = Collections.unmodifiableMap(tmpMap);
8580       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_args.class, metaDataMap);
8581     }
8582 
8583     public deleteMultiple_args() {
8584     }
8585 
8586     public deleteMultiple_args(
8587       ByteBuffer table,
8588       List<TDelete> deletes)
8589     {
8590       this();
8591       this.table = table;
8592       this.deletes = deletes;
8593     }
8594 
8595     /**
8596      * Performs a deep copy on <i>other</i>.
8597      */
8598     public deleteMultiple_args(deleteMultiple_args other) {
8599       if (other.isSetTable()) {
8600         this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
8601 ;
8602       }
8603       if (other.isSetDeletes()) {
8604         List<TDelete> __this__deletes = new ArrayList<TDelete>();
8605         for (TDelete other_element : other.deletes) {
8606           __this__deletes.add(new TDelete(other_element));
8607         }
8608         this.deletes = __this__deletes;
8609       }
8610     }
8611 
8612     public deleteMultiple_args deepCopy() {
8613       return new deleteMultiple_args(this);
8614     }
8615 
8616     @Override
8617     public void clear() {
8618       this.table = null;
8619       this.deletes = null;
8620     }
8621 
8622     /**
8623      * the table to delete from
8624      */
8625     public byte[] getTable() {
8626       setTable(org.apache.thrift.TBaseHelper.rightSize(table));
8627       return table == null ? null : table.array();
8628     }
8629 
8630     public ByteBuffer bufferForTable() {
8631       return table;
8632     }
8633 
8634     /**
8635      * the table to delete from
8636      */
8637     public deleteMultiple_args setTable(byte[] table) {
8638       setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
8639       return this;
8640     }
8641 
8642     public deleteMultiple_args setTable(ByteBuffer table) {
8643       this.table = table;
8644       return this;
8645     }
8646 
8647     public void unsetTable() {
8648       this.table = null;
8649     }
8650 
8651     /** Returns true if field table is set (has been assigned a value) and false otherwise */
8652     public boolean isSetTable() {
8653       return this.table != null;
8654     }
8655 
8656     public void setTableIsSet(boolean value) {
8657       if (!value) {
8658         this.table = null;
8659       }
8660     }
8661 
8662     public int getDeletesSize() {
8663       return (this.deletes == null) ? 0 : this.deletes.size();
8664     }
8665 
8666     public java.util.Iterator<TDelete> getDeletesIterator() {
8667       return (this.deletes == null) ? null : this.deletes.iterator();
8668     }
8669 
8670     public void addToDeletes(TDelete elem) {
8671       if (this.deletes == null) {
8672         this.deletes = new ArrayList<TDelete>();
8673       }
8674       this.deletes.add(elem);
8675     }
8676 
8677     /**
8678      * list of TDeletes to delete
8679      */
8680     public List<TDelete> getDeletes() {
8681       return this.deletes;
8682     }
8683 
8684     /**
8685      * list of TDeletes to delete
8686      */
8687     public deleteMultiple_args setDeletes(List<TDelete> deletes) {
8688       this.deletes = deletes;
8689       return this;
8690     }
8691 
8692     public void unsetDeletes() {
8693       this.deletes = null;
8694     }
8695 
8696     /** Returns true if field deletes is set (has been assigned a value) and false otherwise */
8697     public boolean isSetDeletes() {
8698       return this.deletes != null;
8699     }
8700 
8701     public void setDeletesIsSet(boolean value) {
8702       if (!value) {
8703         this.deletes = null;
8704       }
8705     }
8706 
8707     public void setFieldValue(_Fields field, Object value) {
8708       switch (field) {
8709       case TABLE:
8710         if (value == null) {
8711           unsetTable();
8712         } else {
8713           setTable((ByteBuffer)value);
8714         }
8715         break;
8716 
8717       case DELETES:
8718         if (value == null) {
8719           unsetDeletes();
8720         } else {
8721           setDeletes((List<TDelete>)value);
8722         }
8723         break;
8724 
8725       }
8726     }
8727 
8728     public Object getFieldValue(_Fields field) {
8729       switch (field) {
8730       case TABLE:
8731         return getTable();
8732 
8733       case DELETES:
8734         return getDeletes();
8735 
8736       }
8737       throw new IllegalStateException();
8738     }
8739 
8740     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
8741     public boolean isSet(_Fields field) {
8742       if (field == null) {
8743         throw new IllegalArgumentException();
8744       }
8745 
8746       switch (field) {
8747       case TABLE:
8748         return isSetTable();
8749       case DELETES:
8750         return isSetDeletes();
8751       }
8752       throw new IllegalStateException();
8753     }
8754 
8755     @Override
8756     public boolean equals(Object that) {
8757       if (that == null)
8758         return false;
8759       if (that instanceof deleteMultiple_args)
8760         return this.equals((deleteMultiple_args)that);
8761       return false;
8762     }
8763 
8764     public boolean equals(deleteMultiple_args that) {
8765       if (that == null)
8766         return false;
8767 
8768       boolean this_present_table = true && this.isSetTable();
8769       boolean that_present_table = true && that.isSetTable();
8770       if (this_present_table || that_present_table) {
8771         if (!(this_present_table && that_present_table))
8772           return false;
8773         if (!this.table.equals(that.table))
8774           return false;
8775       }
8776 
8777       boolean this_present_deletes = true && this.isSetDeletes();
8778       boolean that_present_deletes = true && that.isSetDeletes();
8779       if (this_present_deletes || that_present_deletes) {
8780         if (!(this_present_deletes && that_present_deletes))
8781           return false;
8782         if (!this.deletes.equals(that.deletes))
8783           return false;
8784       }
8785 
8786       return true;
8787     }
8788 
8789     @Override
8790     public int hashCode() {
8791       return 0;
8792     }
8793 
8794     public int compareTo(deleteMultiple_args other) {
8795       if (!getClass().equals(other.getClass())) {
8796         return getClass().getName().compareTo(other.getClass().getName());
8797       }
8798 
8799       int lastComparison = 0;
8800       deleteMultiple_args typedOther = (deleteMultiple_args)other;
8801 
8802       lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
8803       if (lastComparison != 0) {
8804         return lastComparison;
8805       }
8806       if (isSetTable()) {
8807         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
8808         if (lastComparison != 0) {
8809           return lastComparison;
8810         }
8811       }
8812       lastComparison = Boolean.valueOf(isSetDeletes()).compareTo(typedOther.isSetDeletes());
8813       if (lastComparison != 0) {
8814         return lastComparison;
8815       }
8816       if (isSetDeletes()) {
8817         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deletes, typedOther.deletes);
8818         if (lastComparison != 0) {
8819           return lastComparison;
8820         }
8821       }
8822       return 0;
8823     }
8824 
8825     public _Fields fieldForId(int fieldId) {
8826       return _Fields.findByThriftId(fieldId);
8827     }
8828 
8829     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
8830       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
8831     }
8832 
8833     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
8834       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
8835     }
8836 
8837     @Override
8838     public String toString() {
8839       StringBuilder sb = new StringBuilder("deleteMultiple_args(");
8840       boolean first = true;
8841 
8842       sb.append("table:");
8843       if (this.table == null) {
8844         sb.append("null");
8845       } else {
8846         org.apache.thrift.TBaseHelper.toString(this.table, sb);
8847       }
8848       first = false;
8849       if (!first) sb.append(", ");
8850       sb.append("deletes:");
8851       if (this.deletes == null) {
8852         sb.append("null");
8853       } else {
8854         sb.append(this.deletes);
8855       }
8856       first = false;
8857       sb.append(")");
8858       return sb.toString();
8859     }
8860 
8861     public void validate() throws org.apache.thrift.TException {
8862       // check for required fields
8863       if (table == null) {
8864         throw new org.apache.thrift.protocol.TProtocolException("Required field 'table' was not present! Struct: " + toString());
8865       }
8866       if (deletes == null) {
8867         throw new org.apache.thrift.protocol.TProtocolException("Required field 'deletes' was not present! Struct: " + toString());
8868       }
8869     }
8870 
8871     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
8872       try {
8873         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
8874       } catch (org.apache.thrift.TException te) {
8875         throw new java.io.IOException(te);
8876       }
8877     }
8878 
8879     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
8880       try {
8881         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
8882       } catch (org.apache.thrift.TException te) {
8883         throw new java.io.IOException(te);
8884       }
8885     }
8886 
8887     private static class deleteMultiple_argsStandardSchemeFactory implements SchemeFactory {
8888       public deleteMultiple_argsStandardScheme getScheme() {
8889         return new deleteMultiple_argsStandardScheme();
8890       }
8891     }
8892 
8893     private static class deleteMultiple_argsStandardScheme extends StandardScheme<deleteMultiple_args> {
8894 
8895       public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8896         org.apache.thrift.protocol.TField schemeField;
8897         iprot.readStructBegin();
8898         while (true)
8899         {
8900           schemeField = iprot.readFieldBegin();
8901           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
8902             break;
8903           }
8904           switch (schemeField.id) {
8905             case 1: // TABLE
8906               if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
8907                 struct.table = iprot.readBinary();
8908                 struct.setTableIsSet(true);
8909               } else { 
8910                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8911               }
8912               break;
8913             case 2: // DELETES
8914               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
8915                 {
8916                   org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
8917                   struct.deletes = new ArrayList<TDelete>(_list120.size);
8918                   for (int _i121 = 0; _i121 < _list120.size; ++_i121)
8919                   {
8920                     TDelete _elem122; // required
8921                     _elem122 = new TDelete();
8922                     _elem122.read(iprot);
8923                     struct.deletes.add(_elem122);
8924                   }
8925                   iprot.readListEnd();
8926                 }
8927                 struct.setDeletesIsSet(true);
8928               } else { 
8929                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8930               }
8931               break;
8932             default:
8933               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
8934           }
8935           iprot.readFieldEnd();
8936         }
8937         iprot.readStructEnd();
8938 
8939         // check for required fields of primitive type, which can't be checked in the validate method
8940         struct.validate();
8941       }
8942 
8943       public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8944         struct.validate();
8945 
8946         oprot.writeStructBegin(STRUCT_DESC);
8947         if (struct.table != null) {
8948           oprot.writeFieldBegin(TABLE_FIELD_DESC);
8949           oprot.writeBinary(struct.table);
8950           oprot.writeFieldEnd();
8951         }
8952         if (struct.deletes != null) {
8953           oprot.writeFieldBegin(DELETES_FIELD_DESC);
8954           {
8955             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.deletes.size()));
8956             for (TDelete _iter123 : struct.deletes)
8957             {
8958               _iter123.write(oprot);
8959             }
8960             oprot.writeListEnd();
8961           }
8962           oprot.writeFieldEnd();
8963         }
8964         oprot.writeFieldStop();
8965         oprot.writeStructEnd();
8966       }
8967 
8968     }
8969 
8970     private static class deleteMultiple_argsTupleSchemeFactory implements SchemeFactory {
8971       public deleteMultiple_argsTupleScheme getScheme() {
8972         return new deleteMultiple_argsTupleScheme();
8973       }
8974     }
8975 
8976     private static class deleteMultiple_argsTupleScheme extends TupleScheme<deleteMultiple_args> {
8977 
8978       @Override
8979       public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8980         TTupleProtocol oprot = (TTupleProtocol) prot;
8981         oprot.writeBinary(struct.table);
8982         {
8983           oprot.writeI32(struct.deletes.size());
8984           for (TDelete _iter124 : struct.deletes)
8985           {
8986             _iter124.write(oprot);
8987           }
8988         }
8989       }
8990 
8991       @Override
8992       public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_args struct) throws org.apache.thrift.TException {
8993         TTupleProtocol iprot = (TTupleProtocol) prot;
8994         struct.table = iprot.readBinary();
8995         struct.setTableIsSet(true);
8996         {
8997           org.apache.thrift.protocol.TList _list125 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
8998           struct.deletes = new ArrayList<TDelete>(_list125.size);
8999           for (int _i126 = 0; _i126 < _list125.size; ++_i126)
9000           {
9001             TDelete _elem127; // required
9002             _elem127 = new TDelete();
9003             _elem127.read(iprot);
9004             struct.deletes.add(_elem127);
9005           }
9006         }
9007         struct.setDeletesIsSet(true);
9008       }
9009     }
9010 
9011   }
9012 
9013   public static class deleteMultiple_result implements org.apache.thrift.TBase<deleteMultiple_result, deleteMultiple_result._Fields>, java.io.Serializable, Cloneable   {
9014     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteMultiple_result");
9015 
9016     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
9017     private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1);
9018 
9019     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
9020     static {
9021       schemes.put(StandardScheme.class, new deleteMultiple_resultStandardSchemeFactory());
9022       schemes.put(TupleScheme.class, new deleteMultiple_resultTupleSchemeFactory());
9023     }
9024 
9025     public List<TDelete> success; // required
9026     public TIOError io; // required
9027 
9028     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
9029     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
9030       SUCCESS((short)0, "success"),
9031       IO((short)1, "io");
9032 
9033       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9034 
9035       static {
9036         for (_Fields field : EnumSet.allOf(_Fields.class)) {
9037           byName.put(field.getFieldName(), field);
9038         }
9039       }
9040 
9041       /**
9042        * Find the _Fields constant that matches fieldId, or null if its not found.
9043        */
9044       public static _Fields findByThriftId(int fieldId) {
9045         switch(fieldId) {
9046           case 0: // SUCCESS
9047             return SUCCESS;
9048           case 1: // IO
9049             return IO;
9050           default:
9051             return null;
9052         }
9053       }
9054 
9055       /**
9056        * Find the _Fields constant that matches fieldId, throwing an exception
9057        * if it is not found.
9058        */
9059       public static _Fields findByThriftIdOrThrow(int fieldId) {
9060         _Fields fields = findByThriftId(fieldId);
9061         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9062         return fields;
9063       }
9064 
9065       /**
9066        * Find the _Fields constant that matches name, or null if its not found.
9067        */
9068       public static _Fields findByName(String name) {
9069         return byName.get(name);
9070       }
9071 
9072       private final short _thriftId;
9073       private final String _fieldName;
9074 
9075       _Fields(short thriftId, String fieldName) {
9076         _thriftId = thriftId;
9077         _fieldName = fieldName;
9078       }
9079 
9080       public short getThriftFieldId() {
9081         return _thriftId;
9082       }
9083 
9084       public String getFieldName() {
9085         return _fieldName;
9086       }
9087     }
9088 
9089     // isset id assignments
9090     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
9091     static {
9092       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
9093       tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
9094           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
9095               new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class))));
9096       tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, 
9097           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
9098       metaDataMap = Collections.unmodifiableMap(tmpMap);
9099       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteMultiple_result.class, metaDataMap);
9100     }
9101 
9102     public deleteMultiple_result() {
9103     }
9104 
9105     public deleteMultiple_result(
9106       List<TDelete> success,
9107       TIOError io)
9108     {
9109       this();
9110       this.success = success;
9111       this.io = io;
9112     }
9113 
9114     /**
9115      * Performs a deep copy on <i>other</i>.
9116      */
9117     public deleteMultiple_result(deleteMultiple_result other) {
9118       if (other.isSetSuccess()) {
9119         List<TDelete> __this__success = new ArrayList<TDelete>();
9120         for (TDelete other_element : other.success) {
9121           __this__success.add(new TDelete(other_element));
9122         }
9123         this.success = __this__success;
9124       }
9125       if (other.isSetIo()) {
9126         this.io = new TIOError(other.io);
9127       }
9128     }
9129 
9130     public deleteMultiple_result deepCopy() {
9131       return new deleteMultiple_result(this);
9132     }
9133 
9134     @Override
9135     public void clear() {
9136       this.success = null;
9137       this.io = null;
9138     }
9139 
9140     public int getSuccessSize() {
9141       return (this.success == null) ? 0 : this.success.size();
9142     }
9143 
9144     public java.util.Iterator<TDelete> getSuccessIterator() {
9145       return (this.success == null) ? null : this.success.iterator();
9146     }
9147 
9148     public void addToSuccess(TDelete elem) {
9149       if (this.success == null) {
9150         this.success = new ArrayList<TDelete>();
9151       }
9152       this.success.add(elem);
9153     }
9154 
9155     public List<TDelete> getSuccess() {
9156       return this.success;
9157     }
9158 
9159     public deleteMultiple_result setSuccess(List<TDelete> success) {
9160       this.success = success;
9161       return this;
9162     }
9163 
9164     public void unsetSuccess() {
9165       this.success = null;
9166     }
9167 
9168     /** Returns true if field success is set (has been assigned a value) and false otherwise */
9169     public boolean isSetSuccess() {
9170       return this.success != null;
9171     }
9172 
9173     public void setSuccessIsSet(boolean value) {
9174       if (!value) {
9175         this.success = null;
9176       }
9177     }
9178 
9179     public TIOError getIo() {
9180       return this.io;
9181     }
9182 
9183     public deleteMultiple_result setIo(TIOError io) {
9184       this.io = io;
9185       return this;
9186     }
9187 
9188     public void unsetIo() {
9189       this.io = null;
9190     }
9191 
9192     /** Returns true if field io is set (has been assigned a value) and false otherwise */
9193     public boolean isSetIo() {
9194       return this.io != null;
9195     }
9196 
9197     public void setIoIsSet(boolean value) {
9198       if (!value) {
9199         this.io = null;
9200       }
9201     }
9202 
9203     public void setFieldValue(_Fields field, Object value) {
9204       switch (field) {
9205       case SUCCESS:
9206         if (value == null) {
9207           unsetSuccess();
9208         } else {
9209           setSuccess((List<TDelete>)value);
9210         }
9211         break;
9212 
9213       case IO:
9214         if (value == null) {
9215           unsetIo();
9216         } else {
9217           setIo((TIOError)value);
9218         }
9219         break;
9220 
9221       }
9222     }
9223 
9224     public Object getFieldValue(_Fields field) {
9225       switch (field) {
9226       case SUCCESS:
9227         return getSuccess();
9228 
9229       case IO:
9230         return getIo();
9231 
9232       }
9233       throw new IllegalStateException();
9234     }
9235 
9236     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
9237     public boolean isSet(_Fields field) {
9238       if (field == null) {
9239         throw new IllegalArgumentException();
9240       }
9241 
9242       switch (field) {
9243       case SUCCESS:
9244         return isSetSuccess();
9245       case IO:
9246         return isSetIo();
9247       }
9248       throw new IllegalStateException();
9249     }
9250 
9251     @Override
9252     public boolean equals(Object that) {
9253       if (that == null)
9254         return false;
9255       if (that instanceof deleteMultiple_result)
9256         return this.equals((deleteMultiple_result)that);
9257       return false;
9258     }
9259 
9260     public boolean equals(deleteMultiple_result that) {
9261       if (that == null)
9262         return false;
9263 
9264       boolean this_present_success = true && this.isSetSuccess();
9265       boolean that_present_success = true && that.isSetSuccess();
9266       if (this_present_success || that_present_success) {
9267         if (!(this_present_success && that_present_success))
9268           return false;
9269         if (!this.success.equals(that.success))
9270           return false;
9271       }
9272 
9273       boolean this_present_io = true && this.isSetIo();
9274       boolean that_present_io = true && that.isSetIo();
9275       if (this_present_io || that_present_io) {
9276         if (!(this_present_io && that_present_io))
9277           return false;
9278         if (!this.io.equals(that.io))
9279           return false;
9280       }
9281 
9282       return true;
9283     }
9284 
9285     @Override
9286     public int hashCode() {
9287       return 0;
9288     }
9289 
9290     public int compareTo(deleteMultiple_result other) {
9291       if (!getClass().equals(other.getClass())) {
9292         return getClass().getName().compareTo(other.getClass().getName());
9293       }
9294 
9295       int lastComparison = 0;
9296       deleteMultiple_result typedOther = (deleteMultiple_result)other;
9297 
9298       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
9299       if (lastComparison != 0) {
9300         return lastComparison;
9301       }
9302       if (isSetSuccess()) {
9303         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
9304         if (lastComparison != 0) {
9305           return lastComparison;
9306         }
9307       }
9308       lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo());
9309       if (lastComparison != 0) {
9310         return lastComparison;
9311       }
9312       if (isSetIo()) {
9313         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io);
9314         if (lastComparison != 0) {
9315           return lastComparison;
9316         }
9317       }
9318       return 0;
9319     }
9320 
9321     public _Fields fieldForId(int fieldId) {
9322       return _Fields.findByThriftId(fieldId);
9323     }
9324 
9325     public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
9326       schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
9327     }
9328 
9329     public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
9330       schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
9331       }
9332 
9333     @Override
9334     public String toString() {
9335       StringBuilder sb = new StringBuilder("deleteMultiple_result(");
9336       boolean first = true;
9337 
9338       sb.append("success:");
9339       if (this.success == null) {
9340         sb.append("null");
9341       } else {
9342         sb.append(this.success);
9343       }
9344       first = false;
9345       if (!first) sb.append(", ");
9346       sb.append("io:");
9347       if (this.io == null) {
9348         sb.append("null");
9349       } else {
9350         sb.append(this.io);
9351       }
9352       first = false;
9353       sb.append(")");
9354       return sb.toString();
9355     }
9356 
9357     public void validate() throws org.apache.thrift.TException {
9358       // check for required fields
9359     }
9360 
9361     private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
9362       try {
9363         write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
9364       } catch (org.apache.thrift.TException te) {
9365         throw new java.io.IOException(te);
9366       }
9367     }
9368 
9369     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
9370       try {
9371         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
9372       } catch (org.apache.thrift.TException te) {
9373         throw new java.io.IOException(te);
9374       }
9375     }
9376 
9377     private static class deleteMultiple_resultStandardSchemeFactory implements SchemeFactory {
9378       public deleteMultiple_resultStandardScheme getScheme() {
9379         return new deleteMultiple_resultStandardScheme();
9380       }
9381     }
9382 
9383     private static class deleteMultiple_resultStandardScheme extends StandardScheme<deleteMultiple_result> {
9384 
9385       public void read(org.apache.thrift.protocol.TProtocol iprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9386         org.apache.thrift.protocol.TField schemeField;
9387         iprot.readStructBegin();
9388         while (true)
9389         {
9390           schemeField = iprot.readFieldBegin();
9391           if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
9392             break;
9393           }
9394           switch (schemeField.id) {
9395             case 0: // SUCCESS
9396               if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
9397                 {
9398                   org.apache.thrift.protocol.TList _list128 = iprot.readListBegin();
9399                   struct.success = new ArrayList<TDelete>(_list128.size);
9400                   for (int _i129 = 0; _i129 < _list128.size; ++_i129)
9401                   {
9402                     TDelete _elem130; // required
9403                     _elem130 = new TDelete();
9404                     _elem130.read(iprot);
9405                     struct.success.add(_elem130);
9406                   }
9407                   iprot.readListEnd();
9408                 }
9409                 struct.setSuccessIsSet(true);
9410               } else { 
9411                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9412               }
9413               break;
9414             case 1: // IO
9415               if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
9416                 struct.io = new TIOError();
9417                 struct.io.read(iprot);
9418                 struct.setIoIsSet(true);
9419               } else { 
9420                 org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9421               }
9422               break;
9423             default:
9424               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
9425           }
9426           iprot.readFieldEnd();
9427         }
9428         iprot.readStructEnd();
9429 
9430         // check for required fields of primitive type, which can't be checked in the validate method
9431         struct.validate();
9432       }
9433 
9434       public void write(org.apache.thrift.protocol.TProtocol oprot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9435         struct.validate();
9436 
9437         oprot.writeStructBegin(STRUCT_DESC);
9438         if (struct.success != null) {
9439           oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
9440           {
9441             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
9442             for (TDelete _iter131 : struct.success)
9443             {
9444               _iter131.write(oprot);
9445             }
9446             oprot.writeListEnd();
9447           }
9448           oprot.writeFieldEnd();
9449         }
9450         if (struct.io != null) {
9451           oprot.writeFieldBegin(IO_FIELD_DESC);
9452           struct.io.write(oprot);
9453           oprot.writeFieldEnd();
9454         }
9455         oprot.writeFieldStop();
9456         oprot.writeStructEnd();
9457       }
9458 
9459     }
9460 
9461     private static class deleteMultiple_resultTupleSchemeFactory implements SchemeFactory {
9462       public deleteMultiple_resultTupleScheme getScheme() {
9463         return new deleteMultiple_resultTupleScheme();
9464       }
9465     }
9466 
9467     private static class deleteMultiple_resultTupleScheme extends TupleScheme<deleteMultiple_result> {
9468 
9469       @Override
9470       public void write(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9471         TTupleProtocol oprot = (TTupleProtocol) prot;
9472         BitSet optionals = new BitSet();
9473         if (struct.isSetSuccess()) {
9474           optionals.set(0);
9475         }
9476         if (struct.isSetIo()) {
9477           optionals.set(1);
9478         }
9479         oprot.writeBitSet(optionals, 2);
9480         if (struct.isSetSuccess()) {
9481           {
9482             oprot.writeI32(struct.success.size());
9483             for (TDelete _iter132 : struct.success)
9484             {
9485               _iter132.write(oprot);
9486             }
9487           }
9488         }
9489         if (struct.isSetIo()) {
9490           struct.io.write(oprot);
9491         }
9492       }
9493 
9494       @Override
9495       public void read(org.apache.thrift.protocol.TProtocol prot, deleteMultiple_result struct) throws org.apache.thrift.TException {
9496         TTupleProtocol iprot = (TTupleProtocol) prot;
9497         BitSet incoming = iprot.readBitSet(2);
9498         if (incoming.get(0)) {
9499           {
9500             org.apache.thrift.protocol.TList _list133 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
9501             struct.success = new ArrayList<TDelete>(_list133.size);
9502             for (int _i134 = 0; _i134 < _list133.size; ++_i134)
9503             {
9504               TDelete _elem135; // required
9505               _elem135 = new TDelete();
9506               _elem135.read(iprot);
9507               struct.success.add(_elem135);
9508             }
9509           }
9510           struct.setSuccessIsSet(true);
9511         }
9512         if (incoming.get(1)) {
9513           struct.io = new TIOError();
9514           struct.io.read(iprot);
9515           struct.setIoIsSet(true);
9516         }
9517       }
9518     }
9519 
9520   }
9521 
9522   public static class checkAndDelete_args implements org.apache.thrift.TBase<checkAndDelete_args, checkAndDelete_args._Fields>, java.io.Serializable, Cloneable   {
9523     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkAndDelete_args");
9524 
9525     private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
9526     private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2);
9527     private static final org.apache.thrift.protocol.TField FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("family", org.apache.thrift.protocol.TType.STRING, (short)3);
9528     private static final org.apache.thrift.protocol.TField QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("qualifier", org.apache.thrift.protocol.TType.STRING, (short)4);
9529     private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)5);
9530     private static final org.apache.thrift.protocol.TField DELETE_SINGLE_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteSingle", org.apache.thrift.protocol.TType.STRUCT, (short)6);
9531 
9532     private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
9533     static {
9534       schemes.put(StandardScheme.class, new checkAndDelete_argsStandardSchemeFactory());
9535       schemes.put(TupleScheme.class, new checkAndDelete_argsTupleSchemeFactory());
9536     }
9537 
9538     /**
9539      * to check in and delete from
9540      */
9541     public ByteBuffer table; // required
9542     /**
9543      * row to check
9544      */
9545     public ByteBuffer row; // required
9546     /**
9547      * column family to check
9548      */
9549     public ByteBuffer family; // required
9550     /**
9551      * column qualifier to check
9552      */
9553     public ByteBuffer qualifier; // required
9554     /**
9555      * the expected value, if not provided the
9556      * check is for the non-existence of the
9557      * column in question
9558      */
9559     public ByteBuffer value; // required
9560     /**
9561      * the TDelete to execute if the check succeeds
9562      */
9563     public TDelete deleteSingle; // required
9564 
9565     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
9566     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
9567       /**
9568        * to check in and delete from
9569        */
9570       TABLE((short)1, "table"),
9571       /**
9572        * row to check
9573        */
9574       ROW((short)2, "row"),
9575       /**
9576        * column family to check
9577        */
9578       FAMILY((short)3, "family"),
9579       /**
9580        * column qualifier to check
9581        */
9582       QUALIFIER((short)4, "qualifier"),
9583       /**
9584        * the expected value, if not provided the
9585        * check is for the non-existence of the
9586        * column in question
9587        */
9588       VALUE((short)5, "value"),
9589       /**
9590        * the TDelete to execute if the check succeeds
9591        */
9592       DELETE_SINGLE((short)6, "deleteSingle");
9593 
9594       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9595 
9596       static {
9597         for (_Fields field : EnumSet.allOf(_Fields.class)) {
9598           byName.put(field.getFieldName(), field);
9599         }
9600       }
9601 
9602       /**
9603        * Find the _Fields constant that matches fieldId, or null if its not found.
9604        */
9605       public static _Fields findByThriftId(int fieldId) {
9606         switch(fieldId) {
9607           case 1: // TABLE
9608             return TABLE;
9609           case 2: // ROW
9610             return ROW;
9611           case 3: // FAMILY
9612             return FAMILY;
9613           case 4: // QUALIFIER
9614             return QUALIFIER;
9615           case 5: // VALUE
9616             return VALUE;
9617           case 6: // DELETE_SINGLE
9618             return DELETE_SINGLE;
9619           default:
9620             return null;
9621         }
9622       }
9623 
9624       /**
9625        * Find the _Fields constant that matches fieldId, throwing an exception
9626        * if it is not found.
9627        */
9628       public static _Fields findByThriftIdOrThrow(int fieldId) {
9629         _Fields fields = findByThriftId(fieldId);
9630         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9631         return fields;
9632       }
9633 
9634       /**
9635        * Find the _Fields constant that matches name, or null if its not found.
9636        */
9637       public static _Fields findByName(String name) {
9638         return byName.get(name);
9639       }
9640 
9641       private final short _thriftId;
9642       private final String _fieldName;
9643 
9644       _Fields(short thriftId, String fieldName) {
9645         _thriftId = thriftId;
9646         _fieldName = fieldName;
9647       }
9648 
9649       public short getThriftFieldId() {
9650         return _thriftId;
9651       }
9652 
9653       public String getFieldName() {
9654         return _fieldName;
9655       }
9656     }
9657 
9658     // isset id assignments
9659     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
9660     static {
9661       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
9662       tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.REQUIRED, 
9663           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
9664       tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED, 
9665           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
9666       tmpMap.put(_Fields.FAMILY, new org.apache.thrift.meta_data.FieldMetaData("family", org.apache.thrift.TFieldRequirementType.REQUIRED, 
9667           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
9668       tmpMap.put(_Fields.QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("qualifier", org.apache.thrift.TFieldRequirementType.REQUIRED, 
9669           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
9670       tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT, 
9671           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
9672       tmpMap.put(_Fields.DELETE_SINGLE, new org.apache.thrift.meta_data.FieldMetaData("deleteSingle", org.apache.thrift.TFieldRequirementType.REQUIRED, 
9673           new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDelete.class)));
9674       metaDataMap = Collections.unmodifiableMap(tmpMap);
9675       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkAndDelete_args.class, metaDataMap);
9676     }
9677 
9678     public checkAndDelete_args() {
9679     }
9680 
9681     public checkAndDelete_args(
9682       ByteBuffer table,
9683       ByteBuffer row,
9684       ByteBuffer family,
9685       ByteBuffer qualifier,
9686       ByteBuffer value,
9687       TDelete deleteSingle)
9688     {
9689       this();
9690       this.table = table;
9691       this.row = row;
9692       this.family = family;
9693       this.qualifier = qualifier;
9694       this.value = value;
9695       this.deleteSingle = deleteSingle;
9696     }
9697 
9698     /**
9699      * Performs a deep copy on <i>other</i>.
9700      */
9701     public checkAndDelete_args(checkAndDelete_args other) {
9702       if (other.isSetTable()) {
9703         this.table = org.apache.thrift.TBaseHelper.copyBinary(other.table);
9704 ;
9705       }
9706       if (other.isSetRow()) {
9707         this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row);
9708 ;
9709       }
9710       if (other.isSetFamily()) {
9711         this.family = org.apache.thrift.TBaseHelper.copyBinary(other.family);
9712 ;
9713       }
9714       if (other.isSetQualifier()) {
9715         this.qualifier = org.apache.thrift.TBaseHelper.copyBinary(other.qualifier);
9716 ;
9717       }
9718       if (other.isSetValue()) {
9719         this.value = org.apache.thrift.TBaseHelper.copyBinary(other.value);
9720 ;
9721       }
9722       if (other.isSetDeleteSingle()) {
9723         this.deleteSingle = new TDelete(other.deleteSingle);
9724       }
9725     }
9726 
9727     public checkAndDelete_args deepCopy() {
9728       return new checkAndDelete_args(this);
9729     }
9730 
9731     @Override
9732     public void clear() {
9733       this.table = null;
9734       this.row = null;
9735       this.family = null;
9736       this.qualifier = null;
9737       this.value = null;
9738       this.deleteSingle = null;
9739     }
9740 
9741     /**
9742      * to check in and delete from
9743      */
9744     public byte[] getTable() {
9745