View Javadoc

1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  package org.apache.hadoop.hbase.thrift.generated;
19  
20  import org.apache.commons.lang.builder.HashCodeBuilder;
21  import java.util.List;
22  import java.util.ArrayList;
23  import java.util.Map;
24  import java.util.HashMap;
25  import java.util.EnumMap;
26  import java.util.Set;
27  import java.util.HashSet;
28  import java.util.EnumSet;
29  import java.util.Collections;
30  import java.util.BitSet;
31  import java.util.Arrays;
32  import org.slf4j.Logger;
33  import org.slf4j.LoggerFactory;
34  
35  import org.apache.thrift.*;
36  import org.apache.thrift.meta_data.*;
37  import org.apache.thrift.protocol.*;
38  
39  public class Hbase {
40  
41    public interface Iface {
42  
43      /**
44       * Brings a table on-line (enables it)
45       *
46       * @param tableName name of the table
47       */
48      public void enableTable(byte[] tableName) throws IOError, TException;
49  
50      /**
51       * Disables a table (takes it off-line) If it is being served, the master
52       * will tell the servers to stop serving it.
53       *
54       * @param tableName name of the table
55       */
56      public void disableTable(byte[] tableName) throws IOError, TException;
57  
58      /**
59       * @return true if table is on-line
60       *
61       * @param tableName name of the table to check
62       */
63      public boolean isTableEnabled(byte[] tableName) throws IOError, TException;
64  
65      public void compact(byte[] tableNameOrRegionName) throws IOError, TException;
66  
67      public void majorCompact(byte[] tableNameOrRegionName) throws IOError, TException;
68  
69      /**
70       * List all the userspace tables.
71       *
72       * @return returns a list of names
73       */
74      public List<byte[]> getTableNames() throws IOError, TException;
75  
76      /**
77       * List all the column families assoicated with a table.
78       *
79       * @return list of column family descriptors
80       *
81       * @param tableName table name
82       */
83      public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException;
84  
85      /**
86       * List the regions associated with a table.
87       *
88       * @return list of region descriptors
89       *
90       * @param tableName table name
91       */
92      public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException;
93  
94      /**
95       * Create a table with the specified column families.  The name
96       * field for each ColumnDescriptor must be set and must end in a
97       * colon (:). All other fields are optional and will get default
98       * values if not explicitly specified.
99       *
100      * @throws IllegalArgument if an input parameter is invalid
101      *
102      * @throws AlreadyExists if the table name already exists
103      *
104      * @param tableName name of table to create
105      *
106      * @param columnFamilies list of column family descriptors
107      */
108     public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException;
109 
110     /**
111      * Deletes a table
112      *
113      * @throws IOError if table doesn't exist on server or there was some other
114      * problem
115      *
116      * @param tableName name of table to delete
117      */
118     public void deleteTable(byte[] tableName) throws IOError, TException;
119 
120     /**
121      * Get a single TCell for the specified table, row, and column at the
122      * latest timestamp. Returns an empty list if no such value exists.
123      *
124      * @return value for specified row/column
125      *
126      * @param tableName name of table
127      *
128      * @param row row key
129      *
130      * @param column column name
131      */
132     public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
133 
134     /**
135      * Get the specified number of versions for the specified table,
136      * row, and column.
137      *
138      * @return list of cells for specified row/column
139      *
140      * @param tableName name of table
141      *
142      * @param row row key
143      *
144      * @param column column name
145      *
146      * @param numVersions number of versions to retrieve
147      */
148     public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException;
149 
150     /**
151      * Get the specified number of versions for the specified table,
152      * row, and column.  Only versions less than or equal to the specified
153      * timestamp will be returned.
154      *
155      * @return list of cells for specified row/column
156      *
157      * @param tableName name of table
158      *
159      * @param row row key
160      *
161      * @param column column name
162      *
163      * @param timestamp timestamp
164      *
165      * @param numVersions number of versions to retrieve
166      */
167     public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException;
168 
169     /**
170      * Get all the data for the specified table and row at the latest
171      * timestamp. Returns an empty list if the row does not exist.
172      *
173      * @return TRowResult containing the row and map of columns to TCells
174      *
175      * @param tableName name of table
176      *
177      * @param row row key
178      */
179     public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException;
180 
181     /**
182      * Get the specified columns for the specified table and row at the latest
183      * timestamp. Returns an empty list if the row does not exist.
184      *
185      * @return TRowResult containing the row and map of columns to TCells
186      *
187      * @param tableName name of table
188      *
189      * @param row row key
190      *
191      * @param columns List of columns to return, null for all columns
192      */
193     public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException;
194 
195     /**
196      * Get all the data for the specified table and row at the specified
197      * timestamp. Returns an empty list if the row does not exist.
198      *
199      * @return TRowResult containing the row and map of columns to TCells
200      *
201      * @param tableName name of the table
202      *
203      * @param row row key
204      *
205      * @param timestamp timestamp
206      */
207     public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
208 
209     /**
210      * Get the specified columns for the specified table and row at the specified
211      * timestamp. Returns an empty list if the row does not exist.
212      *
213      * @return TRowResult containing the row and map of columns to TCells
214      *
215      * @param tableName name of table
216      *
217      * @param row row key
218      *
219      * @param columns List of columns to return, null for all columns
220      *
221      * @param timestamp
222      */
223     public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException;
224 
225     /**
226      * Get all the data for the specified table and rows at the latest
227      * timestamp. Returns an empty list if no rows exist.
228      *
229      * @return TRowResult containing the rows and map of columns to TCells
230      *
231      * @param tableName name of table
232      *
233      * @param rows row keys
234      */
235     public List<TRowResult> getRows(byte[] tableName, List<byte[]> rows) throws IOError, TException;
236 
237     /**
238      * Get the specified columns for the specified table and rows at the latest
239      * timestamp. Returns an empty list if no rows exist.
240      *
241      * @return TRowResult containing the rows and map of columns to TCells
242      *
243      * @param tableName name of table
244      *
245      * @param rows row keys
246      *
247      * @param columns List of columns to return, null for all columns
248      */
249     public List<TRowResult> getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns) throws IOError, TException;
250 
251     /**
252      * Get all the data for the specified table and rows at the specified
253      * timestamp. Returns an empty list if no rows exist.
254      *
255      * @return TRowResult containing the rows and map of columns to TCells
256      *
257      * @param tableName name of the table
258      *
259      * @param rows row keys
260      *
261      * @param timestamp timestamp
262      */
263     public List<TRowResult> getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws IOError, TException;
264 
265     /**
266      * Get the specified columns for the specified table and rows at the specified
267      * timestamp. Returns an empty list if no rows exist.
268      *
269      * @return TRowResult containing the rows and map of columns to TCells
270      *
271      * @param tableName name of table
272      *
273      * @param rows row keys
274      *
275      * @param columns List of columns to return, null for all columns
276      *
277      * @param timestamp
278      */
279     public List<TRowResult> getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp) throws IOError, TException;
280 
281     /**
282      * Apply a series of mutations (updates/deletes) to a row in a
283      * single transaction.  If an exception is thrown, then the
284      * transaction is aborted.  Default current timestamp is used, and
285      * all entries will have an identical timestamp.
286      *
287      * @param tableName name of table
288      *
289      * @param row row key
290      *
291      * @param mutations list of mutation commands
292      */
293     public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException;
294 
295     /**
296      * Apply a series of mutations (updates/deletes) to a row in a
297      * single transaction.  If an exception is thrown, then the
298      * transaction is aborted.  The specified timestamp is used, and
299      * all entries will have an identical timestamp.
300      *
301      * @param tableName name of table
302      *
303      * @param row row key
304      *
305      * @param mutations list of mutation commands
306      *
307      * @param timestamp timestamp
308      */
309     public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException;
310 
311     /**
312      * Apply a series of batches (each a series of mutations on a single row)
313      * in a single transaction.  If an exception is thrown, then the
314      * transaction is aborted.  Default current timestamp is used, and
315      * all entries will have an identical timestamp.
316      *
317      * @param tableName name of table
318      *
319      * @param rowBatches list of row batches
320      */
321     public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException;
322 
323     /**
324      * Apply a series of batches (each a series of mutations on a single row)
325      * in a single transaction.  If an exception is thrown, then the
326      * transaction is aborted.  The specified timestamp is used, and
327      * all entries will have an identical timestamp.
328      *
329      * @param tableName name of table
330      *
331      * @param rowBatches list of row batches
332      *
333      * @param timestamp timestamp
334      */
335     public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException;
336 
337     /**
338      * Atomically increment the column value specified.  Returns the next value post increment.
339      *
340      * @param tableName name of table
341      *
342      * @param row row to increment
343      *
344      * @param column name of column
345      *
346      * @param value amount to increment by
347      */
348     public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException;
349 
350     /**
351      * Delete all cells that match the passed row and column.
352      *
353      * @param tableName name of table
354      *
355      * @param row Row to update
356      *
357      * @param column name of column whose value is to be deleted
358      */
359     public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
360 
361     /**
362      * Delete all cells that match the passed row and column and whose
363      * timestamp is equal-to or older than the passed timestamp.
364      *
365      * @param tableName name of table
366      *
367      * @param row Row to update
368      *
369      * @param column name of column whose value is to be deleted
370      *
371      * @param timestamp timestamp
372      */
373     public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException;
374 
375     /**
376      * Completely delete the row's cells.
377      *
378      * @param tableName name of table
379      *
380      * @param row key of the row to be completely deleted.
381      */
382     public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException;
383 
384     /**
385      * Completely delete the row's cells marked with a timestamp
386      * equal-to or older than the passed timestamp.
387      *
388      * @param tableName name of table
389      *
390      * @param row key of the row to be completely deleted.
391      *
392      * @param timestamp timestamp
393      */
394     public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
395 
396     /**
397      * Get a scanner on the current table starting at the specified row and
398      * ending at the last row in the table.  Return the specified columns.
399      *
400      * @return scanner id to be used with other scanner procedures
401      *
402      * @param tableName name of table
403      *
404      * @param startRow Starting row in table to scan.
405      * Send "" (empty string) to start at the first row.
406      *
407      * @param columns columns to scan. If column name is a column family, all
408      * columns of the specified column family are returned. It's also possible
409      * to pass a regex in the column qualifier.
410      */
411     public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException;
412 
413     /**
414      * Get a scanner on the current table starting and stopping at the
415      * specified rows.  ending at the last row in the table.  Return the
416      * specified columns.
417      *
418      * @return scanner id to be used with other scanner procedures
419      *
420      * @param tableName name of table
421      *
422      * @param startRow Starting row in table to scan.
423      * Send "" (empty string) to start at the first row.
424      *
425      * @param stopRow row to stop scanning on. This row is *not* included in the
426      * scanner's results
427      *
428      * @param columns columns to scan. If column name is a column family, all
429      * columns of the specified column family are returned. It's also possible
430      * to pass a regex in the column qualifier.
431      */
432     public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException;
433 
434     /**
435      * Open a scanner for a given prefix.  That is all rows will have the specified
436      * prefix. No other rows will be returned.
437      *
438      * @return scanner id to use with other scanner calls
439      *
440      * @param tableName name of table
441      *
442      * @param startAndPrefix the prefix (and thus start row) of the keys you want
443      *
444      * @param columns the columns you want returned
445      */
446     public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException;
447 
448     /**
449      * Get a scanner on the current table starting at the specified row and
450      * ending at the last row in the table.  Return the specified columns.
451      * Only values with the specified timestamp are returned.
452      *
453      * @return scanner id to be used with other scanner procedures
454      *
455      * @param tableName name of table
456      *
457      * @param startRow Starting row in table to scan.
458      * Send "" (empty string) to start at the first row.
459      *
460      * @param columns columns to scan. If column name is a column family, all
461      * columns of the specified column family are returned. It's also possible
462      * to pass a regex in the column qualifier.
463      *
464      * @param timestamp timestamp
465      */
466     public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException;
467 
468     /**
469      * Get a scanner on the current table starting and stopping at the
470      * specified rows.  ending at the last row in the table.  Return the
471      * specified columns.  Only values with the specified timestamp are
472      * returned.
473      *
474      * @return scanner id to be used with other scanner procedures
475      *
476      * @param tableName name of table
477      *
478      * @param startRow Starting row in table to scan.
479      * Send "" (empty string) to start at the first row.
480      *
481      * @param stopRow row to stop scanning on. This row is *not* included in the
482      * scanner's results
483      *
484      * @param columns columns to scan. If column name is a column family, all
485      * columns of the specified column family are returned. It's also possible
486      * to pass a regex in the column qualifier.
487      *
488      * @param timestamp timestamp
489      */
490     public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException;
491 
492     /**
493      * Returns the scanner's current row value and advances to the next
494      * row in the table.  When there are no more rows in the table, or a key
495      * greater-than-or-equal-to the scanner's specified stopRow is reached,
496      * an empty list is returned.
497      *
498      * @return a TRowResult containing the current row and a map of the columns to TCells.
499      *
500      * @throws IllegalArgument if ScannerID is invalid
501      *
502      * @throws NotFound when the scanner reaches the end
503      *
504      * @param id id of a scanner returned by scannerOpen
505      */
506     public List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, TException;
507 
508     /**
509      * Returns, starting at the scanner's current row value nbRows worth of
510      * rows and advances to the next row in the table.  When there are no more
511      * rows in the table, or a key greater-than-or-equal-to the scanner's
512      * specified stopRow is reached,  an empty list is returned.
513      *
514      * @return a TRowResult containing the current row and a map of the columns to TCells.
515      *
516      * @throws IllegalArgument if ScannerID is invalid
517      *
518      * @throws NotFound when the scanner reaches the end
519      *
520      * @param id id of a scanner returned by scannerOpen
521      *
522      * @param nbRows number of results to return
523      */
524     public List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException;
525 
526     /**
527      * Closes the server-state associated with an open scanner.
528      *
529      * @throws IllegalArgument if ScannerID is invalid
530      *
531      * @param id id of a scanner returned by scannerOpen
532      */
533     public void scannerClose(int id) throws IOError, IllegalArgument, TException;
534 
535   }
536 
537   public static class Client implements Iface {
538     public Client(TProtocol prot)
539     {
540       this(prot, prot);
541     }
542 
543     public Client(TProtocol iprot, TProtocol oprot)
544     {
545       iprot_ = iprot;
546       oprot_ = oprot;
547     }
548 
549     protected TProtocol iprot_;
550     protected TProtocol oprot_;
551 
552     protected int seqid_;
553 
554     public TProtocol getInputProtocol()
555     {
556       return this.iprot_;
557     }
558 
559     public TProtocol getOutputProtocol()
560     {
561       return this.oprot_;
562     }
563 
564     public void enableTable(byte[] tableName) throws IOError, TException
565     {
566       send_enableTable(tableName);
567       recv_enableTable();
568     }
569 
570     public void send_enableTable(byte[] tableName) throws TException
571     {
572       oprot_.writeMessageBegin(new TMessage("enableTable", TMessageType.CALL, seqid_));
573       enableTable_args args = new enableTable_args();
574       args.tableName = tableName;
575       args.write(oprot_);
576       oprot_.writeMessageEnd();
577       oprot_.getTransport().flush();
578     }
579 
580     public void recv_enableTable() throws IOError, TException
581     {
582       TMessage msg = iprot_.readMessageBegin();
583       if (msg.type == TMessageType.EXCEPTION) {
584         TApplicationException x = TApplicationException.read(iprot_);
585         iprot_.readMessageEnd();
586         throw x;
587       }
588       enableTable_result result = new enableTable_result();
589       result.read(iprot_);
590       iprot_.readMessageEnd();
591       if (result.io != null) {
592         throw result.io;
593       }
594       return;
595     }
596 
597     public void disableTable(byte[] tableName) throws IOError, TException
598     {
599       send_disableTable(tableName);
600       recv_disableTable();
601     }
602 
603     public void send_disableTable(byte[] tableName) throws TException
604     {
605       oprot_.writeMessageBegin(new TMessage("disableTable", TMessageType.CALL, seqid_));
606       disableTable_args args = new disableTable_args();
607       args.tableName = tableName;
608       args.write(oprot_);
609       oprot_.writeMessageEnd();
610       oprot_.getTransport().flush();
611     }
612 
613     public void recv_disableTable() throws IOError, TException
614     {
615       TMessage msg = iprot_.readMessageBegin();
616       if (msg.type == TMessageType.EXCEPTION) {
617         TApplicationException x = TApplicationException.read(iprot_);
618         iprot_.readMessageEnd();
619         throw x;
620       }
621       disableTable_result result = new disableTable_result();
622       result.read(iprot_);
623       iprot_.readMessageEnd();
624       if (result.io != null) {
625         throw result.io;
626       }
627       return;
628     }
629 
630     public boolean isTableEnabled(byte[] tableName) throws IOError, TException
631     {
632       send_isTableEnabled(tableName);
633       return recv_isTableEnabled();
634     }
635 
636     public void send_isTableEnabled(byte[] tableName) throws TException
637     {
638       oprot_.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.CALL, seqid_));
639       isTableEnabled_args args = new isTableEnabled_args();
640       args.tableName = tableName;
641       args.write(oprot_);
642       oprot_.writeMessageEnd();
643       oprot_.getTransport().flush();
644     }
645 
646     public boolean recv_isTableEnabled() throws IOError, TException
647     {
648       TMessage msg = iprot_.readMessageBegin();
649       if (msg.type == TMessageType.EXCEPTION) {
650         TApplicationException x = TApplicationException.read(iprot_);
651         iprot_.readMessageEnd();
652         throw x;
653       }
654       isTableEnabled_result result = new isTableEnabled_result();
655       result.read(iprot_);
656       iprot_.readMessageEnd();
657       if (result.isSetSuccess()) {
658         return result.success;
659       }
660       if (result.io != null) {
661         throw result.io;
662       }
663       throw new TApplicationException(TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result");
664     }
665 
666     public void compact(byte[] tableNameOrRegionName) throws IOError, TException
667     {
668       send_compact(tableNameOrRegionName);
669       recv_compact();
670     }
671 
672     public void send_compact(byte[] tableNameOrRegionName) throws TException
673     {
674       oprot_.writeMessageBegin(new TMessage("compact", TMessageType.CALL, seqid_));
675       compact_args args = new compact_args();
676       args.tableNameOrRegionName = tableNameOrRegionName;
677       args.write(oprot_);
678       oprot_.writeMessageEnd();
679       oprot_.getTransport().flush();
680     }
681 
682     public void recv_compact() throws IOError, TException
683     {
684       TMessage msg = iprot_.readMessageBegin();
685       if (msg.type == TMessageType.EXCEPTION) {
686         TApplicationException x = TApplicationException.read(iprot_);
687         iprot_.readMessageEnd();
688         throw x;
689       }
690       compact_result result = new compact_result();
691       result.read(iprot_);
692       iprot_.readMessageEnd();
693       if (result.io != null) {
694         throw result.io;
695       }
696       return;
697     }
698 
699     public void majorCompact(byte[] tableNameOrRegionName) throws IOError, TException
700     {
701       send_majorCompact(tableNameOrRegionName);
702       recv_majorCompact();
703     }
704 
705     public void send_majorCompact(byte[] tableNameOrRegionName) throws TException
706     {
707       oprot_.writeMessageBegin(new TMessage("majorCompact", TMessageType.CALL, seqid_));
708       majorCompact_args args = new majorCompact_args();
709       args.tableNameOrRegionName = tableNameOrRegionName;
710       args.write(oprot_);
711       oprot_.writeMessageEnd();
712       oprot_.getTransport().flush();
713     }
714 
715     public void recv_majorCompact() throws IOError, TException
716     {
717       TMessage msg = iprot_.readMessageBegin();
718       if (msg.type == TMessageType.EXCEPTION) {
719         TApplicationException x = TApplicationException.read(iprot_);
720         iprot_.readMessageEnd();
721         throw x;
722       }
723       majorCompact_result result = new majorCompact_result();
724       result.read(iprot_);
725       iprot_.readMessageEnd();
726       if (result.io != null) {
727         throw result.io;
728       }
729       return;
730     }
731 
732     public List<byte[]> getTableNames() throws IOError, TException
733     {
734       send_getTableNames();
735       return recv_getTableNames();
736     }
737 
738     public void send_getTableNames() throws TException
739     {
740       oprot_.writeMessageBegin(new TMessage("getTableNames", TMessageType.CALL, seqid_));
741       getTableNames_args args = new getTableNames_args();
742       args.write(oprot_);
743       oprot_.writeMessageEnd();
744       oprot_.getTransport().flush();
745     }
746 
747     public List<byte[]> recv_getTableNames() throws IOError, TException
748     {
749       TMessage msg = iprot_.readMessageBegin();
750       if (msg.type == TMessageType.EXCEPTION) {
751         TApplicationException x = TApplicationException.read(iprot_);
752         iprot_.readMessageEnd();
753         throw x;
754       }
755       getTableNames_result result = new getTableNames_result();
756       result.read(iprot_);
757       iprot_.readMessageEnd();
758       if (result.isSetSuccess()) {
759         return result.success;
760       }
761       if (result.io != null) {
762         throw result.io;
763       }
764       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result");
765     }
766 
767     public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException
768     {
769       send_getColumnDescriptors(tableName);
770       return recv_getColumnDescriptors();
771     }
772 
773     public void send_getColumnDescriptors(byte[] tableName) throws TException
774     {
775       oprot_.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.CALL, seqid_));
776       getColumnDescriptors_args args = new getColumnDescriptors_args();
777       args.tableName = tableName;
778       args.write(oprot_);
779       oprot_.writeMessageEnd();
780       oprot_.getTransport().flush();
781     }
782 
783     public Map<byte[],ColumnDescriptor> recv_getColumnDescriptors() throws IOError, TException
784     {
785       TMessage msg = iprot_.readMessageBegin();
786       if (msg.type == TMessageType.EXCEPTION) {
787         TApplicationException x = TApplicationException.read(iprot_);
788         iprot_.readMessageEnd();
789         throw x;
790       }
791       getColumnDescriptors_result result = new getColumnDescriptors_result();
792       result.read(iprot_);
793       iprot_.readMessageEnd();
794       if (result.isSetSuccess()) {
795         return result.success;
796       }
797       if (result.io != null) {
798         throw result.io;
799       }
800       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result");
801     }
802 
803     public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException
804     {
805       send_getTableRegions(tableName);
806       return recv_getTableRegions();
807     }
808 
809     public void send_getTableRegions(byte[] tableName) throws TException
810     {
811       oprot_.writeMessageBegin(new TMessage("getTableRegions", TMessageType.CALL, seqid_));
812       getTableRegions_args args = new getTableRegions_args();
813       args.tableName = tableName;
814       args.write(oprot_);
815       oprot_.writeMessageEnd();
816       oprot_.getTransport().flush();
817     }
818 
819     public List<TRegionInfo> recv_getTableRegions() throws IOError, TException
820     {
821       TMessage msg = iprot_.readMessageBegin();
822       if (msg.type == TMessageType.EXCEPTION) {
823         TApplicationException x = TApplicationException.read(iprot_);
824         iprot_.readMessageEnd();
825         throw x;
826       }
827       getTableRegions_result result = new getTableRegions_result();
828       result.read(iprot_);
829       iprot_.readMessageEnd();
830       if (result.isSetSuccess()) {
831         return result.success;
832       }
833       if (result.io != null) {
834         throw result.io;
835       }
836       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result");
837     }
838 
839     public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException
840     {
841       send_createTable(tableName, columnFamilies);
842       recv_createTable();
843     }
844 
845     public void send_createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws TException
846     {
847       oprot_.writeMessageBegin(new TMessage("createTable", TMessageType.CALL, seqid_));
848       createTable_args args = new createTable_args();
849       args.tableName = tableName;
850       args.columnFamilies = columnFamilies;
851       args.write(oprot_);
852       oprot_.writeMessageEnd();
853       oprot_.getTransport().flush();
854     }
855 
856     public void recv_createTable() throws IOError, IllegalArgument, AlreadyExists, TException
857     {
858       TMessage msg = iprot_.readMessageBegin();
859       if (msg.type == TMessageType.EXCEPTION) {
860         TApplicationException x = TApplicationException.read(iprot_);
861         iprot_.readMessageEnd();
862         throw x;
863       }
864       createTable_result result = new createTable_result();
865       result.read(iprot_);
866       iprot_.readMessageEnd();
867       if (result.io != null) {
868         throw result.io;
869       }
870       if (result.ia != null) {
871         throw result.ia;
872       }
873       if (result.exist != null) {
874         throw result.exist;
875       }
876       return;
877     }
878 
879     public void deleteTable(byte[] tableName) throws IOError, TException
880     {
881       send_deleteTable(tableName);
882       recv_deleteTable();
883     }
884 
885     public void send_deleteTable(byte[] tableName) throws TException
886     {
887       oprot_.writeMessageBegin(new TMessage("deleteTable", TMessageType.CALL, seqid_));
888       deleteTable_args args = new deleteTable_args();
889       args.tableName = tableName;
890       args.write(oprot_);
891       oprot_.writeMessageEnd();
892       oprot_.getTransport().flush();
893     }
894 
895     public void recv_deleteTable() throws IOError, TException
896     {
897       TMessage msg = iprot_.readMessageBegin();
898       if (msg.type == TMessageType.EXCEPTION) {
899         TApplicationException x = TApplicationException.read(iprot_);
900         iprot_.readMessageEnd();
901         throw x;
902       }
903       deleteTable_result result = new deleteTable_result();
904       result.read(iprot_);
905       iprot_.readMessageEnd();
906       if (result.io != null) {
907         throw result.io;
908       }
909       return;
910     }
911 
912     public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
913     {
914       send_get(tableName, row, column);
915       return recv_get();
916     }
917 
918     public void send_get(byte[] tableName, byte[] row, byte[] column) throws TException
919     {
920       oprot_.writeMessageBegin(new TMessage("get", TMessageType.CALL, seqid_));
921       get_args args = new get_args();
922       args.tableName = tableName;
923       args.row = row;
924       args.column = column;
925       args.write(oprot_);
926       oprot_.writeMessageEnd();
927       oprot_.getTransport().flush();
928     }
929 
930     public List<TCell> recv_get() throws IOError, TException
931     {
932       TMessage msg = iprot_.readMessageBegin();
933       if (msg.type == TMessageType.EXCEPTION) {
934         TApplicationException x = TApplicationException.read(iprot_);
935         iprot_.readMessageEnd();
936         throw x;
937       }
938       get_result result = new get_result();
939       result.read(iprot_);
940       iprot_.readMessageEnd();
941       if (result.isSetSuccess()) {
942         return result.success;
943       }
944       if (result.io != null) {
945         throw result.io;
946       }
947       throw new TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result");
948     }
949 
950     public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException
951     {
952       send_getVer(tableName, row, column, numVersions);
953       return recv_getVer();
954     }
955 
956     public void send_getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws TException
957     {
958       oprot_.writeMessageBegin(new TMessage("getVer", TMessageType.CALL, seqid_));
959       getVer_args args = new getVer_args();
960       args.tableName = tableName;
961       args.row = row;
962       args.column = column;
963       args.numVersions = numVersions;
964       args.write(oprot_);
965       oprot_.writeMessageEnd();
966       oprot_.getTransport().flush();
967     }
968 
969     public List<TCell> recv_getVer() throws IOError, TException
970     {
971       TMessage msg = iprot_.readMessageBegin();
972       if (msg.type == TMessageType.EXCEPTION) {
973         TApplicationException x = TApplicationException.read(iprot_);
974         iprot_.readMessageEnd();
975         throw x;
976       }
977       getVer_result result = new getVer_result();
978       result.read(iprot_);
979       iprot_.readMessageEnd();
980       if (result.isSetSuccess()) {
981         return result.success;
982       }
983       if (result.io != null) {
984         throw result.io;
985       }
986       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVer failed: unknown result");
987     }
988 
989     public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException
990     {
991       send_getVerTs(tableName, row, column, timestamp, numVersions);
992       return recv_getVerTs();
993     }
994 
995     public void send_getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws TException
996     {
997       oprot_.writeMessageBegin(new TMessage("getVerTs", TMessageType.CALL, seqid_));
998       getVerTs_args args = new getVerTs_args();
999       args.tableName = tableName;
1000       args.row = row;
1001       args.column = column;
1002       args.timestamp = timestamp;
1003       args.numVersions = numVersions;
1004       args.write(oprot_);
1005       oprot_.writeMessageEnd();
1006       oprot_.getTransport().flush();
1007     }
1008 
1009     public List<TCell> recv_getVerTs() throws IOError, TException
1010     {
1011       TMessage msg = iprot_.readMessageBegin();
1012       if (msg.type == TMessageType.EXCEPTION) {
1013         TApplicationException x = TApplicationException.read(iprot_);
1014         iprot_.readMessageEnd();
1015         throw x;
1016       }
1017       getVerTs_result result = new getVerTs_result();
1018       result.read(iprot_);
1019       iprot_.readMessageEnd();
1020       if (result.isSetSuccess()) {
1021         return result.success;
1022       }
1023       if (result.io != null) {
1024         throw result.io;
1025       }
1026       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result");
1027     }
1028 
1029     public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException
1030     {
1031       send_getRow(tableName, row);
1032       return recv_getRow();
1033     }
1034 
1035     public void send_getRow(byte[] tableName, byte[] row) throws TException
1036     {
1037       oprot_.writeMessageBegin(new TMessage("getRow", TMessageType.CALL, seqid_));
1038       getRow_args args = new getRow_args();
1039       args.tableName = tableName;
1040       args.row = row;
1041       args.write(oprot_);
1042       oprot_.writeMessageEnd();
1043       oprot_.getTransport().flush();
1044     }
1045 
1046     public List<TRowResult> recv_getRow() throws IOError, TException
1047     {
1048       TMessage msg = iprot_.readMessageBegin();
1049       if (msg.type == TMessageType.EXCEPTION) {
1050         TApplicationException x = TApplicationException.read(iprot_);
1051         iprot_.readMessageEnd();
1052         throw x;
1053       }
1054       getRow_result result = new getRow_result();
1055       result.read(iprot_);
1056       iprot_.readMessageEnd();
1057       if (result.isSetSuccess()) {
1058         return result.success;
1059       }
1060       if (result.io != null) {
1061         throw result.io;
1062       }
1063       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRow failed: unknown result");
1064     }
1065 
1066     public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException
1067     {
1068       send_getRowWithColumns(tableName, row, columns);
1069       return recv_getRowWithColumns();
1070     }
1071 
1072     public void send_getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws TException
1073     {
1074       oprot_.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.CALL, seqid_));
1075       getRowWithColumns_args args = new getRowWithColumns_args();
1076       args.tableName = tableName;
1077       args.row = row;
1078       args.columns = columns;
1079       args.write(oprot_);
1080       oprot_.writeMessageEnd();
1081       oprot_.getTransport().flush();
1082     }
1083 
1084     public List<TRowResult> recv_getRowWithColumns() throws IOError, TException
1085     {
1086       TMessage msg = iprot_.readMessageBegin();
1087       if (msg.type == TMessageType.EXCEPTION) {
1088         TApplicationException x = TApplicationException.read(iprot_);
1089         iprot_.readMessageEnd();
1090         throw x;
1091       }
1092       getRowWithColumns_result result = new getRowWithColumns_result();
1093       result.read(iprot_);
1094       iprot_.readMessageEnd();
1095       if (result.isSetSuccess()) {
1096         return result.success;
1097       }
1098       if (result.io != null) {
1099         throw result.io;
1100       }
1101       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result");
1102     }
1103 
1104     public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
1105     {
1106       send_getRowTs(tableName, row, timestamp);
1107       return recv_getRowTs();
1108     }
1109 
1110     public void send_getRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
1111     {
1112       oprot_.writeMessageBegin(new TMessage("getRowTs", TMessageType.CALL, seqid_));
1113       getRowTs_args args = new getRowTs_args();
1114       args.tableName = tableName;
1115       args.row = row;
1116       args.timestamp = timestamp;
1117       args.write(oprot_);
1118       oprot_.writeMessageEnd();
1119       oprot_.getTransport().flush();
1120     }
1121 
1122     public List<TRowResult> recv_getRowTs() throws IOError, TException
1123     {
1124       TMessage msg = iprot_.readMessageBegin();
1125       if (msg.type == TMessageType.EXCEPTION) {
1126         TApplicationException x = TApplicationException.read(iprot_);
1127         iprot_.readMessageEnd();
1128         throw x;
1129       }
1130       getRowTs_result result = new getRowTs_result();
1131       result.read(iprot_);
1132       iprot_.readMessageEnd();
1133       if (result.isSetSuccess()) {
1134         return result.success;
1135       }
1136       if (result.io != null) {
1137         throw result.io;
1138       }
1139       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result");
1140     }
1141 
1142     public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException
1143     {
1144       send_getRowWithColumnsTs(tableName, row, columns, timestamp);
1145       return recv_getRowWithColumnsTs();
1146     }
1147 
1148     public void send_getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws TException
1149     {
1150       oprot_.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.CALL, seqid_));
1151       getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
1152       args.tableName = tableName;
1153       args.row = row;
1154       args.columns = columns;
1155       args.timestamp = timestamp;
1156       args.write(oprot_);
1157       oprot_.writeMessageEnd();
1158       oprot_.getTransport().flush();
1159     }
1160 
1161     public List<TRowResult> recv_getRowWithColumnsTs() throws IOError, TException
1162     {
1163       TMessage msg = iprot_.readMessageBegin();
1164       if (msg.type == TMessageType.EXCEPTION) {
1165         TApplicationException x = TApplicationException.read(iprot_);
1166         iprot_.readMessageEnd();
1167         throw x;
1168       }
1169       getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
1170       result.read(iprot_);
1171       iprot_.readMessageEnd();
1172       if (result.isSetSuccess()) {
1173         return result.success;
1174       }
1175       if (result.io != null) {
1176         throw result.io;
1177       }
1178       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
1179     }
1180 
1181     public List<TRowResult> getRows(byte[] tableName, List<byte[]> rows) throws IOError, TException
1182     {
1183       send_getRows(tableName, rows);
1184       return recv_getRows();
1185     }
1186 
1187     public void send_getRows(byte[] tableName, List<byte[]> rows) throws TException
1188     {
1189       oprot_.writeMessageBegin(new TMessage("getRows", TMessageType.CALL, seqid_));
1190       getRows_args args = new getRows_args();
1191       args.tableName = tableName;
1192       args.rows = rows;
1193       args.write(oprot_);
1194       oprot_.writeMessageEnd();
1195       oprot_.getTransport().flush();
1196     }
1197 
1198     public List<TRowResult> recv_getRows() throws IOError, TException
1199     {
1200       TMessage msg = iprot_.readMessageBegin();
1201       if (msg.type == TMessageType.EXCEPTION) {
1202         TApplicationException x = TApplicationException.read(iprot_);
1203         iprot_.readMessageEnd();
1204         throw x;
1205       }
1206       getRows_result result = new getRows_result();
1207       result.read(iprot_);
1208       iprot_.readMessageEnd();
1209       if (result.isSetSuccess()) {
1210         return result.success;
1211       }
1212       if (result.io != null) {
1213         throw result.io;
1214       }
1215       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRows failed: unknown result");
1216     }
1217 
1218     public List<TRowResult> getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns) throws IOError, TException
1219     {
1220       send_getRowsWithColumns(tableName, rows, columns);
1221       return recv_getRowsWithColumns();
1222     }
1223 
1224     public void send_getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns) throws TException
1225     {
1226       oprot_.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.CALL, seqid_));
1227       getRowsWithColumns_args args = new getRowsWithColumns_args();
1228       args.tableName = tableName;
1229       args.rows = rows;
1230       args.columns = columns;
1231       args.write(oprot_);
1232       oprot_.writeMessageEnd();
1233       oprot_.getTransport().flush();
1234     }
1235 
1236     public List<TRowResult> recv_getRowsWithColumns() throws IOError, TException
1237     {
1238       TMessage msg = iprot_.readMessageBegin();
1239       if (msg.type == TMessageType.EXCEPTION) {
1240         TApplicationException x = TApplicationException.read(iprot_);
1241         iprot_.readMessageEnd();
1242         throw x;
1243       }
1244       getRowsWithColumns_result result = new getRowsWithColumns_result();
1245       result.read(iprot_);
1246       iprot_.readMessageEnd();
1247       if (result.isSetSuccess()) {
1248         return result.success;
1249       }
1250       if (result.io != null) {
1251         throw result.io;
1252       }
1253       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumns failed: unknown result");
1254     }
1255 
1256     public List<TRowResult> getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws IOError, TException
1257     {
1258       send_getRowsTs(tableName, rows, timestamp);
1259       return recv_getRowsTs();
1260     }
1261 
1262     public void send_getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws TException
1263     {
1264       oprot_.writeMessageBegin(new TMessage("getRowsTs", TMessageType.CALL, seqid_));
1265       getRowsTs_args args = new getRowsTs_args();
1266       args.tableName = tableName;
1267       args.rows = rows;
1268       args.timestamp = timestamp;
1269       args.write(oprot_);
1270       oprot_.writeMessageEnd();
1271       oprot_.getTransport().flush();
1272     }
1273 
1274     public List<TRowResult> recv_getRowsTs() throws IOError, TException
1275     {
1276       TMessage msg = iprot_.readMessageBegin();
1277       if (msg.type == TMessageType.EXCEPTION) {
1278         TApplicationException x = TApplicationException.read(iprot_);
1279         iprot_.readMessageEnd();
1280         throw x;
1281       }
1282       getRowsTs_result result = new getRowsTs_result();
1283       result.read(iprot_);
1284       iprot_.readMessageEnd();
1285       if (result.isSetSuccess()) {
1286         return result.success;
1287       }
1288       if (result.io != null) {
1289         throw result.io;
1290       }
1291       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsTs failed: unknown result");
1292     }
1293 
1294     public List<TRowResult> getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp) throws IOError, TException
1295     {
1296       send_getRowsWithColumnsTs(tableName, rows, columns, timestamp);
1297       return recv_getRowsWithColumnsTs();
1298     }
1299 
1300     public void send_getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp) throws TException
1301     {
1302       oprot_.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.CALL, seqid_));
1303       getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args();
1304       args.tableName = tableName;
1305       args.rows = rows;
1306       args.columns = columns;
1307       args.timestamp = timestamp;
1308       args.write(oprot_);
1309       oprot_.writeMessageEnd();
1310       oprot_.getTransport().flush();
1311     }
1312 
1313     public List<TRowResult> recv_getRowsWithColumnsTs() throws IOError, TException
1314     {
1315       TMessage msg = iprot_.readMessageBegin();
1316       if (msg.type == TMessageType.EXCEPTION) {
1317         TApplicationException x = TApplicationException.read(iprot_);
1318         iprot_.readMessageEnd();
1319         throw x;
1320       }
1321       getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
1322       result.read(iprot_);
1323       iprot_.readMessageEnd();
1324       if (result.isSetSuccess()) {
1325         return result.success;
1326       }
1327       if (result.io != null) {
1328         throw result.io;
1329       }
1330       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result");
1331     }
1332 
1333     public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException
1334     {
1335       send_mutateRow(tableName, row, mutations);
1336       recv_mutateRow();
1337     }
1338 
1339     public void send_mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws TException
1340     {
1341       oprot_.writeMessageBegin(new TMessage("mutateRow", TMessageType.CALL, seqid_));
1342       mutateRow_args args = new mutateRow_args();
1343       args.tableName = tableName;
1344       args.row = row;
1345       args.mutations = mutations;
1346       args.write(oprot_);
1347       oprot_.writeMessageEnd();
1348       oprot_.getTransport().flush();
1349     }
1350 
1351     public void recv_mutateRow() throws IOError, IllegalArgument, TException
1352     {
1353       TMessage msg = iprot_.readMessageBegin();
1354       if (msg.type == TMessageType.EXCEPTION) {
1355         TApplicationException x = TApplicationException.read(iprot_);
1356         iprot_.readMessageEnd();
1357         throw x;
1358       }
1359       mutateRow_result result = new mutateRow_result();
1360       result.read(iprot_);
1361       iprot_.readMessageEnd();
1362       if (result.io != null) {
1363         throw result.io;
1364       }
1365       if (result.ia != null) {
1366         throw result.ia;
1367       }
1368       return;
1369     }
1370 
1371     public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException
1372     {
1373       send_mutateRowTs(tableName, row, mutations, timestamp);
1374       recv_mutateRowTs();
1375     }
1376 
1377     public void send_mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws TException
1378     {
1379       oprot_.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.CALL, seqid_));
1380       mutateRowTs_args args = new mutateRowTs_args();
1381       args.tableName = tableName;
1382       args.row = row;
1383       args.mutations = mutations;
1384       args.timestamp = timestamp;
1385       args.write(oprot_);
1386       oprot_.writeMessageEnd();
1387       oprot_.getTransport().flush();
1388     }
1389 
1390     public void recv_mutateRowTs() throws IOError, IllegalArgument, TException
1391     {
1392       TMessage msg = iprot_.readMessageBegin();
1393       if (msg.type == TMessageType.EXCEPTION) {
1394         TApplicationException x = TApplicationException.read(iprot_);
1395         iprot_.readMessageEnd();
1396         throw x;
1397       }
1398       mutateRowTs_result result = new mutateRowTs_result();
1399       result.read(iprot_);
1400       iprot_.readMessageEnd();
1401       if (result.io != null) {
1402         throw result.io;
1403       }
1404       if (result.ia != null) {
1405         throw result.ia;
1406       }
1407       return;
1408     }
1409 
1410     public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException
1411     {
1412       send_mutateRows(tableName, rowBatches);
1413       recv_mutateRows();
1414     }
1415 
1416     public void send_mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws TException
1417     {
1418       oprot_.writeMessageBegin(new TMessage("mutateRows", TMessageType.CALL, seqid_));
1419       mutateRows_args args = new mutateRows_args();
1420       args.tableName = tableName;
1421       args.rowBatches = rowBatches;
1422       args.write(oprot_);
1423       oprot_.writeMessageEnd();
1424       oprot_.getTransport().flush();
1425     }
1426 
1427     public void recv_mutateRows() throws IOError, IllegalArgument, TException
1428     {
1429       TMessage msg = iprot_.readMessageBegin();
1430       if (msg.type == TMessageType.EXCEPTION) {
1431         TApplicationException x = TApplicationException.read(iprot_);
1432         iprot_.readMessageEnd();
1433         throw x;
1434       }
1435       mutateRows_result result = new mutateRows_result();
1436       result.read(iprot_);
1437       iprot_.readMessageEnd();
1438       if (result.io != null) {
1439         throw result.io;
1440       }
1441       if (result.ia != null) {
1442         throw result.ia;
1443       }
1444       return;
1445     }
1446 
1447     public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException
1448     {
1449       send_mutateRowsTs(tableName, rowBatches, timestamp);
1450       recv_mutateRowsTs();
1451     }
1452 
1453     public void send_mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws TException
1454     {
1455       oprot_.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.CALL, seqid_));
1456       mutateRowsTs_args args = new mutateRowsTs_args();
1457       args.tableName = tableName;
1458       args.rowBatches = rowBatches;
1459       args.timestamp = timestamp;
1460       args.write(oprot_);
1461       oprot_.writeMessageEnd();
1462       oprot_.getTransport().flush();
1463     }
1464 
1465     public void recv_mutateRowsTs() throws IOError, IllegalArgument, TException
1466     {
1467       TMessage msg = iprot_.readMessageBegin();
1468       if (msg.type == TMessageType.EXCEPTION) {
1469         TApplicationException x = TApplicationException.read(iprot_);
1470         iprot_.readMessageEnd();
1471         throw x;
1472       }
1473       mutateRowsTs_result result = new mutateRowsTs_result();
1474       result.read(iprot_);
1475       iprot_.readMessageEnd();
1476       if (result.io != null) {
1477         throw result.io;
1478       }
1479       if (result.ia != null) {
1480         throw result.ia;
1481       }
1482       return;
1483     }
1484 
1485     public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException
1486     {
1487       send_atomicIncrement(tableName, row, column, value);
1488       return recv_atomicIncrement();
1489     }
1490 
1491     public void send_atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws TException
1492     {
1493       oprot_.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.CALL, seqid_));
1494       atomicIncrement_args args = new atomicIncrement_args();
1495       args.tableName = tableName;
1496       args.row = row;
1497       args.column = column;
1498       args.value = value;
1499       args.write(oprot_);
1500       oprot_.writeMessageEnd();
1501       oprot_.getTransport().flush();
1502     }
1503 
1504     public long recv_atomicIncrement() throws IOError, IllegalArgument, TException
1505     {
1506       TMessage msg = iprot_.readMessageBegin();
1507       if (msg.type == TMessageType.EXCEPTION) {
1508         TApplicationException x = TApplicationException.read(iprot_);
1509         iprot_.readMessageEnd();
1510         throw x;
1511       }
1512       atomicIncrement_result result = new atomicIncrement_result();
1513       result.read(iprot_);
1514       iprot_.readMessageEnd();
1515       if (result.isSetSuccess()) {
1516         return result.success;
1517       }
1518       if (result.io != null) {
1519         throw result.io;
1520       }
1521       if (result.ia != null) {
1522         throw result.ia;
1523       }
1524       throw new TApplicationException(TApplicationException.MISSING_RESULT, "atomicIncrement failed: unknown result");
1525     }
1526 
1527     public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
1528     {
1529       send_deleteAll(tableName, row, column);
1530       recv_deleteAll();
1531     }
1532 
1533     public void send_deleteAll(byte[] tableName, byte[] row, byte[] column) throws TException
1534     {
1535       oprot_.writeMessageBegin(new TMessage("deleteAll", TMessageType.CALL, seqid_));
1536       deleteAll_args args = new deleteAll_args();
1537       args.tableName = tableName;
1538       args.row = row;
1539       args.column = column;
1540       args.write(oprot_);
1541       oprot_.writeMessageEnd();
1542       oprot_.getTransport().flush();
1543     }
1544 
1545     public void recv_deleteAll() throws IOError, TException
1546     {
1547       TMessage msg = iprot_.readMessageBegin();
1548       if (msg.type == TMessageType.EXCEPTION) {
1549         TApplicationException x = TApplicationException.read(iprot_);
1550         iprot_.readMessageEnd();
1551         throw x;
1552       }
1553       deleteAll_result result = new deleteAll_result();
1554       result.read(iprot_);
1555       iprot_.readMessageEnd();
1556       if (result.io != null) {
1557         throw result.io;
1558       }
1559       return;
1560     }
1561 
1562     public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException
1563     {
1564       send_deleteAllTs(tableName, row, column, timestamp);
1565       recv_deleteAllTs();
1566     }
1567 
1568     public void send_deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws TException
1569     {
1570       oprot_.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.CALL, seqid_));
1571       deleteAllTs_args args = new deleteAllTs_args();
1572       args.tableName = tableName;
1573       args.row = row;
1574       args.column = column;
1575       args.timestamp = timestamp;
1576       args.write(oprot_);
1577       oprot_.writeMessageEnd();
1578       oprot_.getTransport().flush();
1579     }
1580 
1581     public void recv_deleteAllTs() throws IOError, TException
1582     {
1583       TMessage msg = iprot_.readMessageBegin();
1584       if (msg.type == TMessageType.EXCEPTION) {
1585         TApplicationException x = TApplicationException.read(iprot_);
1586         iprot_.readMessageEnd();
1587         throw x;
1588       }
1589       deleteAllTs_result result = new deleteAllTs_result();
1590       result.read(iprot_);
1591       iprot_.readMessageEnd();
1592       if (result.io != null) {
1593         throw result.io;
1594       }
1595       return;
1596     }
1597 
1598     public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException
1599     {
1600       send_deleteAllRow(tableName, row);
1601       recv_deleteAllRow();
1602     }
1603 
1604     public void send_deleteAllRow(byte[] tableName, byte[] row) throws TException
1605     {
1606       oprot_.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.CALL, seqid_));
1607       deleteAllRow_args args = new deleteAllRow_args();
1608       args.tableName = tableName;
1609       args.row = row;
1610       args.write(oprot_);
1611       oprot_.writeMessageEnd();
1612       oprot_.getTransport().flush();
1613     }
1614 
1615     public void recv_deleteAllRow() throws IOError, TException
1616     {
1617       TMessage msg = iprot_.readMessageBegin();
1618       if (msg.type == TMessageType.EXCEPTION) {
1619         TApplicationException x = TApplicationException.read(iprot_);
1620         iprot_.readMessageEnd();
1621         throw x;
1622       }
1623       deleteAllRow_result result = new deleteAllRow_result();
1624       result.read(iprot_);
1625       iprot_.readMessageEnd();
1626       if (result.io != null) {
1627         throw result.io;
1628       }
1629       return;
1630     }
1631 
1632     public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
1633     {
1634       send_deleteAllRowTs(tableName, row, timestamp);
1635       recv_deleteAllRowTs();
1636     }
1637 
1638     public void send_deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
1639     {
1640       oprot_.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.CALL, seqid_));
1641       deleteAllRowTs_args args = new deleteAllRowTs_args();
1642       args.tableName = tableName;
1643       args.row = row;
1644       args.timestamp = timestamp;
1645       args.write(oprot_);
1646       oprot_.writeMessageEnd();
1647       oprot_.getTransport().flush();
1648     }
1649 
1650     public void recv_deleteAllRowTs() throws IOError, TException
1651     {
1652       TMessage msg = iprot_.readMessageBegin();
1653       if (msg.type == TMessageType.EXCEPTION) {
1654         TApplicationException x = TApplicationException.read(iprot_);
1655         iprot_.readMessageEnd();
1656         throw x;
1657       }
1658       deleteAllRowTs_result result = new deleteAllRowTs_result();
1659       result.read(iprot_);
1660       iprot_.readMessageEnd();
1661       if (result.io != null) {
1662         throw result.io;
1663       }
1664       return;
1665     }
1666 
1667     public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException
1668     {
1669       send_scannerOpen(tableName, startRow, columns);
1670       return recv_scannerOpen();
1671     }
1672 
1673     public void send_scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws TException
1674     {
1675       oprot_.writeMessageBegin(new TMessage("scannerOpen", TMessageType.CALL, seqid_));
1676       scannerOpen_args args = new scannerOpen_args();
1677       args.tableName = tableName;
1678       args.startRow = startRow;
1679       args.columns = columns;
1680       args.write(oprot_);
1681       oprot_.writeMessageEnd();
1682       oprot_.getTransport().flush();
1683     }
1684 
1685     public int recv_scannerOpen() throws IOError, TException
1686     {
1687       TMessage msg = iprot_.readMessageBegin();
1688       if (msg.type == TMessageType.EXCEPTION) {
1689         TApplicationException x = TApplicationException.read(iprot_);
1690         iprot_.readMessageEnd();
1691         throw x;
1692       }
1693       scannerOpen_result result = new scannerOpen_result();
1694       result.read(iprot_);
1695       iprot_.readMessageEnd();
1696       if (result.isSetSuccess()) {
1697         return result.success;
1698       }
1699       if (result.io != null) {
1700         throw result.io;
1701       }
1702       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result");
1703     }
1704 
1705     public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException
1706     {
1707       send_scannerOpenWithStop(tableName, startRow, stopRow, columns);
1708       return recv_scannerOpenWithStop();
1709     }
1710 
1711     public void send_scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws TException
1712     {
1713       oprot_.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.CALL, seqid_));
1714       scannerOpenWithStop_args args = new scannerOpenWithStop_args();
1715       args.tableName = tableName;
1716       args.startRow = startRow;
1717       args.stopRow = stopRow;
1718       args.columns = columns;
1719       args.write(oprot_);
1720       oprot_.writeMessageEnd();
1721       oprot_.getTransport().flush();
1722     }
1723 
1724     public int recv_scannerOpenWithStop() throws IOError, TException
1725     {
1726       TMessage msg = iprot_.readMessageBegin();
1727       if (msg.type == TMessageType.EXCEPTION) {
1728         TApplicationException x = TApplicationException.read(iprot_);
1729         iprot_.readMessageEnd();
1730         throw x;
1731       }
1732       scannerOpenWithStop_result result = new scannerOpenWithStop_result();
1733       result.read(iprot_);
1734       iprot_.readMessageEnd();
1735       if (result.isSetSuccess()) {
1736         return result.success;
1737       }
1738       if (result.io != null) {
1739         throw result.io;
1740       }
1741       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
1742     }
1743 
1744     public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException
1745     {
1746       send_scannerOpenWithPrefix(tableName, startAndPrefix, columns);
1747       return recv_scannerOpenWithPrefix();
1748     }
1749 
1750     public void send_scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws TException
1751     {
1752       oprot_.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.CALL, seqid_));
1753       scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
1754       args.tableName = tableName;
1755       args.startAndPrefix = startAndPrefix;
1756       args.columns = columns;
1757       args.write(oprot_);
1758       oprot_.writeMessageEnd();
1759       oprot_.getTransport().flush();
1760     }
1761 
1762     public int recv_scannerOpenWithPrefix() throws IOError, TException
1763     {
1764       TMessage msg = iprot_.readMessageBegin();
1765       if (msg.type == TMessageType.EXCEPTION) {
1766         TApplicationException x = TApplicationException.read(iprot_);
1767         iprot_.readMessageEnd();
1768         throw x;
1769       }
1770       scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
1771       result.read(iprot_);
1772       iprot_.readMessageEnd();
1773       if (result.isSetSuccess()) {
1774         return result.success;
1775       }
1776       if (result.io != null) {
1777         throw result.io;
1778       }
1779       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
1780     }
1781 
1782     public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException
1783     {
1784       send_scannerOpenTs(tableName, startRow, columns, timestamp);
1785       return recv_scannerOpenTs();
1786     }
1787 
1788     public void send_scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws TException
1789     {
1790       oprot_.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.CALL, seqid_));
1791       scannerOpenTs_args args = new scannerOpenTs_args();
1792       args.tableName = tableName;
1793       args.startRow = startRow;
1794       args.columns = columns;
1795       args.timestamp = timestamp;
1796       args.write(oprot_);
1797       oprot_.writeMessageEnd();
1798       oprot_.getTransport().flush();
1799     }
1800 
1801     public int recv_scannerOpenTs() throws IOError, TException
1802     {
1803       TMessage msg = iprot_.readMessageBegin();
1804       if (msg.type == TMessageType.EXCEPTION) {
1805         TApplicationException x = TApplicationException.read(iprot_);
1806         iprot_.readMessageEnd();
1807         throw x;
1808       }
1809       scannerOpenTs_result result = new scannerOpenTs_result();
1810       result.read(iprot_);
1811       iprot_.readMessageEnd();
1812       if (result.isSetSuccess()) {
1813         return result.success;
1814       }
1815       if (result.io != null) {
1816         throw result.io;
1817       }
1818       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result");
1819     }
1820 
1821     public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException
1822     {
1823       send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
1824       return recv_scannerOpenWithStopTs();
1825     }
1826 
1827     public void send_scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws TException
1828     {
1829       oprot_.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.CALL, seqid_));
1830       scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
1831       args.tableName = tableName;
1832       args.startRow = startRow;
1833       args.stopRow = stopRow;
1834       args.columns = columns;
1835       args.timestamp = timestamp;
1836       args.write(oprot_);
1837       oprot_.writeMessageEnd();
1838       oprot_.getTransport().flush();
1839     }
1840 
1841     public int recv_scannerOpenWithStopTs() throws IOError, TException
1842     {
1843       TMessage msg = iprot_.readMessageBegin();
1844       if (msg.type == TMessageType.EXCEPTION) {
1845         TApplicationException x = TApplicationException.read(iprot_);
1846         iprot_.readMessageEnd();
1847         throw x;
1848       }
1849       scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
1850       result.read(iprot_);
1851       iprot_.readMessageEnd();
1852       if (result.isSetSuccess()) {
1853         return result.success;
1854       }
1855       if (result.io != null) {
1856         throw result.io;
1857       }
1858       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
1859     }
1860 
1861     public List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, TException
1862     {
1863       send_scannerGet(id);
1864       return recv_scannerGet();
1865     }
1866 
1867     public void send_scannerGet(int id) throws TException
1868     {
1869       oprot_.writeMessageBegin(new TMessage("scannerGet", TMessageType.CALL, seqid_));
1870       scannerGet_args args = new scannerGet_args();
1871       args.id = id;
1872       args.write(oprot_);
1873       oprot_.writeMessageEnd();
1874       oprot_.getTransport().flush();
1875     }
1876 
1877     public List<TRowResult> recv_scannerGet() throws IOError, IllegalArgument, TException
1878     {
1879       TMessage msg = iprot_.readMessageBegin();
1880       if (msg.type == TMessageType.EXCEPTION) {
1881         TApplicationException x = TApplicationException.read(iprot_);
1882         iprot_.readMessageEnd();
1883         throw x;
1884       }
1885       scannerGet_result result = new scannerGet_result();
1886       result.read(iprot_);
1887       iprot_.readMessageEnd();
1888       if (result.isSetSuccess()) {
1889         return result.success;
1890       }
1891       if (result.io != null) {
1892         throw result.io;
1893       }
1894       if (result.ia != null) {
1895         throw result.ia;
1896       }
1897       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGet failed: unknown result");
1898     }
1899 
1900     public List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException
1901     {
1902       send_scannerGetList(id, nbRows);
1903       return recv_scannerGetList();
1904     }
1905 
1906     public void send_scannerGetList(int id, int nbRows) throws TException
1907     {
1908       oprot_.writeMessageBegin(new TMessage("scannerGetList", TMessageType.CALL, seqid_));
1909       scannerGetList_args args = new scannerGetList_args();
1910       args.id = id;
1911       args.nbRows = nbRows;
1912       args.write(oprot_);
1913       oprot_.writeMessageEnd();
1914       oprot_.getTransport().flush();
1915     }
1916 
1917     public List<TRowResult> recv_scannerGetList() throws IOError, IllegalArgument, TException
1918     {
1919       TMessage msg = iprot_.readMessageBegin();
1920       if (msg.type == TMessageType.EXCEPTION) {
1921         TApplicationException x = TApplicationException.read(iprot_);
1922         iprot_.readMessageEnd();
1923         throw x;
1924       }
1925       scannerGetList_result result = new scannerGetList_result();
1926       result.read(iprot_);
1927       iprot_.readMessageEnd();
1928       if (result.isSetSuccess()) {
1929         return result.success;
1930       }
1931       if (result.io != null) {
1932         throw result.io;
1933       }
1934       if (result.ia != null) {
1935         throw result.ia;
1936       }
1937       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGetList failed: unknown result");
1938     }
1939 
1940     public void scannerClose(int id) throws IOError, IllegalArgument, TException
1941     {
1942       send_scannerClose(id);
1943       recv_scannerClose();
1944     }
1945 
1946     public void send_scannerClose(int id) throws TException
1947     {
1948       oprot_.writeMessageBegin(new TMessage("scannerClose", TMessageType.CALL, seqid_));
1949       scannerClose_args args = new scannerClose_args();
1950       args.id = id;
1951       args.write(oprot_);
1952       oprot_.writeMessageEnd();
1953       oprot_.getTransport().flush();
1954     }
1955 
1956     public void recv_scannerClose() throws IOError, IllegalArgument, TException
1957     {
1958       TMessage msg = iprot_.readMessageBegin();
1959       if (msg.type == TMessageType.EXCEPTION) {
1960         TApplicationException x = TApplicationException.read(iprot_);
1961         iprot_.readMessageEnd();
1962         throw x;
1963       }
1964       scannerClose_result result = new scannerClose_result();
1965       result.read(iprot_);
1966       iprot_.readMessageEnd();
1967       if (result.io != null) {
1968         throw result.io;
1969       }
1970       if (result.ia != null) {
1971         throw result.ia;
1972       }
1973       return;
1974     }
1975 
1976   }
1977   public static class Processor implements TProcessor {
1978     private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1979     public Processor(Iface iface)
1980     {
1981       iface_ = iface;
1982       processMap_.put("enableTable", new enableTable());
1983       processMap_.put("disableTable", new disableTable());
1984       processMap_.put("isTableEnabled", new isTableEnabled());
1985       processMap_.put("compact", new compact());
1986       processMap_.put("majorCompact", new majorCompact());
1987       processMap_.put("getTableNames", new getTableNames());
1988       processMap_.put("getColumnDescriptors", new getColumnDescriptors());
1989       processMap_.put("getTableRegions", new getTableRegions());
1990       processMap_.put("createTable", new createTable());
1991       processMap_.put("deleteTable", new deleteTable());
1992       processMap_.put("get", new get());
1993       processMap_.put("getVer", new getVer());
1994       processMap_.put("getVerTs", new getVerTs());
1995       processMap_.put("getRow", new getRow());
1996       processMap_.put("getRowWithColumns", new getRowWithColumns());
1997       processMap_.put("getRowTs", new getRowTs());
1998       processMap_.put("getRowWithColumnsTs", new getRowWithColumnsTs());
1999       processMap_.put("getRows", new getRows());
2000       processMap_.put("getRowsWithColumns", new getRowsWithColumns());
2001       processMap_.put("getRowsTs", new getRowsTs());
2002       processMap_.put("getRowsWithColumnsTs", new getRowsWithColumnsTs());
2003       processMap_.put("mutateRow", new mutateRow());
2004       processMap_.put("mutateRowTs", new mutateRowTs());
2005       processMap_.put("mutateRows", new mutateRows());
2006       processMap_.put("mutateRowsTs", new mutateRowsTs());
2007       processMap_.put("atomicIncrement", new atomicIncrement());
2008       processMap_.put("deleteAll", new deleteAll());
2009       processMap_.put("deleteAllTs", new deleteAllTs());
2010       processMap_.put("deleteAllRow", new deleteAllRow());
2011       processMap_.put("deleteAllRowTs", new deleteAllRowTs());
2012       processMap_.put("scannerOpen", new scannerOpen());
2013       processMap_.put("scannerOpenWithStop", new scannerOpenWithStop());
2014       processMap_.put("scannerOpenWithPrefix", new scannerOpenWithPrefix());
2015       processMap_.put("scannerOpenTs", new scannerOpenTs());
2016       processMap_.put("scannerOpenWithStopTs", new scannerOpenWithStopTs());
2017       processMap_.put("scannerGet", new scannerGet());
2018       processMap_.put("scannerGetList", new scannerGetList());
2019       processMap_.put("scannerClose", new scannerClose());
2020     }
2021 
2022     protected static interface ProcessFunction {
2023       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException;
2024     }
2025 
2026     private Iface iface_;
2027     protected final HashMap<String,ProcessFunction> processMap_ = new HashMap<String,ProcessFunction>();
2028 
2029     public boolean process(TProtocol iprot, TProtocol oprot) throws TException
2030     {
2031       TMessage msg = iprot.readMessageBegin();
2032       ProcessFunction fn = processMap_.get(msg.name);
2033       if (fn == null) {
2034         TProtocolUtil.skip(iprot, TType.STRUCT);
2035         iprot.readMessageEnd();
2036         TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'");
2037         oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));
2038         x.write(oprot);
2039         oprot.writeMessageEnd();
2040         oprot.getTransport().flush();
2041         return true;
2042       }
2043       fn.process(msg.seqid, iprot, oprot);
2044       return true;
2045     }
2046 
2047     private class enableTable implements ProcessFunction {
2048       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2049       {
2050         enableTable_args args = new enableTable_args();
2051         args.read(iprot);
2052         iprot.readMessageEnd();
2053         enableTable_result result = new enableTable_result();
2054         try {
2055           iface_.enableTable(args.tableName);
2056         } catch (IOError io) {
2057           result.io = io;
2058         } catch (Throwable th) {
2059           LOGGER.error("Internal error processing enableTable", th);
2060           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing enableTable");
2061           oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.EXCEPTION, seqid));
2062           x.write(oprot);
2063           oprot.writeMessageEnd();
2064           oprot.getTransport().flush();
2065           return;
2066         }
2067         oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.REPLY, seqid));
2068         result.write(oprot);
2069         oprot.writeMessageEnd();
2070         oprot.getTransport().flush();
2071       }
2072 
2073     }
2074 
2075     private class disableTable implements ProcessFunction {
2076       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2077       {
2078         disableTable_args args = new disableTable_args();
2079         args.read(iprot);
2080         iprot.readMessageEnd();
2081         disableTable_result result = new disableTable_result();
2082         try {
2083           iface_.disableTable(args.tableName);
2084         } catch (IOError io) {
2085           result.io = io;
2086         } catch (Throwable th) {
2087           LOGGER.error("Internal error processing disableTable", th);
2088           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing disableTable");
2089           oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.EXCEPTION, seqid));
2090           x.write(oprot);
2091           oprot.writeMessageEnd();
2092           oprot.getTransport().flush();
2093           return;
2094         }
2095         oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.REPLY, seqid));
2096         result.write(oprot);
2097         oprot.writeMessageEnd();
2098         oprot.getTransport().flush();
2099       }
2100 
2101     }
2102 
2103     private class isTableEnabled implements ProcessFunction {
2104       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2105       {
2106         isTableEnabled_args args = new isTableEnabled_args();
2107         args.read(iprot);
2108         iprot.readMessageEnd();
2109         isTableEnabled_result result = new isTableEnabled_result();
2110         try {
2111           result.success = iface_.isTableEnabled(args.tableName);
2112           result.setSuccessIsSet(true);
2113         } catch (IOError io) {
2114           result.io = io;
2115         } catch (Throwable th) {
2116           LOGGER.error("Internal error processing isTableEnabled", th);
2117           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing isTableEnabled");
2118           oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.EXCEPTION, seqid));
2119           x.write(oprot);
2120           oprot.writeMessageEnd();
2121           oprot.getTransport().flush();
2122           return;
2123         }
2124         oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.REPLY, seqid));
2125         result.write(oprot);
2126         oprot.writeMessageEnd();
2127         oprot.getTransport().flush();
2128       }
2129 
2130     }
2131 
2132     private class compact implements ProcessFunction {
2133       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2134       {
2135         compact_args args = new compact_args();
2136         args.read(iprot);
2137         iprot.readMessageEnd();
2138         compact_result result = new compact_result();
2139         try {
2140           iface_.compact(args.tableNameOrRegionName);
2141         } catch (IOError io) {
2142           result.io = io;
2143         } catch (Throwable th) {
2144           LOGGER.error("Internal error processing compact", th);
2145           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing compact");
2146           oprot.writeMessageBegin(new TMessage("compact", TMessageType.EXCEPTION, seqid));
2147           x.write(oprot);
2148           oprot.writeMessageEnd();
2149           oprot.getTransport().flush();
2150           return;
2151         }
2152         oprot.writeMessageBegin(new TMessage("compact", TMessageType.REPLY, seqid));
2153         result.write(oprot);
2154         oprot.writeMessageEnd();
2155         oprot.getTransport().flush();
2156       }
2157 
2158     }
2159 
2160     private class majorCompact implements ProcessFunction {
2161       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2162       {
2163         majorCompact_args args = new majorCompact_args();
2164         args.read(iprot);
2165         iprot.readMessageEnd();
2166         majorCompact_result result = new majorCompact_result();
2167         try {
2168           iface_.majorCompact(args.tableNameOrRegionName);
2169         } catch (IOError io) {
2170           result.io = io;
2171         } catch (Throwable th) {
2172           LOGGER.error("Internal error processing majorCompact", th);
2173           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing majorCompact");
2174           oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.EXCEPTION, seqid));
2175           x.write(oprot);
2176           oprot.writeMessageEnd();
2177           oprot.getTransport().flush();
2178           return;
2179         }
2180         oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.REPLY, seqid));
2181         result.write(oprot);
2182         oprot.writeMessageEnd();
2183         oprot.getTransport().flush();
2184       }
2185 
2186     }
2187 
2188     private class getTableNames implements ProcessFunction {
2189       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2190       {
2191         getTableNames_args args = new getTableNames_args();
2192         args.read(iprot);
2193         iprot.readMessageEnd();
2194         getTableNames_result result = new getTableNames_result();
2195         try {
2196           result.success = iface_.getTableNames();
2197         } catch (IOError io) {
2198           result.io = io;
2199         } catch (Throwable th) {
2200           LOGGER.error("Internal error processing getTableNames", th);
2201           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableNames");
2202           oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.EXCEPTION, seqid));
2203           x.write(oprot);
2204           oprot.writeMessageEnd();
2205           oprot.getTransport().flush();
2206           return;
2207         }
2208         oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.REPLY, seqid));
2209         result.write(oprot);
2210         oprot.writeMessageEnd();
2211         oprot.getTransport().flush();
2212       }
2213 
2214     }
2215 
2216     private class getColumnDescriptors implements ProcessFunction {
2217       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2218       {
2219         getColumnDescriptors_args args = new getColumnDescriptors_args();
2220         args.read(iprot);
2221         iprot.readMessageEnd();
2222         getColumnDescriptors_result result = new getColumnDescriptors_result();
2223         try {
2224           result.success = iface_.getColumnDescriptors(args.tableName);
2225         } catch (IOError io) {
2226           result.io = io;
2227         } catch (Throwable th) {
2228           LOGGER.error("Internal error processing getColumnDescriptors", th);
2229           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getColumnDescriptors");
2230           oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.EXCEPTION, seqid));
2231           x.write(oprot);
2232           oprot.writeMessageEnd();
2233           oprot.getTransport().flush();
2234           return;
2235         }
2236         oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.REPLY, seqid));
2237         result.write(oprot);
2238         oprot.writeMessageEnd();
2239         oprot.getTransport().flush();
2240       }
2241 
2242     }
2243 
2244     private class getTableRegions implements ProcessFunction {
2245       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2246       {
2247         getTableRegions_args args = new getTableRegions_args();
2248         args.read(iprot);
2249         iprot.readMessageEnd();
2250         getTableRegions_result result = new getTableRegions_result();
2251         try {
2252           result.success = iface_.getTableRegions(args.tableName);
2253         } catch (IOError io) {
2254           result.io = io;
2255         } catch (Throwable th) {
2256           LOGGER.error("Internal error processing getTableRegions", th);
2257           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableRegions");
2258           oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.EXCEPTION, seqid));
2259           x.write(oprot);
2260           oprot.writeMessageEnd();
2261           oprot.getTransport().flush();
2262           return;
2263         }
2264         oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.REPLY, seqid));
2265         result.write(oprot);
2266         oprot.writeMessageEnd();
2267         oprot.getTransport().flush();
2268       }
2269 
2270     }
2271 
2272     private class createTable implements ProcessFunction {
2273       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2274       {
2275         createTable_args args = new createTable_args();
2276         args.read(iprot);
2277         iprot.readMessageEnd();
2278         createTable_result result = new createTable_result();
2279         try {
2280           iface_.createTable(args.tableName, args.columnFamilies);
2281         } catch (IOError io) {
2282           result.io = io;
2283         } catch (IllegalArgument ia) {
2284           result.ia = ia;
2285         } catch (AlreadyExists exist) {
2286           result.exist = exist;
2287         } catch (Throwable th) {
2288           LOGGER.error("Internal error processing createTable", th);
2289           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing createTable");
2290           oprot.writeMessageBegin(new TMessage("createTable", TMessageType.EXCEPTION, seqid));
2291           x.write(oprot);
2292           oprot.writeMessageEnd();
2293           oprot.getTransport().flush();
2294           return;
2295         }
2296         oprot.writeMessageBegin(new TMessage("createTable", TMessageType.REPLY, seqid));
2297         result.write(oprot);
2298         oprot.writeMessageEnd();
2299         oprot.getTransport().flush();
2300       }
2301 
2302     }
2303 
2304     private class deleteTable implements ProcessFunction {
2305       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2306       {
2307         deleteTable_args args = new deleteTable_args();
2308         args.read(iprot);
2309         iprot.readMessageEnd();
2310         deleteTable_result result = new deleteTable_result();
2311         try {
2312           iface_.deleteTable(args.tableName);
2313         } catch (IOError io) {
2314           result.io = io;
2315         } catch (Throwable th) {
2316           LOGGER.error("Internal error processing deleteTable", th);
2317           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteTable");
2318           oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.EXCEPTION, seqid));
2319           x.write(oprot);
2320           oprot.writeMessageEnd();
2321           oprot.getTransport().flush();
2322           return;
2323         }
2324         oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.REPLY, seqid));
2325         result.write(oprot);
2326         oprot.writeMessageEnd();
2327         oprot.getTransport().flush();
2328       }
2329 
2330     }
2331 
2332     private class get implements ProcessFunction {
2333       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2334       {
2335         get_args args = new get_args();
2336         args.read(iprot);
2337         iprot.readMessageEnd();
2338         get_result result = new get_result();
2339         try {
2340           result.success = iface_.get(args.tableName, args.row, args.column);
2341         } catch (IOError io) {
2342           result.io = io;
2343         } catch (Throwable th) {
2344           LOGGER.error("Internal error processing get", th);
2345           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing get");
2346           oprot.writeMessageBegin(new TMessage("get", TMessageType.EXCEPTION, seqid));
2347           x.write(oprot);
2348           oprot.writeMessageEnd();
2349           oprot.getTransport().flush();
2350           return;
2351         }
2352         oprot.writeMessageBegin(new TMessage("get", TMessageType.REPLY, seqid));
2353         result.write(oprot);
2354         oprot.writeMessageEnd();
2355         oprot.getTransport().flush();
2356       }
2357 
2358     }
2359 
2360     private class getVer implements ProcessFunction {
2361       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2362       {
2363         getVer_args args = new getVer_args();
2364         args.read(iprot);
2365         iprot.readMessageEnd();
2366         getVer_result result = new getVer_result();
2367         try {
2368           result.success = iface_.getVer(args.tableName, args.row, args.column, args.numVersions);
2369         } catch (IOError io) {
2370           result.io = io;
2371         } catch (Throwable th) {
2372           LOGGER.error("Internal error processing getVer", th);
2373           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVer");
2374           oprot.writeMessageBegin(new TMessage("getVer", TMessageType.EXCEPTION, seqid));
2375           x.write(oprot);
2376           oprot.writeMessageEnd();
2377           oprot.getTransport().flush();
2378           return;
2379         }
2380         oprot.writeMessageBegin(new TMessage("getVer", TMessageType.REPLY, seqid));
2381         result.write(oprot);
2382         oprot.writeMessageEnd();
2383         oprot.getTransport().flush();
2384       }
2385 
2386     }
2387 
2388     private class getVerTs implements ProcessFunction {
2389       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2390       {
2391         getVerTs_args args = new getVerTs_args();
2392         args.read(iprot);
2393         iprot.readMessageEnd();
2394         getVerTs_result result = new getVerTs_result();
2395         try {
2396           result.success = iface_.getVerTs(args.tableName, args.row, args.column, args.timestamp, args.numVersions);
2397         } catch (IOError io) {
2398           result.io = io;
2399         } catch (Throwable th) {
2400           LOGGER.error("Internal error processing getVerTs", th);
2401           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVerTs");
2402           oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.EXCEPTION, seqid));
2403           x.write(oprot);
2404           oprot.writeMessageEnd();
2405           oprot.getTransport().flush();
2406           return;
2407         }
2408         oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.REPLY, seqid));
2409         result.write(oprot);
2410         oprot.writeMessageEnd();
2411         oprot.getTransport().flush();
2412       }
2413 
2414     }
2415 
2416     private class getRow implements ProcessFunction {
2417       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2418       {
2419         getRow_args args = new getRow_args();
2420         args.read(iprot);
2421         iprot.readMessageEnd();
2422         getRow_result result = new getRow_result();
2423         try {
2424           result.success = iface_.getRow(args.tableName, args.row);
2425         } catch (IOError io) {
2426           result.io = io;
2427         } catch (Throwable th) {
2428           LOGGER.error("Internal error processing getRow", th);
2429           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRow");
2430           oprot.writeMessageBegin(new TMessage("getRow", TMessageType.EXCEPTION, seqid));
2431           x.write(oprot);
2432           oprot.writeMessageEnd();
2433           oprot.getTransport().flush();
2434           return;
2435         }
2436         oprot.writeMessageBegin(new TMessage("getRow", TMessageType.REPLY, seqid));
2437         result.write(oprot);
2438         oprot.writeMessageEnd();
2439         oprot.getTransport().flush();
2440       }
2441 
2442     }
2443 
2444     private class getRowWithColumns implements ProcessFunction {
2445       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2446       {
2447         getRowWithColumns_args args = new getRowWithColumns_args();
2448         args.read(iprot);
2449         iprot.readMessageEnd();
2450         getRowWithColumns_result result = new getRowWithColumns_result();
2451         try {
2452           result.success = iface_.getRowWithColumns(args.tableName, args.row, args.columns);
2453         } catch (IOError io) {
2454           result.io = io;
2455         } catch (Throwable th) {
2456           LOGGER.error("Internal error processing getRowWithColumns", th);
2457           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumns");
2458           oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.EXCEPTION, seqid));
2459           x.write(oprot);
2460           oprot.writeMessageEnd();
2461           oprot.getTransport().flush();
2462           return;
2463         }
2464         oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.REPLY, seqid));
2465         result.write(oprot);
2466         oprot.writeMessageEnd();
2467         oprot.getTransport().flush();
2468       }
2469 
2470     }
2471 
2472     private class getRowTs implements ProcessFunction {
2473       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2474       {
2475         getRowTs_args args = new getRowTs_args();
2476         args.read(iprot);
2477         iprot.readMessageEnd();
2478         getRowTs_result result = new getRowTs_result();
2479         try {
2480           result.success = iface_.getRowTs(args.tableName, args.row, args.timestamp);
2481         } catch (IOError io) {
2482           result.io = io;
2483         } catch (Throwable th) {
2484           LOGGER.error("Internal error processing getRowTs", th);
2485           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowTs");
2486           oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.EXCEPTION, seqid));
2487           x.write(oprot);
2488           oprot.writeMessageEnd();
2489           oprot.getTransport().flush();
2490           return;
2491         }
2492         oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.REPLY, seqid));
2493         result.write(oprot);
2494         oprot.writeMessageEnd();
2495         oprot.getTransport().flush();
2496       }
2497 
2498     }
2499 
2500     private class getRowWithColumnsTs implements ProcessFunction {
2501       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2502       {
2503         getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
2504         args.read(iprot);
2505         iprot.readMessageEnd();
2506         getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
2507         try {
2508           result.success = iface_.getRowWithColumnsTs(args.tableName, args.row, args.columns, args.timestamp);
2509         } catch (IOError io) {
2510           result.io = io;
2511         } catch (Throwable th) {
2512           LOGGER.error("Internal error processing getRowWithColumnsTs", th);
2513           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumnsTs");
2514           oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.EXCEPTION, seqid));
2515           x.write(oprot);
2516           oprot.writeMessageEnd();
2517           oprot.getTransport().flush();
2518           return;
2519         }
2520         oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.REPLY, seqid));
2521         result.write(oprot);
2522         oprot.writeMessageEnd();
2523         oprot.getTransport().flush();
2524       }
2525 
2526     }
2527 
2528     private class getRows implements ProcessFunction {
2529       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2530       {
2531         getRows_args args = new getRows_args();
2532         args.read(iprot);
2533         iprot.readMessageEnd();
2534         getRows_result result = new getRows_result();
2535         try {
2536           result.success = iface_.getRows(args.tableName, args.rows);
2537         } catch (IOError io) {
2538           result.io = io;
2539         } catch (Throwable th) {
2540           LOGGER.error("Internal error processing getRows", th);
2541           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRows");
2542           oprot.writeMessageBegin(new TMessage("getRows", TMessageType.EXCEPTION, seqid));
2543           x.write(oprot);
2544           oprot.writeMessageEnd();
2545           oprot.getTransport().flush();
2546           return;
2547         }
2548         oprot.writeMessageBegin(new TMessage("getRows", TMessageType.REPLY, seqid));
2549         result.write(oprot);
2550         oprot.writeMessageEnd();
2551         oprot.getTransport().flush();
2552       }
2553 
2554     }
2555 
2556     private class getRowsWithColumns implements ProcessFunction {
2557       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2558       {
2559         getRowsWithColumns_args args = new getRowsWithColumns_args();
2560         args.read(iprot);
2561         iprot.readMessageEnd();
2562         getRowsWithColumns_result result = new getRowsWithColumns_result();
2563         try {
2564           result.success = iface_.getRowsWithColumns(args.tableName, args.rows, args.columns);
2565         } catch (IOError io) {
2566           result.io = io;
2567         } catch (Throwable th) {
2568           LOGGER.error("Internal error processing getRowsWithColumns", th);
2569           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumns");
2570           oprot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.EXCEPTION, seqid));
2571           x.write(oprot);
2572           oprot.writeMessageEnd();
2573           oprot.getTransport().flush();
2574           return;
2575         }
2576         oprot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.REPLY, seqid));
2577         result.write(oprot);
2578         oprot.writeMessageEnd();
2579         oprot.getTransport().flush();
2580       }
2581 
2582     }
2583 
2584     private class getRowsTs implements ProcessFunction {
2585       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2586       {
2587         getRowsTs_args args = new getRowsTs_args();
2588         args.read(iprot);
2589         iprot.readMessageEnd();
2590         getRowsTs_result result = new getRowsTs_result();
2591         try {
2592           result.success = iface_.getRowsTs(args.tableName, args.rows, args.timestamp);
2593         } catch (IOError io) {
2594           result.io = io;
2595         } catch (Throwable th) {
2596           LOGGER.error("Internal error processing getRowsTs", th);
2597           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsTs");
2598           oprot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.EXCEPTION, seqid));
2599           x.write(oprot);
2600           oprot.writeMessageEnd();
2601           oprot.getTransport().flush();
2602           return;
2603         }
2604         oprot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.REPLY, seqid));
2605         result.write(oprot);
2606         oprot.writeMessageEnd();
2607         oprot.getTransport().flush();
2608       }
2609 
2610     }
2611 
2612     private class getRowsWithColumnsTs implements ProcessFunction {
2613       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2614       {
2615         getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args();
2616         args.read(iprot);
2617         iprot.readMessageEnd();
2618         getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
2619         try {
2620           result.success = iface_.getRowsWithColumnsTs(args.tableName, args.rows, args.columns, args.timestamp);
2621         } catch (IOError io) {
2622           result.io = io;
2623         } catch (Throwable th) {
2624           LOGGER.error("Internal error processing getRowsWithColumnsTs", th);
2625           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumnsTs");
2626           oprot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.EXCEPTION, seqid));
2627           x.write(oprot);
2628           oprot.writeMessageEnd();
2629           oprot.getTransport().flush();
2630           return;
2631         }
2632         oprot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.REPLY, seqid));
2633         result.write(oprot);
2634         oprot.writeMessageEnd();
2635         oprot.getTransport().flush();
2636       }
2637 
2638     }
2639 
2640     private class mutateRow implements ProcessFunction {
2641       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2642       {
2643         mutateRow_args args = new mutateRow_args();
2644         args.read(iprot);
2645         iprot.readMessageEnd();
2646         mutateRow_result result = new mutateRow_result();
2647         try {
2648           iface_.mutateRow(args.tableName, args.row, args.mutations);
2649         } catch (IOError io) {
2650           result.io = io;
2651         } catch (IllegalArgument ia) {
2652           result.ia = ia;
2653         } catch (Throwable th) {
2654           LOGGER.error("Internal error processing mutateRow", th);
2655           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRow");
2656           oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.EXCEPTION, seqid));
2657           x.write(oprot);
2658           oprot.writeMessageEnd();
2659           oprot.getTransport().flush();
2660           return;
2661         }
2662         oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.REPLY, seqid));
2663         result.write(oprot);
2664         oprot.writeMessageEnd();
2665         oprot.getTransport().flush();
2666       }
2667 
2668     }
2669 
2670     private class mutateRowTs implements ProcessFunction {
2671       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2672       {
2673         mutateRowTs_args args = new mutateRowTs_args();
2674         args.read(iprot);
2675         iprot.readMessageEnd();
2676         mutateRowTs_result result = new mutateRowTs_result();
2677         try {
2678           iface_.mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp);
2679         } catch (IOError io) {
2680           result.io = io;
2681         } catch (IllegalArgument ia) {
2682           result.ia = ia;
2683         } catch (Throwable th) {
2684           LOGGER.error("Internal error processing mutateRowTs", th);
2685           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowTs");
2686           oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.EXCEPTION, seqid));
2687           x.write(oprot);
2688           oprot.writeMessageEnd();
2689           oprot.getTransport().flush();
2690           return;
2691         }
2692         oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.REPLY, seqid));
2693         result.write(oprot);
2694         oprot.writeMessageEnd();
2695         oprot.getTransport().flush();
2696       }
2697 
2698     }
2699 
2700     private class mutateRows implements ProcessFunction {
2701       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2702       {
2703         mutateRows_args args = new mutateRows_args();
2704         args.read(iprot);
2705         iprot.readMessageEnd();
2706         mutateRows_result result = new mutateRows_result();
2707         try {
2708           iface_.mutateRows(args.tableName, args.rowBatches);
2709         } catch (IOError io) {
2710           result.io = io;
2711         } catch (IllegalArgument ia) {
2712           result.ia = ia;
2713         } catch (Throwable th) {
2714           LOGGER.error("Internal error processing mutateRows", th);
2715           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRows");
2716           oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.EXCEPTION, seqid));
2717           x.write(oprot);
2718           oprot.writeMessageEnd();
2719           oprot.getTransport().flush();
2720           return;
2721         }
2722         oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.REPLY, seqid));
2723         result.write(oprot);
2724         oprot.writeMessageEnd();
2725         oprot.getTransport().flush();
2726       }
2727 
2728     }
2729 
2730     private class mutateRowsTs implements ProcessFunction {
2731       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2732       {
2733         mutateRowsTs_args args = new mutateRowsTs_args();
2734         args.read(iprot);
2735         iprot.readMessageEnd();
2736         mutateRowsTs_result result = new mutateRowsTs_result();
2737         try {
2738           iface_.mutateRowsTs(args.tableName, args.rowBatches, args.timestamp);
2739         } catch (IOError io) {
2740           result.io = io;
2741         } catch (IllegalArgument ia) {
2742           result.ia = ia;
2743         } catch (Throwable th) {
2744           LOGGER.error("Internal error processing mutateRowsTs", th);
2745           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowsTs");
2746           oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.EXCEPTION, seqid));
2747           x.write(oprot);
2748           oprot.writeMessageEnd();
2749           oprot.getTransport().flush();
2750           return;
2751         }
2752         oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.REPLY, seqid));
2753         result.write(oprot);
2754         oprot.writeMessageEnd();
2755         oprot.getTransport().flush();
2756       }
2757 
2758     }
2759 
2760     private class atomicIncrement implements ProcessFunction {
2761       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2762       {
2763         atomicIncrement_args args = new atomicIncrement_args();
2764         args.read(iprot);
2765         iprot.readMessageEnd();
2766         atomicIncrement_result result = new atomicIncrement_result();
2767         try {
2768           result.success = iface_.atomicIncrement(args.tableName, args.row, args.column, args.value);
2769           result.setSuccessIsSet(true);
2770         } catch (IOError io) {
2771           result.io = io;
2772         } catch (IllegalArgument ia) {
2773           result.ia = ia;
2774         } catch (Throwable th) {
2775           LOGGER.error("Internal error processing atomicIncrement", th);
2776           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing atomicIncrement");
2777           oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.EXCEPTION, seqid));
2778           x.write(oprot);
2779           oprot.writeMessageEnd();
2780           oprot.getTransport().flush();
2781           return;
2782         }
2783         oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.REPLY, seqid));
2784         result.write(oprot);
2785         oprot.writeMessageEnd();
2786         oprot.getTransport().flush();
2787       }
2788 
2789     }
2790 
2791     private class deleteAll implements ProcessFunction {
2792       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2793       {
2794         deleteAll_args args = new deleteAll_args();
2795         args.read(iprot);
2796         iprot.readMessageEnd();
2797         deleteAll_result result = new deleteAll_result();
2798         try {
2799           iface_.deleteAll(args.tableName, args.row, args.column);
2800         } catch (IOError io) {
2801           result.io = io;
2802         } catch (Throwable th) {
2803           LOGGER.error("Internal error processing deleteAll", th);
2804           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAll");
2805           oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.EXCEPTION, seqid));
2806           x.write(oprot);
2807           oprot.writeMessageEnd();
2808           oprot.getTransport().flush();
2809           return;
2810         }
2811         oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.REPLY, seqid));
2812         result.write(oprot);
2813         oprot.writeMessageEnd();
2814         oprot.getTransport().flush();
2815       }
2816 
2817     }
2818 
2819     private class deleteAllTs implements ProcessFunction {
2820       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2821       {
2822         deleteAllTs_args args = new deleteAllTs_args();
2823         args.read(iprot);
2824         iprot.readMessageEnd();
2825         deleteAllTs_result result = new deleteAllTs_result();
2826         try {
2827           iface_.deleteAllTs(args.tableName, args.row, args.column, args.timestamp);
2828         } catch (IOError io) {
2829           result.io = io;
2830         } catch (Throwable th) {
2831           LOGGER.error("Internal error processing deleteAllTs", th);
2832           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllTs");
2833           oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.EXCEPTION, seqid));
2834           x.write(oprot);
2835           oprot.writeMessageEnd();
2836           oprot.getTransport().flush();
2837           return;
2838         }
2839         oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.REPLY, seqid));
2840         result.write(oprot);
2841         oprot.writeMessageEnd();
2842         oprot.getTransport().flush();
2843       }
2844 
2845     }
2846 
2847     private class deleteAllRow implements ProcessFunction {
2848       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2849       {
2850         deleteAllRow_args args = new deleteAllRow_args();
2851         args.read(iprot);
2852         iprot.readMessageEnd();
2853         deleteAllRow_result result = new deleteAllRow_result();
2854         try {
2855           iface_.deleteAllRow(args.tableName, args.row);
2856         } catch (IOError io) {
2857           result.io = io;
2858         } catch (Throwable th) {
2859           LOGGER.error("Internal error processing deleteAllRow", th);
2860           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRow");
2861           oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.EXCEPTION, seqid));
2862           x.write(oprot);
2863           oprot.writeMessageEnd();
2864           oprot.getTransport().flush();
2865           return;
2866         }
2867         oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.REPLY, seqid));
2868         result.write(oprot);
2869         oprot.writeMessageEnd();
2870         oprot.getTransport().flush();
2871       }
2872 
2873     }
2874 
2875     private class deleteAllRowTs implements ProcessFunction {
2876       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2877       {
2878         deleteAllRowTs_args args = new deleteAllRowTs_args();
2879         args.read(iprot);
2880         iprot.readMessageEnd();
2881         deleteAllRowTs_result result = new deleteAllRowTs_result();
2882         try {
2883           iface_.deleteAllRowTs(args.tableName, args.row, args.timestamp);
2884         } catch (IOError io) {
2885           result.io = io;
2886         } catch (Throwable th) {
2887           LOGGER.error("Internal error processing deleteAllRowTs", th);
2888           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRowTs");
2889           oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.EXCEPTION, seqid));
2890           x.write(oprot);
2891           oprot.writeMessageEnd();
2892           oprot.getTransport().flush();
2893           return;
2894         }
2895         oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.REPLY, seqid));
2896         result.write(oprot);
2897         oprot.writeMessageEnd();
2898         oprot.getTransport().flush();
2899       }
2900 
2901     }
2902 
2903     private class scannerOpen implements ProcessFunction {
2904       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2905       {
2906         scannerOpen_args args = new scannerOpen_args();
2907         args.read(iprot);
2908         iprot.readMessageEnd();
2909         scannerOpen_result result = new scannerOpen_result();
2910         try {
2911           result.success = iface_.scannerOpen(args.tableName, args.startRow, args.columns);
2912           result.setSuccessIsSet(true);
2913         } catch (IOError io) {
2914           result.io = io;
2915         } catch (Throwable th) {
2916           LOGGER.error("Internal error processing scannerOpen", th);
2917           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpen");
2918           oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.EXCEPTION, seqid));
2919           x.write(oprot);
2920           oprot.writeMessageEnd();
2921           oprot.getTransport().flush();
2922           return;
2923         }
2924         oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.REPLY, seqid));
2925         result.write(oprot);
2926         oprot.writeMessageEnd();
2927         oprot.getTransport().flush();
2928       }
2929 
2930     }
2931 
2932     private class scannerOpenWithStop implements ProcessFunction {
2933       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2934       {
2935         scannerOpenWithStop_args args = new scannerOpenWithStop_args();
2936         args.read(iprot);
2937         iprot.readMessageEnd();
2938         scannerOpenWithStop_result result = new scannerOpenWithStop_result();
2939         try {
2940           result.success = iface_.scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns);
2941           result.setSuccessIsSet(true);
2942         } catch (IOError io) {
2943           result.io = io;
2944         } catch (Throwable th) {
2945           LOGGER.error("Internal error processing scannerOpenWithStop", th);
2946           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStop");
2947           oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.EXCEPTION, seqid));
2948           x.write(oprot);
2949           oprot.writeMessageEnd();
2950           oprot.getTransport().flush();
2951           return;
2952         }
2953         oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.REPLY, seqid));
2954         result.write(oprot);
2955         oprot.writeMessageEnd();
2956         oprot.getTransport().flush();
2957       }
2958 
2959     }
2960 
2961     private class scannerOpenWithPrefix implements ProcessFunction {
2962       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2963       {
2964         scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
2965         args.read(iprot);
2966         iprot.readMessageEnd();
2967         scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
2968         try {
2969           result.success = iface_.scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns);
2970           result.setSuccessIsSet(true);
2971         } catch (IOError io) {
2972           result.io = io;
2973         } catch (Throwable th) {
2974           LOGGER.error("Internal error processing scannerOpenWithPrefix", th);
2975           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithPrefix");
2976           oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.EXCEPTION, seqid));
2977           x.write(oprot);
2978           oprot.writeMessageEnd();
2979           oprot.getTransport().flush();
2980           return;
2981         }
2982         oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.REPLY, seqid));
2983         result.write(oprot);
2984         oprot.writeMessageEnd();
2985         oprot.getTransport().flush();
2986       }
2987 
2988     }
2989 
2990     private class scannerOpenTs implements ProcessFunction {
2991       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2992       {
2993         scannerOpenTs_args args = new scannerOpenTs_args();
2994         args.read(iprot);
2995         iprot.readMessageEnd();
2996         scannerOpenTs_result result = new scannerOpenTs_result();
2997         try {
2998           result.success = iface_.scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp);
2999           result.setSuccessIsSet(true);
3000         } catch (IOError io) {
3001           result.io = io;
3002         } catch (Throwable th) {
3003           LOGGER.error("Internal error processing scannerOpenTs", th);
3004           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenTs");
3005           oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.EXCEPTION, seqid));
3006           x.write(oprot);
3007           oprot.writeMessageEnd();
3008           oprot.getTransport().flush();
3009           return;
3010         }
3011         oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.REPLY, seqid));
3012         result.write(oprot);
3013         oprot.writeMessageEnd();
3014         oprot.getTransport().flush();
3015       }
3016 
3017     }
3018 
3019     private class scannerOpenWithStopTs implements ProcessFunction {
3020       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
3021       {
3022         scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
3023         args.read(iprot);
3024         iprot.readMessageEnd();
3025         scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
3026         try {
3027           result.success = iface_.scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp);
3028           result.setSuccessIsSet(true);
3029         } catch (IOError io) {
3030           result.io = io;
3031         } catch (Throwable th) {
3032           LOGGER.error("Internal error processing scannerOpenWithStopTs", th);
3033           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStopTs");
3034           oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.EXCEPTION, seqid));
3035           x.write(oprot);
3036           oprot.writeMessageEnd();
3037           oprot.getTransport().flush();
3038           return;
3039         }
3040         oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.REPLY, seqid));
3041         result.write(oprot);
3042         oprot.writeMessageEnd();
3043         oprot.getTransport().flush();
3044       }
3045 
3046     }
3047 
3048     private class scannerGet implements ProcessFunction {
3049       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
3050       {
3051         scannerGet_args args = new scannerGet_args();
3052         args.read(iprot);
3053         iprot.readMessageEnd();
3054         scannerGet_result result = new scannerGet_result();
3055         try {
3056           result.success = iface_.scannerGet(args.id);
3057         } catch (IOError io) {
3058           result.io = io;
3059         } catch (IllegalArgument ia) {
3060           result.ia = ia;
3061         } catch (Throwable th) {
3062           LOGGER.error("Internal error processing scannerGet", th);
3063           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGet");
3064           oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.EXCEPTION, seqid));
3065           x.write(oprot);
3066           oprot.writeMessageEnd();
3067           oprot.getTransport().flush();
3068           return;
3069         }
3070         oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.REPLY, seqid));
3071         result.write(oprot);
3072         oprot.writeMessageEnd();
3073         oprot.getTransport().flush();
3074       }
3075 
3076     }
3077 
3078     private class scannerGetList implements ProcessFunction {
3079       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
3080       {
3081         scannerGetList_args args = new scannerGetList_args();
3082         args.read(iprot);
3083         iprot.readMessageEnd();
3084         scannerGetList_result result = new scannerGetList_result();
3085         try {
3086           result.success = iface_.scannerGetList(args.id, args.nbRows);
3087         } catch (IOError io) {
3088           result.io = io;
3089         } catch (IllegalArgument ia) {
3090           result.ia = ia;
3091         } catch (Throwable th) {
3092           LOGGER.error("Internal error processing scannerGetList", th);
3093           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGetList");
3094           oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.EXCEPTION, seqid));
3095           x.write(oprot);
3096           oprot.writeMessageEnd();
3097           oprot.getTransport().flush();
3098           return;
3099         }
3100         oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.REPLY, seqid));
3101         result.write(oprot);
3102         oprot.writeMessageEnd();
3103         oprot.getTransport().flush();
3104       }
3105 
3106     }
3107 
3108     private class scannerClose implements ProcessFunction {
3109       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
3110       {
3111         scannerClose_args args = new scannerClose_args();
3112         args.read(iprot);
3113         iprot.readMessageEnd();
3114         scannerClose_result result = new scannerClose_result();
3115         try {
3116           iface_.scannerClose(args.id);
3117         } catch (IOError io) {
3118           result.io = io;
3119         } catch (IllegalArgument ia) {
3120           result.ia = ia;
3121         } catch (Throwable th) {
3122           LOGGER.error("Internal error processing scannerClose", th);
3123           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerClose");
3124           oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.EXCEPTION, seqid));
3125           x.write(oprot);
3126           oprot.writeMessageEnd();
3127           oprot.getTransport().flush();
3128           return;
3129         }
3130         oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.REPLY, seqid));
3131         result.write(oprot);
3132         oprot.writeMessageEnd();
3133         oprot.getTransport().flush();
3134       }
3135 
3136     }
3137 
3138   }
3139 
3140   public static class enableTable_args implements TBase<enableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_args>   {
3141     private static final TStruct STRUCT_DESC = new TStruct("enableTable_args");
3142 
3143     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
3144 
3145     /**
3146      * name of the table
3147      */
3148     public byte[] tableName;
3149 
3150     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
3151     public enum _Fields implements TFieldIdEnum {
3152       /**
3153        * name of the table
3154        */
3155       TABLE_NAME((short)1, "tableName");
3156 
3157       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3158       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3159 
3160       static {
3161         for (_Fields field : EnumSet.allOf(_Fields.class)) {
3162           byId.put((int)field._thriftId, field);
3163           byName.put(field.getFieldName(), field);
3164         }
3165       }
3166 
3167       /**
3168        * Find the _Fields constant that matches fieldId, or null if its not found.
3169        */
3170       public static _Fields findByThriftId(int fieldId) {
3171         return byId.get(fieldId);
3172       }
3173 
3174       /**
3175        * Find the _Fields constant that matches fieldId, throwing an exception
3176        * if it is not found.
3177        */
3178       public static _Fields findByThriftIdOrThrow(int fieldId) {
3179         _Fields fields = findByThriftId(fieldId);
3180         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3181         return fields;
3182       }
3183 
3184       /**
3185        * Find the _Fields constant that matches name, or null if its not found.
3186        */
3187       public static _Fields findByName(String name) {
3188         return byName.get(name);
3189       }
3190 
3191       private final short _thriftId;
3192       private final String _fieldName;
3193 
3194       _Fields(short thriftId, String fieldName) {
3195         _thriftId = thriftId;
3196         _fieldName = fieldName;
3197       }
3198 
3199       public short getThriftFieldId() {
3200         return _thriftId;
3201       }
3202 
3203       public String getFieldName() {
3204         return _fieldName;
3205       }
3206     }
3207 
3208     // isset id assignments
3209 
3210     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3211       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
3212           new FieldValueMetaData(TType.STRING)));
3213     }});
3214 
3215     static {
3216       FieldMetaData.addStructMetaDataMap(enableTable_args.class, metaDataMap);
3217     }
3218 
3219     public enableTable_args() {
3220     }
3221 
3222     public enableTable_args(
3223       byte[] tableName)
3224     {
3225       this();
3226       this.tableName = tableName;
3227     }
3228 
3229     /**
3230      * Performs a deep copy on <i>other</i>.
3231      */
3232     public enableTable_args(enableTable_args other) {
3233       if (other.isSetTableName()) {
3234         this.tableName = other.tableName;
3235       }
3236     }
3237 
3238     public enableTable_args deepCopy() {
3239       return new enableTable_args(this);
3240     }
3241 
3242     @Deprecated
3243     public enableTable_args clone() {
3244       return new enableTable_args(this);
3245     }
3246 
3247     /**
3248      * name of the table
3249      */
3250     public byte[] getTableName() {
3251       return this.tableName;
3252     }
3253 
3254     /**
3255      * name of the table
3256      */
3257     public enableTable_args setTableName(byte[] tableName) {
3258       this.tableName = tableName;
3259       return this;
3260     }
3261 
3262     public void unsetTableName() {
3263       this.tableName = null;
3264     }
3265 
3266     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
3267     public boolean isSetTableName() {
3268       return this.tableName != null;
3269     }
3270 
3271     public void setTableNameIsSet(boolean value) {
3272       if (!value) {
3273         this.tableName = null;
3274       }
3275     }
3276 
3277     public void setFieldValue(_Fields field, Object value) {
3278       switch (field) {
3279       case TABLE_NAME:
3280         if (value == null) {
3281           unsetTableName();
3282         } else {
3283           setTableName((byte[])value);
3284         }
3285         break;
3286 
3287       }
3288     }
3289 
3290     public void setFieldValue(int fieldID, Object value) {
3291       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3292     }
3293 
3294     public Object getFieldValue(_Fields field) {
3295       switch (field) {
3296       case TABLE_NAME:
3297         return getTableName();
3298 
3299       }
3300       throw new IllegalStateException();
3301     }
3302 
3303     public Object getFieldValue(int fieldId) {
3304       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3305     }
3306 
3307     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
3308     public boolean isSet(_Fields field) {
3309       switch (field) {
3310       case TABLE_NAME:
3311         return isSetTableName();
3312       }
3313       throw new IllegalStateException();
3314     }
3315 
3316     public boolean isSet(int fieldID) {
3317       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3318     }
3319 
3320     @Override
3321     public boolean equals(Object that) {
3322       if (that == null)
3323         return false;
3324       if (that instanceof enableTable_args)
3325         return this.equals((enableTable_args)that);
3326       return false;
3327     }
3328 
3329     public boolean equals(enableTable_args that) {
3330       if (that == null)
3331         return false;
3332 
3333       boolean this_present_tableName = true && this.isSetTableName();
3334       boolean that_present_tableName = true && that.isSetTableName();
3335       if (this_present_tableName || that_present_tableName) {
3336         if (!(this_present_tableName && that_present_tableName))
3337           return false;
3338         if (!java.util.Arrays.equals(this.tableName, that.tableName))
3339           return false;
3340       }
3341 
3342       return true;
3343     }
3344 
3345     @Override
3346     public int hashCode() {
3347       HashCodeBuilder builder = new HashCodeBuilder();
3348 
3349       boolean present_tableName = true && (isSetTableName());
3350       builder.append(present_tableName);
3351       if (present_tableName)
3352         builder.append(tableName);
3353 
3354       return builder.toHashCode();
3355     }
3356 
3357     public int compareTo(enableTable_args other) {
3358       if (!getClass().equals(other.getClass())) {
3359         return getClass().getName().compareTo(other.getClass().getName());
3360       }
3361 
3362       int lastComparison = 0;
3363       enableTable_args typedOther = (enableTable_args)other;
3364 
3365       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
3366       if (lastComparison != 0) {
3367         return lastComparison;
3368       }
3369       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
3370       if (lastComparison != 0) {
3371         return lastComparison;
3372       }
3373       return 0;
3374     }
3375 
3376     public void read(TProtocol iprot) throws TException {
3377       TField field;
3378       iprot.readStructBegin();
3379       while (true)
3380       {
3381         field = iprot.readFieldBegin();
3382         if (field.type == TType.STOP) {
3383           break;
3384         }
3385         _Fields fieldId = _Fields.findByThriftId(field.id);
3386         if (fieldId == null) {
3387           TProtocolUtil.skip(iprot, field.type);
3388         } else {
3389           switch (fieldId) {
3390             case TABLE_NAME:
3391               if (field.type == TType.STRING) {
3392                 this.tableName = iprot.readBinary();
3393               } else {
3394                 TProtocolUtil.skip(iprot, field.type);
3395               }
3396               break;
3397           }
3398           iprot.readFieldEnd();
3399         }
3400       }
3401       iprot.readStructEnd();
3402 
3403       // check for required fields of primitive type, which can't be checked in the validate method
3404       validate();
3405     }
3406 
3407     public void write(TProtocol oprot) throws TException {
3408       validate();
3409 
3410       oprot.writeStructBegin(STRUCT_DESC);
3411       if (this.tableName != null) {
3412         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
3413         oprot.writeBinary(this.tableName);
3414         oprot.writeFieldEnd();
3415       }
3416       oprot.writeFieldStop();
3417       oprot.writeStructEnd();
3418     }
3419 
3420     @Override
3421     public String toString() {
3422       StringBuilder sb = new StringBuilder("enableTable_args(");
3423       boolean first = true;
3424 
3425       sb.append("tableName:");
3426       if (this.tableName == null) {
3427         sb.append("null");
3428       } else {
3429         sb.append(this.tableName);
3430       }
3431       first = false;
3432       sb.append(")");
3433       return sb.toString();
3434     }
3435 
3436     public void validate() throws TException {
3437       // check for required fields
3438     }
3439 
3440   }
3441 
3442   public static class enableTable_result implements TBase<enableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_result>   {
3443     private static final TStruct STRUCT_DESC = new TStruct("enableTable_result");
3444 
3445     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
3446 
3447     public IOError io;
3448 
3449     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
3450     public enum _Fields implements TFieldIdEnum {
3451       IO((short)1, "io");
3452 
3453       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3454       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3455 
3456       static {
3457         for (_Fields field : EnumSet.allOf(_Fields.class)) {
3458           byId.put((int)field._thriftId, field);
3459           byName.put(field.getFieldName(), field);
3460         }
3461       }
3462 
3463       /**
3464        * Find the _Fields constant that matches fieldId, or null if its not found.
3465        */
3466       public static _Fields findByThriftId(int fieldId) {
3467         return byId.get(fieldId);
3468       }
3469 
3470       /**
3471        * Find the _Fields constant that matches fieldId, throwing an exception
3472        * if it is not found.
3473        */
3474       public static _Fields findByThriftIdOrThrow(int fieldId) {
3475         _Fields fields = findByThriftId(fieldId);
3476         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3477         return fields;
3478       }
3479 
3480       /**
3481        * Find the _Fields constant that matches name, or null if its not found.
3482        */
3483       public static _Fields findByName(String name) {
3484         return byName.get(name);
3485       }
3486 
3487       private final short _thriftId;
3488       private final String _fieldName;
3489 
3490       _Fields(short thriftId, String fieldName) {
3491         _thriftId = thriftId;
3492         _fieldName = fieldName;
3493       }
3494 
3495       public short getThriftFieldId() {
3496         return _thriftId;
3497       }
3498 
3499       public String getFieldName() {
3500         return _fieldName;
3501       }
3502     }
3503 
3504     // isset id assignments
3505 
3506     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3507       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
3508           new FieldValueMetaData(TType.STRUCT)));
3509     }});
3510 
3511     static {
3512       FieldMetaData.addStructMetaDataMap(enableTable_result.class, metaDataMap);
3513     }
3514 
3515     public enableTable_result() {
3516     }
3517 
3518     public enableTable_result(
3519       IOError io)
3520     {
3521       this();
3522       this.io = io;
3523     }
3524 
3525     /**
3526      * Performs a deep copy on <i>other</i>.
3527      */
3528     public enableTable_result(enableTable_result other) {
3529       if (other.isSetIo()) {
3530         this.io = new IOError(other.io);
3531       }
3532     }
3533 
3534     public enableTable_result deepCopy() {
3535       return new enableTable_result(this);
3536     }
3537 
3538     @Deprecated
3539     public enableTable_result clone() {
3540       return new enableTable_result(this);
3541     }
3542 
3543     public IOError getIo() {
3544       return this.io;
3545     }
3546 
3547     public enableTable_result setIo(IOError io) {
3548       this.io = io;
3549       return this;
3550     }
3551 
3552     public void unsetIo() {
3553       this.io = null;
3554     }
3555 
3556     /** Returns true if field io is set (has been asigned a value) and false otherwise */
3557     public boolean isSetIo() {
3558       return this.io != null;
3559     }
3560 
3561     public void setIoIsSet(boolean value) {
3562       if (!value) {
3563         this.io = null;
3564       }
3565     }
3566 
3567     public void setFieldValue(_Fields field, Object value) {
3568       switch (field) {
3569       case IO:
3570         if (value == null) {
3571           unsetIo();
3572         } else {
3573           setIo((IOError)value);
3574         }
3575         break;
3576 
3577       }
3578     }
3579 
3580     public void setFieldValue(int fieldID, Object value) {
3581       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3582     }
3583 
3584     public Object getFieldValue(_Fields field) {
3585       switch (field) {
3586       case IO:
3587         return getIo();
3588 
3589       }
3590       throw new IllegalStateException();
3591     }
3592 
3593     public Object getFieldValue(int fieldId) {
3594       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3595     }
3596 
3597     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
3598     public boolean isSet(_Fields field) {
3599       switch (field) {
3600       case IO:
3601         return isSetIo();
3602       }
3603       throw new IllegalStateException();
3604     }
3605 
3606     public boolean isSet(int fieldID) {
3607       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3608     }
3609 
3610     @Override
3611     public boolean equals(Object that) {
3612       if (that == null)
3613         return false;
3614       if (that instanceof enableTable_result)
3615         return this.equals((enableTable_result)that);
3616       return false;
3617     }
3618 
3619     public boolean equals(enableTable_result that) {
3620       if (that == null)
3621         return false;
3622 
3623       boolean this_present_io = true && this.isSetIo();
3624       boolean that_present_io = true && that.isSetIo();
3625       if (this_present_io || that_present_io) {
3626         if (!(this_present_io && that_present_io))
3627           return false;
3628         if (!this.io.equals(that.io))
3629           return false;
3630       }
3631 
3632       return true;
3633     }
3634 
3635     @Override
3636     public int hashCode() {
3637       HashCodeBuilder builder = new HashCodeBuilder();
3638 
3639       boolean present_io = true && (isSetIo());
3640       builder.append(present_io);
3641       if (present_io)
3642         builder.append(io);
3643 
3644       return builder.toHashCode();
3645     }
3646 
3647     public int compareTo(enableTable_result other) {
3648       if (!getClass().equals(other.getClass())) {
3649         return getClass().getName().compareTo(other.getClass().getName());
3650       }
3651 
3652       int lastComparison = 0;
3653       enableTable_result typedOther = (enableTable_result)other;
3654 
3655       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
3656       if (lastComparison != 0) {
3657         return lastComparison;
3658       }
3659       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
3660       if (lastComparison != 0) {
3661         return lastComparison;
3662       }
3663       return 0;
3664     }
3665 
3666     public void read(TProtocol iprot) throws TException {
3667       TField field;
3668       iprot.readStructBegin();
3669       while (true)
3670       {
3671         field = iprot.readFieldBegin();
3672         if (field.type == TType.STOP) {
3673           break;
3674         }
3675         _Fields fieldId = _Fields.findByThriftId(field.id);
3676         if (fieldId == null) {
3677           TProtocolUtil.skip(iprot, field.type);
3678         } else {
3679           switch (fieldId) {
3680             case IO:
3681               if (field.type == TType.STRUCT) {
3682                 this.io = new IOError();
3683                 this.io.read(iprot);
3684               } else {
3685                 TProtocolUtil.skip(iprot, field.type);
3686               }
3687               break;
3688           }
3689           iprot.readFieldEnd();
3690         }
3691       }
3692       iprot.readStructEnd();
3693 
3694       // check for required fields of primitive type, which can't be checked in the validate method
3695       validate();
3696     }
3697 
3698     public void write(TProtocol oprot) throws TException {
3699       oprot.writeStructBegin(STRUCT_DESC);
3700 
3701       if (this.isSetIo()) {
3702         oprot.writeFieldBegin(IO_FIELD_DESC);
3703         this.io.write(oprot);
3704         oprot.writeFieldEnd();
3705       }
3706       oprot.writeFieldStop();
3707       oprot.writeStructEnd();
3708     }
3709 
3710     @Override
3711     public String toString() {
3712       StringBuilder sb = new StringBuilder("enableTable_result(");
3713       boolean first = true;
3714 
3715       sb.append("io:");
3716       if (this.io == null) {
3717         sb.append("null");
3718       } else {
3719         sb.append(this.io);
3720       }
3721       first = false;
3722       sb.append(")");
3723       return sb.toString();
3724     }
3725 
3726     public void validate() throws TException {
3727       // check for required fields
3728     }
3729 
3730   }
3731 
3732   public static class disableTable_args implements TBase<disableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_args>   {
3733     private static final TStruct STRUCT_DESC = new TStruct("disableTable_args");
3734 
3735     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
3736 
3737     /**
3738      * name of the table
3739      */
3740     public byte[] tableName;
3741 
3742     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
3743     public enum _Fields implements TFieldIdEnum {
3744       /**
3745        * name of the table
3746        */
3747       TABLE_NAME((short)1, "tableName");
3748 
3749       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3750       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3751 
3752       static {
3753         for (_Fields field : EnumSet.allOf(_Fields.class)) {
3754           byId.put((int)field._thriftId, field);
3755           byName.put(field.getFieldName(), field);
3756         }
3757       }
3758 
3759       /**
3760        * Find the _Fields constant that matches fieldId, or null if its not found.
3761        */
3762       public static _Fields findByThriftId(int fieldId) {
3763         return byId.get(fieldId);
3764       }
3765 
3766       /**
3767        * Find the _Fields constant that matches fieldId, throwing an exception
3768        * if it is not found.
3769        */
3770       public static _Fields findByThriftIdOrThrow(int fieldId) {
3771         _Fields fields = findByThriftId(fieldId);
3772         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3773         return fields;
3774       }
3775 
3776       /**
3777        * Find the _Fields constant that matches name, or null if its not found.
3778        */
3779       public static _Fields findByName(String name) {
3780         return byName.get(name);
3781       }
3782 
3783       private final short _thriftId;
3784       private final String _fieldName;
3785 
3786       _Fields(short thriftId, String fieldName) {
3787         _thriftId = thriftId;
3788         _fieldName = fieldName;
3789       }
3790 
3791       public short getThriftFieldId() {
3792         return _thriftId;
3793       }
3794 
3795       public String getFieldName() {
3796         return _fieldName;
3797       }
3798     }
3799 
3800     // isset id assignments
3801 
3802     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3803       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
3804           new FieldValueMetaData(TType.STRING)));
3805     }});
3806 
3807     static {
3808       FieldMetaData.addStructMetaDataMap(disableTable_args.class, metaDataMap);
3809     }
3810 
3811     public disableTable_args() {
3812     }
3813 
3814     public disableTable_args(
3815       byte[] tableName)
3816     {
3817       this();
3818       this.tableName = tableName;
3819     }
3820 
3821     /**
3822      * Performs a deep copy on <i>other</i>.
3823      */
3824     public disableTable_args(disableTable_args other) {
3825       if (other.isSetTableName()) {
3826         this.tableName = other.tableName;
3827       }
3828     }
3829 
3830     public disableTable_args deepCopy() {
3831       return new disableTable_args(this);
3832     }
3833 
3834     @Deprecated
3835     public disableTable_args clone() {
3836       return new disableTable_args(this);
3837     }
3838 
3839     /**
3840      * name of the table
3841      */
3842     public byte[] getTableName() {
3843       return this.tableName;
3844     }
3845 
3846     /**
3847      * name of the table
3848      */
3849     public disableTable_args setTableName(byte[] tableName) {
3850       this.tableName = tableName;
3851       return this;
3852     }
3853 
3854     public void unsetTableName() {
3855       this.tableName = null;
3856     }
3857 
3858     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
3859     public boolean isSetTableName() {
3860       return this.tableName != null;
3861     }
3862 
3863     public void setTableNameIsSet(boolean value) {
3864       if (!value) {
3865         this.tableName = null;
3866       }
3867     }
3868 
3869     public void setFieldValue(_Fields field, Object value) {
3870       switch (field) {
3871       case TABLE_NAME:
3872         if (value == null) {
3873           unsetTableName();
3874         } else {
3875           setTableName((byte[])value);
3876         }
3877         break;
3878 
3879       }
3880     }
3881 
3882     public void setFieldValue(int fieldID, Object value) {
3883       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3884     }
3885 
3886     public Object getFieldValue(_Fields field) {
3887       switch (field) {
3888       case TABLE_NAME:
3889         return getTableName();
3890 
3891       }
3892       throw new IllegalStateException();
3893     }
3894 
3895     public Object getFieldValue(int fieldId) {
3896       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3897     }
3898 
3899     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
3900     public boolean isSet(_Fields field) {
3901       switch (field) {
3902       case TABLE_NAME:
3903         return isSetTableName();
3904       }
3905       throw new IllegalStateException();
3906     }
3907 
3908     public boolean isSet(int fieldID) {
3909       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3910     }
3911 
3912     @Override
3913     public boolean equals(Object that) {
3914       if (that == null)
3915         return false;
3916       if (that instanceof disableTable_args)
3917         return this.equals((disableTable_args)that);
3918       return false;
3919     }
3920 
3921     public boolean equals(disableTable_args that) {
3922       if (that == null)
3923         return false;
3924 
3925       boolean this_present_tableName = true && this.isSetTableName();
3926       boolean that_present_tableName = true && that.isSetTableName();
3927       if (this_present_tableName || that_present_tableName) {
3928         if (!(this_present_tableName && that_present_tableName))
3929           return false;
3930         if (!java.util.Arrays.equals(this.tableName, that.tableName))
3931           return false;
3932       }
3933 
3934       return true;
3935     }
3936 
3937     @Override
3938     public int hashCode() {
3939       HashCodeBuilder builder = new HashCodeBuilder();
3940 
3941       boolean present_tableName = true && (isSetTableName());
3942       builder.append(present_tableName);
3943       if (present_tableName)
3944         builder.append(tableName);
3945 
3946       return builder.toHashCode();
3947     }
3948 
3949     public int compareTo(disableTable_args other) {
3950       if (!getClass().equals(other.getClass())) {
3951         return getClass().getName().compareTo(other.getClass().getName());
3952       }
3953 
3954       int lastComparison = 0;
3955       disableTable_args typedOther = (disableTable_args)other;
3956 
3957       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
3958       if (lastComparison != 0) {
3959         return lastComparison;
3960       }
3961       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
3962       if (lastComparison != 0) {
3963         return lastComparison;
3964       }
3965       return 0;
3966     }
3967 
3968     public void read(TProtocol iprot) throws TException {
3969       TField field;
3970       iprot.readStructBegin();
3971       while (true)
3972       {
3973         field = iprot.readFieldBegin();
3974         if (field.type == TType.STOP) {
3975           break;
3976         }
3977         _Fields fieldId = _Fields.findByThriftId(field.id);
3978         if (fieldId == null) {
3979           TProtocolUtil.skip(iprot, field.type);
3980         } else {
3981           switch (fieldId) {
3982             case TABLE_NAME:
3983               if (field.type == TType.STRING) {
3984                 this.tableName = iprot.readBinary();
3985               } else {
3986                 TProtocolUtil.skip(iprot, field.type);
3987               }
3988               break;
3989           }
3990           iprot.readFieldEnd();
3991         }
3992       }
3993       iprot.readStructEnd();
3994 
3995       // check for required fields of primitive type, which can't be checked in the validate method
3996       validate();
3997     }
3998 
3999     public void write(TProtocol oprot) throws TException {
4000       validate();
4001 
4002       oprot.writeStructBegin(STRUCT_DESC);
4003       if (this.tableName != null) {
4004         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
4005         oprot.writeBinary(this.tableName);
4006         oprot.writeFieldEnd();
4007       }
4008       oprot.writeFieldStop();
4009       oprot.writeStructEnd();
4010     }
4011 
4012     @Override
4013     public String toString() {
4014       StringBuilder sb = new StringBuilder("disableTable_args(");
4015       boolean first = true;
4016 
4017       sb.append("tableName:");
4018       if (this.tableName == null) {
4019         sb.append("null");
4020       } else {
4021         sb.append(this.tableName);
4022       }
4023       first = false;
4024       sb.append(")");
4025       return sb.toString();
4026     }
4027 
4028     public void validate() throws TException {
4029       // check for required fields
4030     }
4031 
4032   }
4033 
4034   public static class disableTable_result implements TBase<disableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_result>   {
4035     private static final TStruct STRUCT_DESC = new TStruct("disableTable_result");
4036 
4037     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
4038 
4039     public IOError io;
4040 
4041     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4042     public enum _Fields implements TFieldIdEnum {
4043       IO((short)1, "io");
4044 
4045       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4046       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4047 
4048       static {
4049         for (_Fields field : EnumSet.allOf(_Fields.class)) {
4050           byId.put((int)field._thriftId, field);
4051           byName.put(field.getFieldName(), field);
4052         }
4053       }
4054 
4055       /**
4056        * Find the _Fields constant that matches fieldId, or null if its not found.
4057        */
4058       public static _Fields findByThriftId(int fieldId) {
4059         return byId.get(fieldId);
4060       }
4061 
4062       /**
4063        * Find the _Fields constant that matches fieldId, throwing an exception
4064        * if it is not found.
4065        */
4066       public static _Fields findByThriftIdOrThrow(int fieldId) {
4067         _Fields fields = findByThriftId(fieldId);
4068         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4069         return fields;
4070       }
4071 
4072       /**
4073        * Find the _Fields constant that matches name, or null if its not found.
4074        */
4075       public static _Fields findByName(String name) {
4076         return byName.get(name);
4077       }
4078 
4079       private final short _thriftId;
4080       private final String _fieldName;
4081 
4082       _Fields(short thriftId, String fieldName) {
4083         _thriftId = thriftId;
4084         _fieldName = fieldName;
4085       }
4086 
4087       public short getThriftFieldId() {
4088         return _thriftId;
4089       }
4090 
4091       public String getFieldName() {
4092         return _fieldName;
4093       }
4094     }
4095 
4096     // isset id assignments
4097 
4098     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4099       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
4100           new FieldValueMetaData(TType.STRUCT)));
4101     }});
4102 
4103     static {
4104       FieldMetaData.addStructMetaDataMap(disableTable_result.class, metaDataMap);
4105     }
4106 
4107     public disableTable_result() {
4108     }
4109 
4110     public disableTable_result(
4111       IOError io)
4112     {
4113       this();
4114       this.io = io;
4115     }
4116 
4117     /**
4118      * Performs a deep copy on <i>other</i>.
4119      */
4120     public disableTable_result(disableTable_result other) {
4121       if (other.isSetIo()) {
4122         this.io = new IOError(other.io);
4123       }
4124     }
4125 
4126     public disableTable_result deepCopy() {
4127       return new disableTable_result(this);
4128     }
4129 
4130     @Deprecated
4131     public disableTable_result clone() {
4132       return new disableTable_result(this);
4133     }
4134 
4135     public IOError getIo() {
4136       return this.io;
4137     }
4138 
4139     public disableTable_result setIo(IOError io) {
4140       this.io = io;
4141       return this;
4142     }
4143 
4144     public void unsetIo() {
4145       this.io = null;
4146     }
4147 
4148     /** Returns true if field io is set (has been asigned a value) and false otherwise */
4149     public boolean isSetIo() {
4150       return this.io != null;
4151     }
4152 
4153     public void setIoIsSet(boolean value) {
4154       if (!value) {
4155         this.io = null;
4156       }
4157     }
4158 
4159     public void setFieldValue(_Fields field, Object value) {
4160       switch (field) {
4161       case IO:
4162         if (value == null) {
4163           unsetIo();
4164         } else {
4165           setIo((IOError)value);
4166         }
4167         break;
4168 
4169       }
4170     }
4171 
4172     public void setFieldValue(int fieldID, Object value) {
4173       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4174     }
4175 
4176     public Object getFieldValue(_Fields field) {
4177       switch (field) {
4178       case IO:
4179         return getIo();
4180 
4181       }
4182       throw new IllegalStateException();
4183     }
4184 
4185     public Object getFieldValue(int fieldId) {
4186       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4187     }
4188 
4189     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
4190     public boolean isSet(_Fields field) {
4191       switch (field) {
4192       case IO:
4193         return isSetIo();
4194       }
4195       throw new IllegalStateException();
4196     }
4197 
4198     public boolean isSet(int fieldID) {
4199       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4200     }
4201 
4202     @Override
4203     public boolean equals(Object that) {
4204       if (that == null)
4205         return false;
4206       if (that instanceof disableTable_result)
4207         return this.equals((disableTable_result)that);
4208       return false;
4209     }
4210 
4211     public boolean equals(disableTable_result that) {
4212       if (that == null)
4213         return false;
4214 
4215       boolean this_present_io = true && this.isSetIo();
4216       boolean that_present_io = true && that.isSetIo();
4217       if (this_present_io || that_present_io) {
4218         if (!(this_present_io && that_present_io))
4219           return false;
4220         if (!this.io.equals(that.io))
4221           return false;
4222       }
4223 
4224       return true;
4225     }
4226 
4227     @Override
4228     public int hashCode() {
4229       HashCodeBuilder builder = new HashCodeBuilder();
4230 
4231       boolean present_io = true && (isSetIo());
4232       builder.append(present_io);
4233       if (present_io)
4234         builder.append(io);
4235 
4236       return builder.toHashCode();
4237     }
4238 
4239     public int compareTo(disableTable_result other) {
4240       if (!getClass().equals(other.getClass())) {
4241         return getClass().getName().compareTo(other.getClass().getName());
4242       }
4243 
4244       int lastComparison = 0;
4245       disableTable_result typedOther = (disableTable_result)other;
4246 
4247       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
4248       if (lastComparison != 0) {
4249         return lastComparison;
4250       }
4251       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
4252       if (lastComparison != 0) {
4253         return lastComparison;
4254       }
4255       return 0;
4256     }
4257 
4258     public void read(TProtocol iprot) throws TException {
4259       TField field;
4260       iprot.readStructBegin();
4261       while (true)
4262       {
4263         field = iprot.readFieldBegin();
4264         if (field.type == TType.STOP) {
4265           break;
4266         }
4267         _Fields fieldId = _Fields.findByThriftId(field.id);
4268         if (fieldId == null) {
4269           TProtocolUtil.skip(iprot, field.type);
4270         } else {
4271           switch (fieldId) {
4272             case IO:
4273               if (field.type == TType.STRUCT) {
4274                 this.io = new IOError();
4275                 this.io.read(iprot);
4276               } else {
4277                 TProtocolUtil.skip(iprot, field.type);
4278               }
4279               break;
4280           }
4281           iprot.readFieldEnd();
4282         }
4283       }
4284       iprot.readStructEnd();
4285 
4286       // check for required fields of primitive type, which can't be checked in the validate method
4287       validate();
4288     }
4289 
4290     public void write(TProtocol oprot) throws TException {
4291       oprot.writeStructBegin(STRUCT_DESC);
4292 
4293       if (this.isSetIo()) {
4294         oprot.writeFieldBegin(IO_FIELD_DESC);
4295         this.io.write(oprot);
4296         oprot.writeFieldEnd();
4297       }
4298       oprot.writeFieldStop();
4299       oprot.writeStructEnd();
4300     }
4301 
4302     @Override
4303     public String toString() {
4304       StringBuilder sb = new StringBuilder("disableTable_result(");
4305       boolean first = true;
4306 
4307       sb.append("io:");
4308       if (this.io == null) {
4309         sb.append("null");
4310       } else {
4311         sb.append(this.io);
4312       }
4313       first = false;
4314       sb.append(")");
4315       return sb.toString();
4316     }
4317 
4318     public void validate() throws TException {
4319       // check for required fields
4320     }
4321 
4322   }
4323 
4324   public static class isTableEnabled_args implements TBase<isTableEnabled_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_args>   {
4325     private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_args");
4326 
4327     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
4328 
4329     /**
4330      * name of the table to check
4331      */
4332     public byte[] tableName;
4333 
4334     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4335     public enum _Fields implements TFieldIdEnum {
4336       /**
4337        * name of the table to check
4338        */
4339       TABLE_NAME((short)1, "tableName");
4340 
4341       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4342       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4343 
4344       static {
4345         for (_Fields field : EnumSet.allOf(_Fields.class)) {
4346           byId.put((int)field._thriftId, field);
4347           byName.put(field.getFieldName(), field);
4348         }
4349       }
4350 
4351       /**
4352        * Find the _Fields constant that matches fieldId, or null if its not found.
4353        */
4354       public static _Fields findByThriftId(int fieldId) {
4355         return byId.get(fieldId);
4356       }
4357 
4358       /**
4359        * Find the _Fields constant that matches fieldId, throwing an exception
4360        * if it is not found.
4361        */
4362       public static _Fields findByThriftIdOrThrow(int fieldId) {
4363         _Fields fields = findByThriftId(fieldId);
4364         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4365         return fields;
4366       }
4367 
4368       /**
4369        * Find the _Fields constant that matches name, or null if its not found.
4370        */
4371       public static _Fields findByName(String name) {
4372         return byName.get(name);
4373       }
4374 
4375       private final short _thriftId;
4376       private final String _fieldName;
4377 
4378       _Fields(short thriftId, String fieldName) {
4379         _thriftId = thriftId;
4380         _fieldName = fieldName;
4381       }
4382 
4383       public short getThriftFieldId() {
4384         return _thriftId;
4385       }
4386 
4387       public String getFieldName() {
4388         return _fieldName;
4389       }
4390     }
4391 
4392     // isset id assignments
4393 
4394     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4395       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
4396           new FieldValueMetaData(TType.STRING)));
4397     }});
4398 
4399     static {
4400       FieldMetaData.addStructMetaDataMap(isTableEnabled_args.class, metaDataMap);
4401     }
4402 
4403     public isTableEnabled_args() {
4404     }
4405 
4406     public isTableEnabled_args(
4407       byte[] tableName)
4408     {
4409       this();
4410       this.tableName = tableName;
4411     }
4412 
4413     /**
4414      * Performs a deep copy on <i>other</i>.
4415      */
4416     public isTableEnabled_args(isTableEnabled_args other) {
4417       if (other.isSetTableName()) {
4418         this.tableName = other.tableName;
4419       }
4420     }
4421 
4422     public isTableEnabled_args deepCopy() {
4423       return new isTableEnabled_args(this);
4424     }
4425 
4426     @Deprecated
4427     public isTableEnabled_args clone() {
4428       return new isTableEnabled_args(this);
4429     }
4430 
4431     /**
4432      * name of the table to check
4433      */
4434     public byte[] getTableName() {
4435       return this.tableName;
4436     }
4437 
4438     /**
4439      * name of the table to check
4440      */
4441     public isTableEnabled_args setTableName(byte[] tableName) {
4442       this.tableName = tableName;
4443       return this;
4444     }
4445 
4446     public void unsetTableName() {
4447       this.tableName = null;
4448     }
4449 
4450     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
4451     public boolean isSetTableName() {
4452       return this.tableName != null;
4453     }
4454 
4455     public void setTableNameIsSet(boolean value) {
4456       if (!value) {
4457         this.tableName = null;
4458       }
4459     }
4460 
4461     public void setFieldValue(_Fields field, Object value) {
4462       switch (field) {
4463       case TABLE_NAME:
4464         if (value == null) {
4465           unsetTableName();
4466         } else {
4467           setTableName((byte[])value);
4468         }
4469         break;
4470 
4471       }
4472     }
4473 
4474     public void setFieldValue(int fieldID, Object value) {
4475       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4476     }
4477 
4478     public Object getFieldValue(_Fields field) {
4479       switch (field) {
4480       case TABLE_NAME:
4481         return getTableName();
4482 
4483       }
4484       throw new IllegalStateException();
4485     }
4486 
4487     public Object getFieldValue(int fieldId) {
4488       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4489     }
4490 
4491     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
4492     public boolean isSet(_Fields field) {
4493       switch (field) {
4494       case TABLE_NAME:
4495         return isSetTableName();
4496       }
4497       throw new IllegalStateException();
4498     }
4499 
4500     public boolean isSet(int fieldID) {
4501       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4502     }
4503 
4504     @Override
4505     public boolean equals(Object that) {
4506       if (that == null)
4507         return false;
4508       if (that instanceof isTableEnabled_args)
4509         return this.equals((isTableEnabled_args)that);
4510       return false;
4511     }
4512 
4513     public boolean equals(isTableEnabled_args that) {
4514       if (that == null)
4515         return false;
4516 
4517       boolean this_present_tableName = true && this.isSetTableName();
4518       boolean that_present_tableName = true && that.isSetTableName();
4519       if (this_present_tableName || that_present_tableName) {
4520         if (!(this_present_tableName && that_present_tableName))
4521           return false;
4522         if (!java.util.Arrays.equals(this.tableName, that.tableName))
4523           return false;
4524       }
4525 
4526       return true;
4527     }
4528 
4529     @Override
4530     public int hashCode() {
4531       HashCodeBuilder builder = new HashCodeBuilder();
4532 
4533       boolean present_tableName = true && (isSetTableName());
4534       builder.append(present_tableName);
4535       if (present_tableName)
4536         builder.append(tableName);
4537 
4538       return builder.toHashCode();
4539     }
4540 
4541     public int compareTo(isTableEnabled_args other) {
4542       if (!getClass().equals(other.getClass())) {
4543         return getClass().getName().compareTo(other.getClass().getName());
4544       }
4545 
4546       int lastComparison = 0;
4547       isTableEnabled_args typedOther = (isTableEnabled_args)other;
4548 
4549       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
4550       if (lastComparison != 0) {
4551         return lastComparison;
4552       }
4553       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
4554       if (lastComparison != 0) {
4555         return lastComparison;
4556       }
4557       return 0;
4558     }
4559 
4560     public void read(TProtocol iprot) throws TException {
4561       TField field;
4562       iprot.readStructBegin();
4563       while (true)
4564       {
4565         field = iprot.readFieldBegin();
4566         if (field.type == TType.STOP) {
4567           break;
4568         }
4569         _Fields fieldId = _Fields.findByThriftId(field.id);
4570         if (fieldId == null) {
4571           TProtocolUtil.skip(iprot, field.type);
4572         } else {
4573           switch (fieldId) {
4574             case TABLE_NAME:
4575               if (field.type == TType.STRING) {
4576                 this.tableName = iprot.readBinary();
4577               } else {
4578                 TProtocolUtil.skip(iprot, field.type);
4579               }
4580               break;
4581           }
4582           iprot.readFieldEnd();
4583         }
4584       }
4585       iprot.readStructEnd();
4586 
4587       // check for required fields of primitive type, which can't be checked in the validate method
4588       validate();
4589     }
4590 
4591     public void write(TProtocol oprot) throws TException {
4592       validate();
4593 
4594       oprot.writeStructBegin(STRUCT_DESC);
4595       if (this.tableName != null) {
4596         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
4597         oprot.writeBinary(this.tableName);
4598         oprot.writeFieldEnd();
4599       }
4600       oprot.writeFieldStop();
4601       oprot.writeStructEnd();
4602     }
4603 
4604     @Override
4605     public String toString() {
4606       StringBuilder sb = new StringBuilder("isTableEnabled_args(");
4607       boolean first = true;
4608 
4609       sb.append("tableName:");
4610       if (this.tableName == null) {
4611         sb.append("null");
4612       } else {
4613         sb.append(this.tableName);
4614       }
4615       first = false;
4616       sb.append(")");
4617       return sb.toString();
4618     }
4619 
4620     public void validate() throws TException {
4621       // check for required fields
4622     }
4623 
4624   }
4625 
4626   public static class isTableEnabled_result implements TBase<isTableEnabled_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_result>   {
4627     private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_result");
4628 
4629     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0);
4630     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
4631 
4632     public boolean success;
4633     public IOError io;
4634 
4635     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4636     public enum _Fields implements TFieldIdEnum {
4637       SUCCESS((short)0, "success"),
4638       IO((short)1, "io");
4639 
4640       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4641       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4642 
4643       static {
4644         for (_Fields field : EnumSet.allOf(_Fields.class)) {
4645           byId.put((int)field._thriftId, field);
4646           byName.put(field.getFieldName(), field);
4647         }
4648       }
4649 
4650       /**
4651        * Find the _Fields constant that matches fieldId, or null if its not found.
4652        */
4653       public static _Fields findByThriftId(int fieldId) {
4654         return byId.get(fieldId);
4655       }
4656 
4657       /**
4658        * Find the _Fields constant that matches fieldId, throwing an exception
4659        * if it is not found.
4660        */
4661       public static _Fields findByThriftIdOrThrow(int fieldId) {
4662         _Fields fields = findByThriftId(fieldId);
4663         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4664         return fields;
4665       }
4666 
4667       /**
4668        * Find the _Fields constant that matches name, or null if its not found.
4669        */
4670       public static _Fields findByName(String name) {
4671         return byName.get(name);
4672       }
4673 
4674       private final short _thriftId;
4675       private final String _fieldName;
4676 
4677       _Fields(short thriftId, String fieldName) {
4678         _thriftId = thriftId;
4679         _fieldName = fieldName;
4680       }
4681 
4682       public short getThriftFieldId() {
4683         return _thriftId;
4684       }
4685 
4686       public String getFieldName() {
4687         return _fieldName;
4688       }
4689     }
4690 
4691     // isset id assignments
4692     private static final int __SUCCESS_ISSET_ID = 0;
4693     private BitSet __isset_bit_vector = new BitSet(1);
4694 
4695     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4696       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
4697           new FieldValueMetaData(TType.BOOL)));
4698       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
4699           new FieldValueMetaData(TType.STRUCT)));
4700     }});
4701 
4702     static {
4703       FieldMetaData.addStructMetaDataMap(isTableEnabled_result.class, metaDataMap);
4704     }
4705 
4706     public isTableEnabled_result() {
4707     }
4708 
4709     public isTableEnabled_result(
4710       boolean success,
4711       IOError io)
4712     {
4713       this();
4714       this.success = success;
4715       setSuccessIsSet(true);
4716       this.io = io;
4717     }
4718 
4719     /**
4720      * Performs a deep copy on <i>other</i>.
4721      */
4722     public isTableEnabled_result(isTableEnabled_result other) {
4723       __isset_bit_vector.clear();
4724       __isset_bit_vector.or(other.__isset_bit_vector);
4725       this.success = other.success;
4726       if (other.isSetIo()) {
4727         this.io = new IOError(other.io);
4728       }
4729     }
4730 
4731     public isTableEnabled_result deepCopy() {
4732       return new isTableEnabled_result(this);
4733     }
4734 
4735     @Deprecated
4736     public isTableEnabled_result clone() {
4737       return new isTableEnabled_result(this);
4738     }
4739 
4740     public boolean isSuccess() {
4741       return this.success;
4742     }
4743 
4744     public isTableEnabled_result setSuccess(boolean success) {
4745       this.success = success;
4746       setSuccessIsSet(true);
4747       return this;
4748     }
4749 
4750     public void unsetSuccess() {
4751       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
4752     }
4753 
4754     /** Returns true if field success is set (has been asigned a value) and false otherwise */
4755     public boolean isSetSuccess() {
4756       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
4757     }
4758 
4759     public void setSuccessIsSet(boolean value) {
4760       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
4761     }
4762 
4763     public IOError getIo() {
4764       return this.io;
4765     }
4766 
4767     public isTableEnabled_result setIo(IOError io) {
4768       this.io = io;
4769       return this;
4770     }
4771 
4772     public void unsetIo() {
4773       this.io = null;
4774     }
4775 
4776     /** Returns true if field io is set (has been asigned a value) and false otherwise */
4777     public boolean isSetIo() {
4778       return this.io != null;
4779     }
4780 
4781     public void setIoIsSet(boolean value) {
4782       if (!value) {
4783         this.io = null;
4784       }
4785     }
4786 
4787     public void setFieldValue(_Fields field, Object value) {
4788       switch (field) {
4789       case SUCCESS:
4790         if (value == null) {
4791           unsetSuccess();
4792         } else {
4793           setSuccess((Boolean)value);
4794         }
4795         break;
4796 
4797       case IO:
4798         if (value == null) {
4799           unsetIo();
4800         } else {
4801           setIo((IOError)value);
4802         }
4803         break;
4804 
4805       }
4806     }
4807 
4808     public void setFieldValue(int fieldID, Object value) {
4809       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4810     }
4811 
4812     public Object getFieldValue(_Fields field) {
4813       switch (field) {
4814       case SUCCESS:
4815         return new Boolean(isSuccess());
4816 
4817       case IO:
4818         return getIo();
4819 
4820       }
4821       throw new IllegalStateException();
4822     }
4823 
4824     public Object getFieldValue(int fieldId) {
4825       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4826     }
4827 
4828     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
4829     public boolean isSet(_Fields field) {
4830       switch (field) {
4831       case SUCCESS:
4832         return isSetSuccess();
4833       case IO:
4834         return isSetIo();
4835       }
4836       throw new IllegalStateException();
4837     }
4838 
4839     public boolean isSet(int fieldID) {
4840       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4841     }
4842 
4843     @Override
4844     public boolean equals(Object that) {
4845       if (that == null)
4846         return false;
4847       if (that instanceof isTableEnabled_result)
4848         return this.equals((isTableEnabled_result)that);
4849       return false;
4850     }
4851 
4852     public boolean equals(isTableEnabled_result that) {
4853       if (that == null)
4854         return false;
4855 
4856       boolean this_present_success = true;
4857       boolean that_present_success = true;
4858       if (this_present_success || that_present_success) {
4859         if (!(this_present_success && that_present_success))
4860           return false;
4861         if (this.success != that.success)
4862           return false;
4863       }
4864 
4865       boolean this_present_io = true && this.isSetIo();
4866       boolean that_present_io = true && that.isSetIo();
4867       if (this_present_io || that_present_io) {
4868         if (!(this_present_io && that_present_io))
4869           return false;
4870         if (!this.io.equals(that.io))
4871           return false;
4872       }
4873 
4874       return true;
4875     }
4876 
4877     @Override
4878     public int hashCode() {
4879       HashCodeBuilder builder = new HashCodeBuilder();
4880 
4881       boolean present_success = true;
4882       builder.append(present_success);
4883       if (present_success)
4884         builder.append(success);
4885 
4886       boolean present_io = true && (isSetIo());
4887       builder.append(present_io);
4888       if (present_io)
4889         builder.append(io);
4890 
4891       return builder.toHashCode();
4892     }
4893 
4894     public int compareTo(isTableEnabled_result other) {
4895       if (!getClass().equals(other.getClass())) {
4896         return getClass().getName().compareTo(other.getClass().getName());
4897       }
4898 
4899       int lastComparison = 0;
4900       isTableEnabled_result typedOther = (isTableEnabled_result)other;
4901 
4902       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
4903       if (lastComparison != 0) {
4904         return lastComparison;
4905       }
4906       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
4907       if (lastComparison != 0) {
4908         return lastComparison;
4909       }
4910       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
4911       if (lastComparison != 0) {
4912         return lastComparison;
4913       }
4914       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
4915       if (lastComparison != 0) {
4916         return lastComparison;
4917       }
4918       return 0;
4919     }
4920 
4921     public void read(TProtocol iprot) throws TException {
4922       TField field;
4923       iprot.readStructBegin();
4924       while (true)
4925       {
4926         field = iprot.readFieldBegin();
4927         if (field.type == TType.STOP) {
4928           break;
4929         }
4930         _Fields fieldId = _Fields.findByThriftId(field.id);
4931         if (fieldId == null) {
4932           TProtocolUtil.skip(iprot, field.type);
4933         } else {
4934           switch (fieldId) {
4935             case SUCCESS:
4936               if (field.type == TType.BOOL) {
4937                 this.success = iprot.readBool();
4938                 setSuccessIsSet(true);
4939               } else {
4940                 TProtocolUtil.skip(iprot, field.type);
4941               }
4942               break;
4943             case IO:
4944               if (field.type == TType.STRUCT) {
4945                 this.io = new IOError();
4946                 this.io.read(iprot);
4947               } else {
4948                 TProtocolUtil.skip(iprot, field.type);
4949               }
4950               break;
4951           }
4952           iprot.readFieldEnd();
4953         }
4954       }
4955       iprot.readStructEnd();
4956 
4957       // check for required fields of primitive type, which can't be checked in the validate method
4958       validate();
4959     }
4960 
4961     public void write(TProtocol oprot) throws TException {
4962       oprot.writeStructBegin(STRUCT_DESC);
4963 
4964       if (this.isSetSuccess()) {
4965         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4966         oprot.writeBool(this.success);
4967         oprot.writeFieldEnd();
4968       } else if (this.isSetIo()) {
4969         oprot.writeFieldBegin(IO_FIELD_DESC);
4970         this.io.write(oprot);
4971         oprot.writeFieldEnd();
4972       }
4973       oprot.writeFieldStop();
4974       oprot.writeStructEnd();
4975     }
4976 
4977     @Override
4978     public String toString() {
4979       StringBuilder sb = new StringBuilder("isTableEnabled_result(");
4980       boolean first = true;
4981 
4982       sb.append("success:");
4983       sb.append(this.success);
4984       first = false;
4985       if (!first) sb.append(", ");
4986       sb.append("io:");
4987       if (this.io == null) {
4988         sb.append("null");
4989       } else {
4990         sb.append(this.io);
4991       }
4992       first = false;
4993       sb.append(")");
4994       return sb.toString();
4995     }
4996 
4997     public void validate() throws TException {
4998       // check for required fields
4999     }
5000 
5001   }
5002 
5003   public static class compact_args implements TBase<compact_args._Fields>, java.io.Serializable, Cloneable, Comparable<compact_args>   {
5004     private static final TStruct STRUCT_DESC = new TStruct("compact_args");
5005 
5006     private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1);
5007 
5008     public byte[] tableNameOrRegionName;
5009 
5010     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
5011     public enum _Fields implements TFieldIdEnum {
5012       TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
5013 
5014       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5015       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5016 
5017       static {
5018         for (_Fields field : EnumSet.allOf(_Fields.class)) {
5019           byId.put((int)field._thriftId, field);
5020           byName.put(field.getFieldName(), field);
5021         }
5022       }
5023 
5024       /**
5025        * Find the _Fields constant that matches fieldId, or null if its not found.
5026        */
5027       public static _Fields findByThriftId(int fieldId) {
5028         return byId.get(fieldId);
5029       }
5030 
5031       /**
5032        * Find the _Fields constant that matches fieldId, throwing an exception
5033        * if it is not found.
5034        */
5035       public static _Fields findByThriftIdOrThrow(int fieldId) {
5036         _Fields fields = findByThriftId(fieldId);
5037         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5038         return fields;
5039       }
5040 
5041       /**
5042        * Find the _Fields constant that matches name, or null if its not found.
5043        */
5044       public static _Fields findByName(String name) {
5045         return byName.get(name);
5046       }
5047 
5048       private final short _thriftId;
5049       private final String _fieldName;
5050 
5051       _Fields(short thriftId, String fieldName) {
5052         _thriftId = thriftId;
5053         _fieldName = fieldName;
5054       }
5055 
5056       public short getThriftFieldId() {
5057         return _thriftId;
5058       }
5059 
5060       public String getFieldName() {
5061         return _fieldName;
5062       }
5063     }
5064 
5065     // isset id assignments
5066 
5067     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5068       put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT,
5069           new FieldValueMetaData(TType.STRING)));
5070     }});
5071 
5072     static {
5073       FieldMetaData.addStructMetaDataMap(compact_args.class, metaDataMap);
5074     }
5075 
5076     public compact_args() {
5077     }
5078 
5079     public compact_args(
5080       byte[] tableNameOrRegionName)
5081     {
5082       this();
5083       this.tableNameOrRegionName = tableNameOrRegionName;
5084     }
5085 
5086     /**
5087      * Performs a deep copy on <i>other</i>.
5088      */
5089     public compact_args(compact_args other) {
5090       if (other.isSetTableNameOrRegionName()) {
5091         this.tableNameOrRegionName = other.tableNameOrRegionName;
5092       }
5093     }
5094 
5095     public compact_args deepCopy() {
5096       return new compact_args(this);
5097     }
5098 
5099     @Deprecated
5100     public compact_args clone() {
5101       return new compact_args(this);
5102     }
5103 
5104     public byte[] getTableNameOrRegionName() {
5105       return this.tableNameOrRegionName;
5106     }
5107 
5108     public compact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
5109       this.tableNameOrRegionName = tableNameOrRegionName;
5110       return this;
5111     }
5112 
5113     public void unsetTableNameOrRegionName() {
5114       this.tableNameOrRegionName = null;
5115     }
5116 
5117     /** Returns true if field tableNameOrRegionName is set (has been asigned a value) and false otherwise */
5118     public boolean isSetTableNameOrRegionName() {
5119       return this.tableNameOrRegionName != null;
5120     }
5121 
5122     public void setTableNameOrRegionNameIsSet(boolean value) {
5123       if (!value) {
5124         this.tableNameOrRegionName = null;
5125       }
5126     }
5127 
5128     public void setFieldValue(_Fields field, Object value) {
5129       switch (field) {
5130       case TABLE_NAME_OR_REGION_NAME:
5131         if (value == null) {
5132           unsetTableNameOrRegionName();
5133         } else {
5134           setTableNameOrRegionName((byte[])value);
5135         }
5136         break;
5137 
5138       }
5139     }
5140 
5141     public void setFieldValue(int fieldID, Object value) {
5142       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5143     }
5144 
5145     public Object getFieldValue(_Fields field) {
5146       switch (field) {
5147       case TABLE_NAME_OR_REGION_NAME:
5148         return getTableNameOrRegionName();
5149 
5150       }
5151       throw new IllegalStateException();
5152     }
5153 
5154     public Object getFieldValue(int fieldId) {
5155       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5156     }
5157 
5158     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
5159     public boolean isSet(_Fields field) {
5160       switch (field) {
5161       case TABLE_NAME_OR_REGION_NAME:
5162         return isSetTableNameOrRegionName();
5163       }
5164       throw new IllegalStateException();
5165     }
5166 
5167     public boolean isSet(int fieldID) {
5168       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5169     }
5170 
5171     @Override
5172     public boolean equals(Object that) {
5173       if (that == null)
5174         return false;
5175       if (that instanceof compact_args)
5176         return this.equals((compact_args)that);
5177       return false;
5178     }
5179 
5180     public boolean equals(compact_args that) {
5181       if (that == null)
5182         return false;
5183 
5184       boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
5185       boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
5186       if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
5187         if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
5188           return false;
5189         if (!java.util.Arrays.equals(this.tableNameOrRegionName, that.tableNameOrRegionName))
5190           return false;
5191       }
5192 
5193       return true;
5194     }
5195 
5196     @Override
5197     public int hashCode() {
5198       HashCodeBuilder builder = new HashCodeBuilder();
5199 
5200       boolean present_tableNameOrRegionName = true && (isSetTableNameOrRegionName());
5201       builder.append(present_tableNameOrRegionName);
5202       if (present_tableNameOrRegionName)
5203         builder.append(tableNameOrRegionName);
5204 
5205       return builder.toHashCode();
5206     }
5207 
5208     public int compareTo(compact_args other) {
5209       if (!getClass().equals(other.getClass())) {
5210         return getClass().getName().compareTo(other.getClass().getName());
5211       }
5212 
5213       int lastComparison = 0;
5214       compact_args typedOther = (compact_args)other;
5215 
5216       lastComparison = Boolean.valueOf(isSetTableNameOrRegionName()).compareTo(isSetTableNameOrRegionName());
5217       if (lastComparison != 0) {
5218         return lastComparison;
5219       }
5220       lastComparison = TBaseHelper.compareTo(tableNameOrRegionName, typedOther.tableNameOrRegionName);
5221       if (lastComparison != 0) {
5222         return lastComparison;
5223       }
5224       return 0;
5225     }
5226 
5227     public void read(TProtocol iprot) throws TException {
5228       TField field;
5229       iprot.readStructBegin();
5230       while (true)
5231       {
5232         field = iprot.readFieldBegin();
5233         if (field.type == TType.STOP) {
5234           break;
5235         }
5236         _Fields fieldId = _Fields.findByThriftId(field.id);
5237         if (fieldId == null) {
5238           TProtocolUtil.skip(iprot, field.type);
5239         } else {
5240           switch (fieldId) {
5241             case TABLE_NAME_OR_REGION_NAME:
5242               if (field.type == TType.STRING) {
5243                 this.tableNameOrRegionName = iprot.readBinary();
5244               } else {
5245                 TProtocolUtil.skip(iprot, field.type);
5246               }
5247               break;
5248           }
5249           iprot.readFieldEnd();
5250         }
5251       }
5252       iprot.readStructEnd();
5253 
5254       // check for required fields of primitive type, which can't be checked in the validate method
5255       validate();
5256     }
5257 
5258     public void write(TProtocol oprot) throws TException {
5259       validate();
5260 
5261       oprot.writeStructBegin(STRUCT_DESC);
5262       if (this.tableNameOrRegionName != null) {
5263         oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
5264         oprot.writeBinary(this.tableNameOrRegionName);
5265         oprot.writeFieldEnd();
5266       }
5267       oprot.writeFieldStop();
5268       oprot.writeStructEnd();
5269     }
5270 
5271     @Override
5272     public String toString() {
5273       StringBuilder sb = new StringBuilder("compact_args(");
5274       boolean first = true;
5275 
5276       sb.append("tableNameOrRegionName:");
5277       if (this.tableNameOrRegionName == null) {
5278         sb.append("null");
5279       } else {
5280         sb.append(this.tableNameOrRegionName);
5281       }
5282       first = false;
5283       sb.append(")");
5284       return sb.toString();
5285     }
5286 
5287     public void validate() throws TException {
5288       // check for required fields
5289     }
5290 
5291   }
5292 
5293   public static class compact_result implements TBase<compact_result._Fields>, java.io.Serializable, Cloneable, Comparable<compact_result>   {
5294     private static final TStruct STRUCT_DESC = new TStruct("compact_result");
5295 
5296     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
5297 
5298     public IOError io;
5299 
5300     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
5301     public enum _Fields implements TFieldIdEnum {
5302       IO((short)1, "io");
5303 
5304       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5305       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5306 
5307       static {
5308         for (_Fields field : EnumSet.allOf(_Fields.class)) {
5309           byId.put((int)field._thriftId, field);
5310           byName.put(field.getFieldName(), field);
5311         }
5312       }
5313 
5314       /**
5315        * Find the _Fields constant that matches fieldId, or null if its not found.
5316        */
5317       public static _Fields findByThriftId(int fieldId) {
5318         return byId.get(fieldId);
5319       }
5320 
5321       /**
5322        * Find the _Fields constant that matches fieldId, throwing an exception
5323        * if it is not found.
5324        */
5325       public static _Fields findByThriftIdOrThrow(int fieldId) {
5326         _Fields fields = findByThriftId(fieldId);
5327         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5328         return fields;
5329       }
5330 
5331       /**
5332        * Find the _Fields constant that matches name, or null if its not found.
5333        */
5334       public static _Fields findByName(String name) {
5335         return byName.get(name);
5336       }
5337 
5338       private final short _thriftId;
5339       private final String _fieldName;
5340 
5341       _Fields(short thriftId, String fieldName) {
5342         _thriftId = thriftId;
5343         _fieldName = fieldName;
5344       }
5345 
5346       public short getThriftFieldId() {
5347         return _thriftId;
5348       }
5349 
5350       public String getFieldName() {
5351         return _fieldName;
5352       }
5353     }
5354 
5355     // isset id assignments
5356 
5357     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5358       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
5359           new FieldValueMetaData(TType.STRUCT)));
5360     }});
5361 
5362     static {
5363       FieldMetaData.addStructMetaDataMap(compact_result.class, metaDataMap);
5364     }
5365 
5366     public compact_result() {
5367     }
5368 
5369     public compact_result(
5370       IOError io)
5371     {
5372       this();
5373       this.io = io;
5374     }
5375 
5376     /**
5377      * Performs a deep copy on <i>other</i>.
5378      */
5379     public compact_result(compact_result other) {
5380       if (other.isSetIo()) {
5381         this.io = new IOError(other.io);
5382       }
5383     }
5384 
5385     public compact_result deepCopy() {
5386       return new compact_result(this);
5387     }
5388 
5389     @Deprecated
5390     public compact_result clone() {
5391       return new compact_result(this);
5392     }
5393 
5394     public IOError getIo() {
5395       return this.io;
5396     }
5397 
5398     public compact_result setIo(IOError io) {
5399       this.io = io;
5400       return this;
5401     }
5402 
5403     public void unsetIo() {
5404       this.io = null;
5405     }
5406 
5407     /** Returns true if field io is set (has been asigned a value) and false otherwise */
5408     public boolean isSetIo() {
5409       return this.io != null;
5410     }
5411 
5412     public void setIoIsSet(boolean value) {
5413       if (!value) {
5414         this.io = null;
5415       }
5416     }
5417 
5418     public void setFieldValue(_Fields field, Object value) {
5419       switch (field) {
5420       case IO:
5421         if (value == null) {
5422           unsetIo();
5423         } else {
5424           setIo((IOError)value);
5425         }
5426         break;
5427 
5428       }
5429     }
5430 
5431     public void setFieldValue(int fieldID, Object value) {
5432       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5433     }
5434 
5435     public Object getFieldValue(_Fields field) {
5436       switch (field) {
5437       case IO:
5438         return getIo();
5439 
5440       }
5441       throw new IllegalStateException();
5442     }
5443 
5444     public Object getFieldValue(int fieldId) {
5445       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5446     }
5447 
5448     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
5449     public boolean isSet(_Fields field) {
5450       switch (field) {
5451       case IO:
5452         return isSetIo();
5453       }
5454       throw new IllegalStateException();
5455     }
5456 
5457     public boolean isSet(int fieldID) {
5458       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5459     }
5460 
5461     @Override
5462     public boolean equals(Object that) {
5463       if (that == null)
5464         return false;
5465       if (that instanceof compact_result)
5466         return this.equals((compact_result)that);
5467       return false;
5468     }
5469 
5470     public boolean equals(compact_result that) {
5471       if (that == null)
5472         return false;
5473 
5474       boolean this_present_io = true && this.isSetIo();
5475       boolean that_present_io = true && that.isSetIo();
5476       if (this_present_io || that_present_io) {
5477         if (!(this_present_io && that_present_io))
5478           return false;
5479         if (!this.io.equals(that.io))
5480           return false;
5481       }
5482 
5483       return true;
5484     }
5485 
5486     @Override
5487     public int hashCode() {
5488       HashCodeBuilder builder = new HashCodeBuilder();
5489 
5490       boolean present_io = true && (isSetIo());
5491       builder.append(present_io);
5492       if (present_io)
5493         builder.append(io);
5494 
5495       return builder.toHashCode();
5496     }
5497 
5498     public int compareTo(compact_result other) {
5499       if (!getClass().equals(other.getClass())) {
5500         return getClass().getName().compareTo(other.getClass().getName());
5501       }
5502 
5503       int lastComparison = 0;
5504       compact_result typedOther = (compact_result)other;
5505 
5506       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
5507       if (lastComparison != 0) {
5508         return lastComparison;
5509       }
5510       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
5511       if (lastComparison != 0) {
5512         return lastComparison;
5513       }
5514       return 0;
5515     }
5516 
5517     public void read(TProtocol iprot) throws TException {
5518       TField field;
5519       iprot.readStructBegin();
5520       while (true)
5521       {
5522         field = iprot.readFieldBegin();
5523         if (field.type == TType.STOP) {
5524           break;
5525         }
5526         _Fields fieldId = _Fields.findByThriftId(field.id);
5527         if (fieldId == null) {
5528           TProtocolUtil.skip(iprot, field.type);
5529         } else {
5530           switch (fieldId) {
5531             case IO:
5532               if (field.type == TType.STRUCT) {
5533                 this.io = new IOError();
5534                 this.io.read(iprot);
5535               } else {
5536                 TProtocolUtil.skip(iprot, field.type);
5537               }
5538               break;
5539           }
5540           iprot.readFieldEnd();
5541         }
5542       }
5543       iprot.readStructEnd();
5544 
5545       // check for required fields of primitive type, which can't be checked in the validate method
5546       validate();
5547     }
5548 
5549     public void write(TProtocol oprot) throws TException {
5550       oprot.writeStructBegin(STRUCT_DESC);
5551 
5552       if (this.isSetIo()) {
5553         oprot.writeFieldBegin(IO_FIELD_DESC);
5554         this.io.write(oprot);
5555         oprot.writeFieldEnd();
5556       }
5557       oprot.writeFieldStop();
5558       oprot.writeStructEnd();
5559     }
5560 
5561     @Override
5562     public String toString() {
5563       StringBuilder sb = new StringBuilder("compact_result(");
5564       boolean first = true;
5565 
5566       sb.append("io:");
5567       if (this.io == null) {
5568         sb.append("null");
5569       } else {
5570         sb.append(this.io);
5571       }
5572       first = false;
5573       sb.append(")");
5574       return sb.toString();
5575     }
5576 
5577     public void validate() throws TException {
5578       // check for required fields
5579     }
5580 
5581   }
5582 
5583   public static class majorCompact_args implements TBase<majorCompact_args._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_args>   {
5584     private static final TStruct STRUCT_DESC = new TStruct("majorCompact_args");
5585 
5586     private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1);
5587 
5588     public byte[] tableNameOrRegionName;
5589 
5590     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
5591     public enum _Fields implements TFieldIdEnum {
5592       TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
5593 
5594       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5595       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5596 
5597       static {
5598         for (_Fields field : EnumSet.allOf(_Fields.class)) {
5599           byId.put((int)field._thriftId, field);
5600           byName.put(field.getFieldName(), field);
5601         }
5602       }
5603 
5604       /**
5605        * Find the _Fields constant that matches fieldId, or null if its not found.
5606        */
5607       public static _Fields findByThriftId(int fieldId) {
5608         return byId.get(fieldId);
5609       }
5610 
5611       /**
5612        * Find the _Fields constant that matches fieldId, throwing an exception
5613        * if it is not found.
5614        */
5615       public static _Fields findByThriftIdOrThrow(int fieldId) {
5616         _Fields fields = findByThriftId(fieldId);
5617         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5618         return fields;
5619       }
5620 
5621       /**
5622        * Find the _Fields constant that matches name, or null if its not found.
5623        */
5624       public static _Fields findByName(String name) {
5625         return byName.get(name);
5626       }
5627 
5628       private final short _thriftId;
5629       private final String _fieldName;
5630 
5631       _Fields(short thriftId, String fieldName) {
5632         _thriftId = thriftId;
5633         _fieldName = fieldName;
5634       }
5635 
5636       public short getThriftFieldId() {
5637         return _thriftId;
5638       }
5639 
5640       public String getFieldName() {
5641         return _fieldName;
5642       }
5643     }
5644 
5645     // isset id assignments
5646 
5647     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5648       put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT,
5649           new FieldValueMetaData(TType.STRING)));
5650     }});
5651 
5652     static {
5653       FieldMetaData.addStructMetaDataMap(majorCompact_args.class, metaDataMap);
5654     }
5655 
5656     public majorCompact_args() {
5657     }
5658 
5659     public majorCompact_args(
5660       byte[] tableNameOrRegionName)
5661     {
5662       this();
5663       this.tableNameOrRegionName = tableNameOrRegionName;
5664     }
5665 
5666     /**
5667      * Performs a deep copy on <i>other</i>.
5668      */
5669     public majorCompact_args(majorCompact_args other) {
5670       if (other.isSetTableNameOrRegionName()) {
5671         this.tableNameOrRegionName = other.tableNameOrRegionName;
5672       }
5673     }
5674 
5675     public majorCompact_args deepCopy() {
5676       return new majorCompact_args(this);
5677     }
5678 
5679     @Deprecated
5680     public majorCompact_args clone() {
5681       return new majorCompact_args(this);
5682     }
5683 
5684     public byte[] getTableNameOrRegionName() {
5685       return this.tableNameOrRegionName;
5686     }
5687 
5688     public majorCompact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
5689       this.tableNameOrRegionName = tableNameOrRegionName;
5690       return this;
5691     }
5692 
5693     public void unsetTableNameOrRegionName() {
5694       this.tableNameOrRegionName = null;
5695     }
5696 
5697     /** Returns true if field tableNameOrRegionName is set (has been asigned a value) and false otherwise */
5698     public boolean isSetTableNameOrRegionName() {
5699       return this.tableNameOrRegionName != null;
5700     }
5701 
5702     public void setTableNameOrRegionNameIsSet(boolean value) {
5703       if (!value) {
5704         this.tableNameOrRegionName = null;
5705       }
5706     }
5707 
5708     public void setFieldValue(_Fields field, Object value) {
5709       switch (field) {
5710       case TABLE_NAME_OR_REGION_NAME:
5711         if (value == null) {
5712           unsetTableNameOrRegionName();
5713         } else {
5714           setTableNameOrRegionName((byte[])value);
5715         }
5716         break;
5717 
5718       }
5719     }
5720 
5721     public void setFieldValue(int fieldID, Object value) {
5722       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5723     }
5724 
5725     public Object getFieldValue(_Fields field) {
5726       switch (field) {
5727       case TABLE_NAME_OR_REGION_NAME:
5728         return getTableNameOrRegionName();
5729 
5730       }
5731       throw new IllegalStateException();
5732     }
5733 
5734     public Object getFieldValue(int fieldId) {
5735       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5736     }
5737 
5738     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
5739     public boolean isSet(_Fields field) {
5740       switch (field) {
5741       case TABLE_NAME_OR_REGION_NAME:
5742         return isSetTableNameOrRegionName();
5743       }
5744       throw new IllegalStateException();
5745     }
5746 
5747     public boolean isSet(int fieldID) {
5748       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5749     }
5750 
5751     @Override
5752     public boolean equals(Object that) {
5753       if (that == null)
5754         return false;
5755       if (that instanceof majorCompact_args)
5756         return this.equals((majorCompact_args)that);
5757       return false;
5758     }
5759 
5760     public boolean equals(majorCompact_args that) {
5761       if (that == null)
5762         return false;
5763 
5764       boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
5765       boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
5766       if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
5767         if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
5768           return false;
5769         if (!java.util.Arrays.equals(this.tableNameOrRegionName, that.tableNameOrRegionName))
5770           return false;
5771       }
5772 
5773       return true;
5774     }
5775 
5776     @Override
5777     public int hashCode() {
5778       HashCodeBuilder builder = new HashCodeBuilder();
5779 
5780       boolean present_tableNameOrRegionName = true && (isSetTableNameOrRegionName());
5781       builder.append(present_tableNameOrRegionName);
5782       if (present_tableNameOrRegionName)
5783         builder.append(tableNameOrRegionName);
5784 
5785       return builder.toHashCode();
5786     }
5787 
5788     public int compareTo(majorCompact_args other) {
5789       if (!getClass().equals(other.getClass())) {
5790         return getClass().getName().compareTo(other.getClass().getName());
5791       }
5792 
5793       int lastComparison = 0;
5794       majorCompact_args typedOther = (majorCompact_args)other;
5795 
5796       lastComparison = Boolean.valueOf(isSetTableNameOrRegionName()).compareTo(isSetTableNameOrRegionName());
5797       if (lastComparison != 0) {
5798         return lastComparison;
5799       }
5800       lastComparison = TBaseHelper.compareTo(tableNameOrRegionName, typedOther.tableNameOrRegionName);
5801       if (lastComparison != 0) {
5802         return lastComparison;
5803       }
5804       return 0;
5805     }
5806 
5807     public void read(TProtocol iprot) throws TException {
5808       TField field;
5809       iprot.readStructBegin();
5810       while (true)
5811       {
5812         field = iprot.readFieldBegin();
5813         if (field.type == TType.STOP) {
5814           break;
5815         }
5816         _Fields fieldId = _Fields.findByThriftId(field.id);
5817         if (fieldId == null) {
5818           TProtocolUtil.skip(iprot, field.type);
5819         } else {
5820           switch (fieldId) {
5821             case TABLE_NAME_OR_REGION_NAME:
5822               if (field.type == TType.STRING) {
5823                 this.tableNameOrRegionName = iprot.readBinary();
5824               } else {
5825                 TProtocolUtil.skip(iprot, field.type);
5826               }
5827               break;
5828           }
5829           iprot.readFieldEnd();
5830         }
5831       }
5832       iprot.readStructEnd();
5833 
5834       // check for required fields of primitive type, which can't be checked in the validate method
5835       validate();
5836     }
5837 
5838     public void write(TProtocol oprot) throws TException {
5839       validate();
5840 
5841       oprot.writeStructBegin(STRUCT_DESC);
5842       if (this.tableNameOrRegionName != null) {
5843         oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
5844         oprot.writeBinary(this.tableNameOrRegionName);
5845         oprot.writeFieldEnd();
5846       }
5847       oprot.writeFieldStop();
5848       oprot.writeStructEnd();
5849     }
5850 
5851     @Override
5852     public String toString() {
5853       StringBuilder sb = new StringBuilder("majorCompact_args(");
5854       boolean first = true;
5855 
5856       sb.append("tableNameOrRegionName:");
5857       if (this.tableNameOrRegionName == null) {
5858         sb.append("null");
5859       } else {
5860         sb.append(this.tableNameOrRegionName);
5861       }
5862       first = false;
5863       sb.append(")");
5864       return sb.toString();
5865     }
5866 
5867     public void validate() throws TException {
5868       // check for required fields
5869     }
5870 
5871   }
5872 
5873   public static class majorCompact_result implements TBase<majorCompact_result._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_result>   {
5874     private static final TStruct STRUCT_DESC = new TStruct("majorCompact_result");
5875 
5876     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
5877 
5878     public IOError io;
5879 
5880     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
5881     public enum _Fields implements TFieldIdEnum {
5882       IO((short)1, "io");
5883 
5884       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5885       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5886 
5887       static {
5888         for (_Fields field : EnumSet.allOf(_Fields.class)) {
5889           byId.put((int)field._thriftId, field);
5890           byName.put(field.getFieldName(), field);
5891         }
5892       }
5893 
5894       /**
5895        * Find the _Fields constant that matches fieldId, or null if its not found.
5896        */
5897       public static _Fields findByThriftId(int fieldId) {
5898         return byId.get(fieldId);
5899       }
5900 
5901       /**
5902        * Find the _Fields constant that matches fieldId, throwing an exception
5903        * if it is not found.
5904        */
5905       public static _Fields findByThriftIdOrThrow(int fieldId) {
5906         _Fields fields = findByThriftId(fieldId);
5907         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5908         return fields;
5909       }
5910 
5911       /**
5912        * Find the _Fields constant that matches name, or null if its not found.
5913        */
5914       public static _Fields findByName(String name) {
5915         return byName.get(name);
5916       }
5917 
5918       private final short _thriftId;
5919       private final String _fieldName;
5920 
5921       _Fields(short thriftId, String fieldName) {
5922         _thriftId = thriftId;
5923         _fieldName = fieldName;
5924       }
5925 
5926       public short getThriftFieldId() {
5927         return _thriftId;
5928       }
5929 
5930       public String getFieldName() {
5931         return _fieldName;
5932       }
5933     }
5934 
5935     // isset id assignments
5936 
5937     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5938       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
5939           new FieldValueMetaData(TType.STRUCT)));
5940     }});
5941 
5942     static {
5943       FieldMetaData.addStructMetaDataMap(majorCompact_result.class, metaDataMap);
5944     }
5945 
5946     public majorCompact_result() {
5947     }
5948 
5949     public majorCompact_result(
5950       IOError io)
5951     {
5952       this();
5953       this.io = io;
5954     }
5955 
5956     /**
5957      * Performs a deep copy on <i>other</i>.
5958      */
5959     public majorCompact_result(majorCompact_result other) {
5960       if (other.isSetIo()) {
5961         this.io = new IOError(other.io);
5962       }
5963     }
5964 
5965     public majorCompact_result deepCopy() {
5966       return new majorCompact_result(this);
5967     }
5968 
5969     @Deprecated
5970     public majorCompact_result clone() {
5971       return new majorCompact_result(this);
5972     }
5973 
5974     public IOError getIo() {
5975       return this.io;
5976     }
5977 
5978     public majorCompact_result setIo(IOError io) {
5979       this.io = io;
5980       return this;
5981     }
5982 
5983     public void unsetIo() {
5984       this.io = null;
5985     }
5986 
5987     /** Returns true if field io is set (has been asigned a value) and false otherwise */
5988     public boolean isSetIo() {
5989       return this.io != null;
5990     }
5991 
5992     public void setIoIsSet(boolean value) {
5993       if (!value) {
5994         this.io = null;
5995       }
5996     }
5997 
5998     public void setFieldValue(_Fields field, Object value) {
5999       switch (field) {
6000       case IO:
6001         if (value == null) {
6002           unsetIo();
6003         } else {
6004           setIo((IOError)value);
6005         }
6006         break;
6007 
6008       }
6009     }
6010 
6011     public void setFieldValue(int fieldID, Object value) {
6012       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6013     }
6014 
6015     public Object getFieldValue(_Fields field) {
6016       switch (field) {
6017       case IO:
6018         return getIo();
6019 
6020       }
6021       throw new IllegalStateException();
6022     }
6023 
6024     public Object getFieldValue(int fieldId) {
6025       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6026     }
6027 
6028     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
6029     public boolean isSet(_Fields field) {
6030       switch (field) {
6031       case IO:
6032         return isSetIo();
6033       }
6034       throw new IllegalStateException();
6035     }
6036 
6037     public boolean isSet(int fieldID) {
6038       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6039     }
6040 
6041     @Override
6042     public boolean equals(Object that) {
6043       if (that == null)
6044         return false;
6045       if (that instanceof majorCompact_result)
6046         return this.equals((majorCompact_result)that);
6047       return false;
6048     }
6049 
6050     public boolean equals(majorCompact_result that) {
6051       if (that == null)
6052         return false;
6053 
6054       boolean this_present_io = true && this.isSetIo();
6055       boolean that_present_io = true && that.isSetIo();
6056       if (this_present_io || that_present_io) {
6057         if (!(this_present_io && that_present_io))
6058           return false;
6059         if (!this.io.equals(that.io))
6060           return false;
6061       }
6062 
6063       return true;
6064     }
6065 
6066     @Override
6067     public int hashCode() {
6068       HashCodeBuilder builder = new HashCodeBuilder();
6069 
6070       boolean present_io = true && (isSetIo());
6071       builder.append(present_io);
6072       if (present_io)
6073         builder.append(io);
6074 
6075       return builder.toHashCode();
6076     }
6077 
6078     public int compareTo(majorCompact_result other) {
6079       if (!getClass().equals(other.getClass())) {
6080         return getClass().getName().compareTo(other.getClass().getName());
6081       }
6082 
6083       int lastComparison = 0;
6084       majorCompact_result typedOther = (majorCompact_result)other;
6085 
6086       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
6087       if (lastComparison != 0) {
6088         return lastComparison;
6089       }
6090       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
6091       if (lastComparison != 0) {
6092         return lastComparison;
6093       }
6094       return 0;
6095     }
6096 
6097     public void read(TProtocol iprot) throws TException {
6098       TField field;
6099       iprot.readStructBegin();
6100       while (true)
6101       {
6102         field = iprot.readFieldBegin();
6103         if (field.type == TType.STOP) {
6104           break;
6105         }
6106         _Fields fieldId = _Fields.findByThriftId(field.id);
6107         if (fieldId == null) {
6108           TProtocolUtil.skip(iprot, field.type);
6109         } else {
6110           switch (fieldId) {
6111             case IO:
6112               if (field.type == TType.STRUCT) {
6113                 this.io = new IOError();
6114                 this.io.read(iprot);
6115               } else {
6116                 TProtocolUtil.skip(iprot, field.type);
6117               }
6118               break;
6119           }
6120           iprot.readFieldEnd();
6121         }
6122       }
6123       iprot.readStructEnd();
6124 
6125       // check for required fields of primitive type, which can't be checked in the validate method
6126       validate();
6127     }
6128 
6129     public void write(TProtocol oprot) throws TException {
6130       oprot.writeStructBegin(STRUCT_DESC);
6131 
6132       if (this.isSetIo()) {
6133         oprot.writeFieldBegin(IO_FIELD_DESC);
6134         this.io.write(oprot);
6135         oprot.writeFieldEnd();
6136       }
6137       oprot.writeFieldStop();
6138       oprot.writeStructEnd();
6139     }
6140 
6141     @Override
6142     public String toString() {
6143       StringBuilder sb = new StringBuilder("majorCompact_result(");
6144       boolean first = true;
6145 
6146       sb.append("io:");
6147       if (this.io == null) {
6148         sb.append("null");
6149       } else {
6150         sb.append(this.io);
6151       }
6152       first = false;
6153       sb.append(")");
6154       return sb.toString();
6155     }
6156 
6157     public void validate() throws TException {
6158       // check for required fields
6159     }
6160 
6161   }
6162 
6163   public static class getTableNames_args implements TBase<getTableNames_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_args>   {
6164     private static final TStruct STRUCT_DESC = new TStruct("getTableNames_args");
6165 
6166 
6167 
6168     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
6169     public enum _Fields implements TFieldIdEnum {
6170 ;
6171 
6172       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6173       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6174 
6175       static {
6176         for (_Fields field : EnumSet.allOf(_Fields.class)) {
6177           byId.put((int)field._thriftId, field);
6178           byName.put(field.getFieldName(), field);
6179         }
6180       }
6181 
6182       /**
6183        * Find the _Fields constant that matches fieldId, or null if its not found.
6184        */
6185       public static _Fields findByThriftId(int fieldId) {
6186         return byId.get(fieldId);
6187       }
6188 
6189       /**
6190        * Find the _Fields constant that matches fieldId, throwing an exception
6191        * if it is not found.
6192        */
6193       public static _Fields findByThriftIdOrThrow(int fieldId) {
6194         _Fields fields = findByThriftId(fieldId);
6195         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6196         return fields;
6197       }
6198 
6199       /**
6200        * Find the _Fields constant that matches name, or null if its not found.
6201        */
6202       public static _Fields findByName(String name) {
6203         return byName.get(name);
6204       }
6205 
6206       private final short _thriftId;
6207       private final String _fieldName;
6208 
6209       _Fields(short thriftId, String fieldName) {
6210         _thriftId = thriftId;
6211         _fieldName = fieldName;
6212       }
6213 
6214       public short getThriftFieldId() {
6215         return _thriftId;
6216       }
6217 
6218       public String getFieldName() {
6219         return _fieldName;
6220       }
6221     }
6222     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6223     }});
6224 
6225     static {
6226       FieldMetaData.addStructMetaDataMap(getTableNames_args.class, metaDataMap);
6227     }
6228 
6229     public getTableNames_args() {
6230     }
6231 
6232     /**
6233      * Performs a deep copy on <i>other</i>.
6234      */
6235     public getTableNames_args(getTableNames_args other) {
6236     }
6237 
6238     public getTableNames_args deepCopy() {
6239       return new getTableNames_args(this);
6240     }
6241 
6242     @Deprecated
6243     public getTableNames_args clone() {
6244       return new getTableNames_args(this);
6245     }
6246 
6247     public void setFieldValue(_Fields field, Object value) {
6248       switch (field) {
6249       }
6250     }
6251 
6252     public void setFieldValue(int fieldID, Object value) {
6253       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6254     }
6255 
6256     public Object getFieldValue(_Fields field) {
6257       switch (field) {
6258       }
6259       throw new IllegalStateException();
6260     }
6261 
6262     public Object getFieldValue(int fieldId) {
6263       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6264     }
6265 
6266     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
6267     public boolean isSet(_Fields field) {
6268       switch (field) {
6269       }
6270       throw new IllegalStateException();
6271     }
6272 
6273     public boolean isSet(int fieldID) {
6274       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6275     }
6276 
6277     @Override
6278     public boolean equals(Object that) {
6279       if (that == null)
6280         return false;
6281       if (that instanceof getTableNames_args)
6282         return this.equals((getTableNames_args)that);
6283       return false;
6284     }
6285 
6286     public boolean equals(getTableNames_args that) {
6287       if (that == null)
6288         return false;
6289 
6290       return true;
6291     }
6292 
6293     @Override
6294     public int hashCode() {
6295       HashCodeBuilder builder = new HashCodeBuilder();
6296 
6297       return builder.toHashCode();
6298     }
6299 
6300     public int compareTo(getTableNames_args other) {
6301       if (!getClass().equals(other.getClass())) {
6302         return getClass().getName().compareTo(other.getClass().getName());
6303       }
6304 
6305       int lastComparison = 0;
6306       getTableNames_args typedOther = (getTableNames_args)other;
6307 
6308       return 0;
6309     }
6310 
6311     public void read(TProtocol iprot) throws TException {
6312       TField field;
6313       iprot.readStructBegin();
6314       while (true)
6315       {
6316         field = iprot.readFieldBegin();
6317         if (field.type == TType.STOP) {
6318           break;
6319         }
6320         _Fields fieldId = _Fields.findByThriftId(field.id);
6321         if (fieldId == null) {
6322           TProtocolUtil.skip(iprot, field.type);
6323         } else {
6324           switch (fieldId) {
6325           }
6326           iprot.readFieldEnd();
6327         }
6328       }
6329       iprot.readStructEnd();
6330 
6331       // check for required fields of primitive type, which can't be checked in the validate method
6332       validate();
6333     }
6334 
6335     public void write(TProtocol oprot) throws TException {
6336       validate();
6337 
6338       oprot.writeStructBegin(STRUCT_DESC);
6339       oprot.writeFieldStop();
6340       oprot.writeStructEnd();
6341     }
6342 
6343     @Override
6344     public String toString() {
6345       StringBuilder sb = new StringBuilder("getTableNames_args(");
6346       boolean first = true;
6347 
6348       sb.append(")");
6349       return sb.toString();
6350     }
6351 
6352     public void validate() throws TException {
6353       // check for required fields
6354     }
6355 
6356   }
6357 
6358   public static class getTableNames_result implements TBase<getTableNames_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_result>   {
6359     private static final TStruct STRUCT_DESC = new TStruct("getTableNames_result");
6360 
6361     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
6362     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
6363 
6364     public List<byte[]> success;
6365     public IOError io;
6366 
6367     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
6368     public enum _Fields implements TFieldIdEnum {
6369       SUCCESS((short)0, "success"),
6370       IO((short)1, "io");
6371 
6372       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6373       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6374 
6375       static {
6376         for (_Fields field : EnumSet.allOf(_Fields.class)) {
6377           byId.put((int)field._thriftId, field);
6378           byName.put(field.getFieldName(), field);
6379         }
6380       }
6381 
6382       /**
6383        * Find the _Fields constant that matches fieldId, or null if its not found.
6384        */
6385       public static _Fields findByThriftId(int fieldId) {
6386         return byId.get(fieldId);
6387       }
6388 
6389       /**
6390        * Find the _Fields constant that matches fieldId, throwing an exception
6391        * if it is not found.
6392        */
6393       public static _Fields findByThriftIdOrThrow(int fieldId) {
6394         _Fields fields = findByThriftId(fieldId);
6395         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6396         return fields;
6397       }
6398 
6399       /**
6400        * Find the _Fields constant that matches name, or null if its not found.
6401        */
6402       public static _Fields findByName(String name) {
6403         return byName.get(name);
6404       }
6405 
6406       private final short _thriftId;
6407       private final String _fieldName;
6408 
6409       _Fields(short thriftId, String fieldName) {
6410         _thriftId = thriftId;
6411         _fieldName = fieldName;
6412       }
6413 
6414       public short getThriftFieldId() {
6415         return _thriftId;
6416       }
6417 
6418       public String getFieldName() {
6419         return _fieldName;
6420       }
6421     }
6422 
6423     // isset id assignments
6424 
6425     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6426       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
6427           new ListMetaData(TType.LIST,
6428               new FieldValueMetaData(TType.STRING))));
6429       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
6430           new FieldValueMetaData(TType.STRUCT)));
6431     }});
6432 
6433     static {
6434       FieldMetaData.addStructMetaDataMap(getTableNames_result.class, metaDataMap);
6435     }
6436 
6437     public getTableNames_result() {
6438     }
6439 
6440     public getTableNames_result(
6441       List<byte[]> success,
6442       IOError io)
6443     {
6444       this();
6445       this.success = success;
6446       this.io = io;
6447     }
6448 
6449     /**
6450      * Performs a deep copy on <i>other</i>.
6451      */
6452     public getTableNames_result(getTableNames_result other) {
6453       if (other.isSetSuccess()) {
6454         List<byte[]> __this__success = new ArrayList<byte[]>();
6455         for (byte[] other_element : other.success) {
6456           __this__success.add(other_element);
6457         }
6458         this.success = __this__success;
6459       }
6460       if (other.isSetIo()) {
6461         this.io = new IOError(other.io);
6462       }
6463     }
6464 
6465     public getTableNames_result deepCopy() {
6466       return new getTableNames_result(this);
6467     }
6468 
6469     @Deprecated
6470     public getTableNames_result clone() {
6471       return new getTableNames_result(this);
6472     }
6473 
6474     public int getSuccessSize() {
6475       return (this.success == null) ? 0 : this.success.size();
6476     }
6477 
6478     public java.util.Iterator<byte[]> getSuccessIterator() {
6479       return (this.success == null) ? null : this.success.iterator();
6480     }
6481 
6482     public void addToSuccess(byte[] elem) {
6483       if (this.success == null) {
6484         this.success = new ArrayList<byte[]>();
6485       }
6486       this.success.add(elem);
6487     }
6488 
6489     public List<byte[]> getSuccess() {
6490       return this.success;
6491     }
6492 
6493     public getTableNames_result setSuccess(List<byte[]> success) {
6494       this.success = success;
6495       return this;
6496     }
6497 
6498     public void unsetSuccess() {
6499       this.success = null;
6500     }
6501 
6502     /** Returns true if field success is set (has been asigned a value) and false otherwise */
6503     public boolean isSetSuccess() {
6504       return this.success != null;
6505     }
6506 
6507     public void setSuccessIsSet(boolean value) {
6508       if (!value) {
6509         this.success = null;
6510       }
6511     }
6512 
6513     public IOError getIo() {
6514       return this.io;
6515     }
6516 
6517     public getTableNames_result setIo(IOError io) {
6518       this.io = io;
6519       return this;
6520     }
6521 
6522     public void unsetIo() {
6523       this.io = null;
6524     }
6525 
6526     /** Returns true if field io is set (has been asigned a value) and false otherwise */
6527     public boolean isSetIo() {
6528       return this.io != null;
6529     }
6530 
6531     public void setIoIsSet(boolean value) {
6532       if (!value) {
6533         this.io = null;
6534       }
6535     }
6536 
6537     public void setFieldValue(_Fields field, Object value) {
6538       switch (field) {
6539       case SUCCESS:
6540         if (value == null) {
6541           unsetSuccess();
6542         } else {
6543           setSuccess((List<byte[]>)value);
6544         }
6545         break;
6546 
6547       case IO:
6548         if (value == null) {
6549           unsetIo();
6550         } else {
6551           setIo((IOError)value);
6552         }
6553         break;
6554 
6555       }
6556     }
6557 
6558     public void setFieldValue(int fieldID, Object value) {
6559       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6560     }
6561 
6562     public Object getFieldValue(_Fields field) {
6563       switch (field) {
6564       case SUCCESS:
6565         return getSuccess();
6566 
6567       case IO:
6568         return getIo();
6569 
6570       }
6571       throw new IllegalStateException();
6572     }
6573 
6574     public Object getFieldValue(int fieldId) {
6575       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6576     }
6577 
6578     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
6579     public boolean isSet(_Fields field) {
6580       switch (field) {
6581       case SUCCESS:
6582         return isSetSuccess();
6583       case IO:
6584         return isSetIo();
6585       }
6586       throw new IllegalStateException();
6587     }
6588 
6589     public boolean isSet(int fieldID) {
6590       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6591     }
6592 
6593     @Override
6594     public boolean equals(Object that) {
6595       if (that == null)
6596         return false;
6597       if (that instanceof getTableNames_result)
6598         return this.equals((getTableNames_result)that);
6599       return false;
6600     }
6601 
6602     public boolean equals(getTableNames_result that) {
6603       if (that == null)
6604         return false;
6605 
6606       boolean this_present_success = true && this.isSetSuccess();
6607       boolean that_present_success = true && that.isSetSuccess();
6608       if (this_present_success || that_present_success) {
6609         if (!(this_present_success && that_present_success))
6610           return false;
6611         if (!this.success.equals(that.success))
6612           return false;
6613       }
6614 
6615       boolean this_present_io = true && this.isSetIo();
6616       boolean that_present_io = true && that.isSetIo();
6617       if (this_present_io || that_present_io) {
6618         if (!(this_present_io && that_present_io))
6619           return false;
6620         if (!this.io.equals(that.io))
6621           return false;
6622       }
6623 
6624       return true;
6625     }
6626 
6627     @Override
6628     public int hashCode() {
6629       HashCodeBuilder builder = new HashCodeBuilder();
6630 
6631       boolean present_success = true && (isSetSuccess());
6632       builder.append(present_success);
6633       if (present_success)
6634         builder.append(success);
6635 
6636       boolean present_io = true && (isSetIo());
6637       builder.append(present_io);
6638       if (present_io)
6639         builder.append(io);
6640 
6641       return builder.toHashCode();
6642     }
6643 
6644     public int compareTo(getTableNames_result other) {
6645       if (!getClass().equals(other.getClass())) {
6646         return getClass().getName().compareTo(other.getClass().getName());
6647       }
6648 
6649       int lastComparison = 0;
6650       getTableNames_result typedOther = (getTableNames_result)other;
6651 
6652       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
6653       if (lastComparison != 0) {
6654         return lastComparison;
6655       }
6656       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
6657       if (lastComparison != 0) {
6658         return lastComparison;
6659       }
6660       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
6661       if (lastComparison != 0) {
6662         return lastComparison;
6663       }
6664       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
6665       if (lastComparison != 0) {
6666         return lastComparison;
6667       }
6668       return 0;
6669     }
6670 
6671     public void read(TProtocol iprot) throws TException {
6672       TField field;
6673       iprot.readStructBegin();
6674       while (true)
6675       {
6676         field = iprot.readFieldBegin();
6677         if (field.type == TType.STOP) {
6678           break;
6679         }
6680         _Fields fieldId = _Fields.findByThriftId(field.id);
6681         if (fieldId == null) {
6682           TProtocolUtil.skip(iprot, field.type);
6683         } else {
6684           switch (fieldId) {
6685             case SUCCESS:
6686               if (field.type == TType.LIST) {
6687                 {
6688                   TList _list9 = iprot.readListBegin();
6689                   this.success = new ArrayList<byte[]>(_list9.size);
6690                   for (int _i10 = 0; _i10 < _list9.size; ++_i10)
6691                   {
6692                     byte[] _elem11;
6693                     _elem11 = iprot.readBinary();
6694                     this.success.add(_elem11);
6695                   }
6696                   iprot.readListEnd();
6697                 }
6698               } else {
6699                 TProtocolUtil.skip(iprot, field.type);
6700               }
6701               break;
6702             case IO:
6703               if (field.type == TType.STRUCT) {
6704                 this.io = new IOError();
6705                 this.io.read(iprot);
6706               } else {
6707                 TProtocolUtil.skip(iprot, field.type);
6708               }
6709               break;
6710           }
6711           iprot.readFieldEnd();
6712         }
6713       }
6714       iprot.readStructEnd();
6715 
6716       // check for required fields of primitive type, which can't be checked in the validate method
6717       validate();
6718     }
6719 
6720     public void write(TProtocol oprot) throws TException {
6721       oprot.writeStructBegin(STRUCT_DESC);
6722 
6723       if (this.isSetSuccess()) {
6724         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6725         {
6726           oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
6727           for (byte[] _iter12 : this.success)
6728           {
6729             oprot.writeBinary(_iter12);
6730           }
6731           oprot.writeListEnd();
6732         }
6733         oprot.writeFieldEnd();
6734       } else if (this.isSetIo()) {
6735         oprot.writeFieldBegin(IO_FIELD_DESC);
6736         this.io.write(oprot);
6737         oprot.writeFieldEnd();
6738       }
6739       oprot.writeFieldStop();
6740       oprot.writeStructEnd();
6741     }
6742 
6743     @Override
6744     public String toString() {
6745       StringBuilder sb = new StringBuilder("getTableNames_result(");
6746       boolean first = true;
6747 
6748       sb.append("success:");
6749       if (this.success == null) {
6750         sb.append("null");
6751       } else {
6752         sb.append(this.success);
6753       }
6754       first = false;
6755       if (!first) sb.append(", ");
6756       sb.append("io:");
6757       if (this.io == null) {
6758         sb.append("null");
6759       } else {
6760         sb.append(this.io);
6761       }
6762       first = false;
6763       sb.append(")");
6764       return sb.toString();
6765     }
6766 
6767     public void validate() throws TException {
6768       // check for required fields
6769     }
6770 
6771   }
6772 
6773   public static class getColumnDescriptors_args implements TBase<getColumnDescriptors_args._Fields>, java.io.Serializable, Cloneable, Comparable<getColumnDescriptors_args>   {
6774     private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_args");
6775 
6776     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
6777 
6778     /**
6779      * table name
6780      */
6781     public byte[] tableName;
6782 
6783     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
6784     public enum _Fields implements TFieldIdEnum {
6785       /**
6786        * table name
6787        */
6788       TABLE_NAME((short)1, "tableName");
6789 
6790       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6791       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6792 
6793       static {
6794         for (_Fields field : EnumSet.allOf(_Fields.class)) {
6795           byId.put((int)field._thriftId, field);
6796           byName.put(field.getFieldName(), field);
6797         }
6798       }
6799 
6800       /**
6801        * Find the _Fields constant that matches fieldId, or null if its not found.
6802        */
6803       public static _Fields findByThriftId(int fieldId) {
6804         return byId.get(fieldId);
6805       }
6806 
6807       /**
6808        * Find the _Fields constant that matches fieldId, throwing an exception
6809        * if it is not found.
6810        */
6811       public static _Fields findByThriftIdOrThrow(int fieldId) {
6812         _Fields fields = findByThriftId(fieldId);
6813         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6814         return fields;
6815       }
6816 
6817       /**
6818        * Find the _Fields constant that matches name, or null if its not found.
6819        */
6820       public static _Fields findByName(String name) {
6821         return byName.get(name);
6822       }
6823 
6824       private final short _thriftId;
6825       private final String _fieldName;
6826 
6827       _Fields(short thriftId, String fieldName) {
6828         _thriftId = thriftId;
6829         _fieldName = fieldName;
6830       }
6831 
6832       public short getThriftFieldId() {
6833         return _thriftId;
6834       }
6835 
6836       public String getFieldName() {
6837         return _fieldName;
6838       }
6839     }
6840 
6841     // isset id assignments
6842 
6843     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6844       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
6845           new FieldValueMetaData(TType.STRING)));
6846     }});
6847 
6848     static {
6849       FieldMetaData.addStructMetaDataMap(getColumnDescriptors_args.class, metaDataMap);
6850     }
6851 
6852     public getColumnDescriptors_args() {
6853     }
6854 
6855     public getColumnDescriptors_args(
6856       byte[] tableName)
6857     {
6858       this();
6859       this.tableName = tableName;
6860     }
6861 
6862     /**
6863      * Performs a deep copy on <i>other</i>.
6864      */
6865     public getColumnDescriptors_args(getColumnDescriptors_args other) {
6866       if (other.isSetTableName()) {
6867         this.tableName = other.tableName;
6868       }
6869     }
6870 
6871     public getColumnDescriptors_args deepCopy() {
6872       return new getColumnDescriptors_args(this);
6873     }
6874 
6875     @Deprecated
6876     public getColumnDescriptors_args clone() {
6877       return new getColumnDescriptors_args(this);
6878     }
6879 
6880     /**
6881      * table name
6882      */
6883     public byte[] getTableName() {
6884       return this.tableName;
6885     }
6886 
6887     /**
6888      * table name
6889      */
6890     public getColumnDescriptors_args setTableName(byte[] tableName) {
6891       this.tableName = tableName;
6892       return this;
6893     }
6894 
6895     public void unsetTableName() {
6896       this.tableName = null;
6897     }
6898 
6899     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
6900     public boolean isSetTableName() {
6901       return this.tableName != null;
6902     }
6903 
6904     public void setTableNameIsSet(boolean value) {
6905       if (!value) {
6906         this.tableName = null;
6907       }
6908     }
6909 
6910     public void setFieldValue(_Fields field, Object value) {
6911       switch (field) {
6912       case TABLE_NAME:
6913         if (value == null) {
6914           unsetTableName();
6915         } else {
6916           setTableName((byte[])value);
6917         }
6918         break;
6919 
6920       }
6921     }
6922 
6923     public void setFieldValue(int fieldID, Object value) {
6924       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6925     }
6926 
6927     public Object getFieldValue(_Fields field) {
6928       switch (field) {
6929       case TABLE_NAME:
6930         return getTableName();
6931 
6932       }
6933       throw new IllegalStateException();
6934     }
6935 
6936     public Object getFieldValue(int fieldId) {
6937       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6938     }
6939 
6940     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
6941     public boolean isSet(_Fields field) {
6942       switch (field) {
6943       case TABLE_NAME:
6944         return isSetTableName();
6945       }
6946       throw new IllegalStateException();
6947     }
6948 
6949     public boolean isSet(int fieldID) {
6950       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6951     }
6952 
6953     @Override
6954     public boolean equals(Object that) {
6955       if (that == null)
6956         return false;
6957       if (that instanceof getColumnDescriptors_args)
6958         return this.equals((getColumnDescriptors_args)that);
6959       return false;
6960     }
6961 
6962     public boolean equals(getColumnDescriptors_args that) {
6963       if (that == null)
6964         return false;
6965 
6966       boolean this_present_tableName = true && this.isSetTableName();
6967       boolean that_present_tableName = true && that.isSetTableName();
6968       if (this_present_tableName || that_present_tableName) {
6969         if (!(this_present_tableName && that_present_tableName))
6970           return false;
6971         if (!java.util.Arrays.equals(this.tableName, that.tableName))
6972           return false;
6973       }
6974 
6975       return true;
6976     }
6977 
6978     @Override
6979     public int hashCode() {
6980       HashCodeBuilder builder = new HashCodeBuilder();
6981 
6982       boolean present_tableName = true && (isSetTableName());
6983       builder.append(present_tableName);
6984       if (present_tableName)
6985         builder.append(tableName);
6986 
6987       return builder.toHashCode();
6988     }
6989 
6990     public int compareTo(getColumnDescriptors_args other) {
6991       if (!getClass().equals(other.getClass())) {
6992         return getClass().getName().compareTo(other.getClass().getName());
6993       }
6994 
6995       int lastComparison = 0;
6996       getColumnDescriptors_args typedOther = (getColumnDescriptors_args)other;
6997 
6998       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
6999       if (lastComparison != 0) {
7000         return lastComparison;
7001       }
7002       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
7003       if (lastComparison != 0) {
7004         return lastComparison;
7005       }
7006       return 0;
7007     }
7008 
7009     public void read(TProtocol iprot) throws TException {
7010       TField field;
7011       iprot.readStructBegin();
7012       while (true)
7013       {
7014         field = iprot.readFieldBegin();
7015         if (field.type == TType.STOP) {
7016           break;
7017         }
7018         _Fields fieldId = _Fields.findByThriftId(field.id);
7019         if (fieldId == null) {
7020           TProtocolUtil.skip(iprot, field.type);
7021         } else {
7022           switch (fieldId) {
7023             case TABLE_NAME:
7024               if (field.type == TType.STRING) {
7025                 this.tableName = iprot.readBinary();
7026               } else {
7027                 TProtocolUtil.skip(iprot, field.type);
7028               }
7029               break;
7030           }
7031           iprot.readFieldEnd();
7032         }
7033       }
7034       iprot.readStructEnd();
7035 
7036       // check for required fields of primitive type, which can't be checked in the validate method
7037       validate();
7038     }
7039 
7040     public void write(TProtocol oprot) throws TException {
7041       validate();
7042 
7043       oprot.writeStructBegin(STRUCT_DESC);
7044       if (this.tableName != null) {
7045         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
7046         oprot.writeBinary(this.tableName);
7047         oprot.writeFieldEnd();
7048       }
7049       oprot.writeFieldStop();
7050       oprot.writeStructEnd();
7051     }
7052 
7053     @Override
7054     public String toString() {
7055       StringBuilder sb = new StringBuilder("getColumnDescriptors_args(");
7056       boolean first = true;
7057 
7058       sb.append("tableName:");
7059       if (this.tableName == null) {
7060         sb.append("null");
7061       } else {
7062         sb.append(this.tableName);
7063       }
7064       first = false;
7065       sb.append(")");
7066       return sb.toString();
7067     }
7068 
7069     public void validate() throws TException {
7070       // check for required fields
7071     }
7072 
7073   }
7074 
7075   public static class getColumnDescriptors_result implements TBase<getColumnDescriptors_result._Fields>, java.io.Serializable, Cloneable   {
7076     private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_result");
7077 
7078     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.MAP, (short)0);
7079     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
7080 
7081     public Map<byte[],ColumnDescriptor> success;
7082     public IOError io;
7083 
7084     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
7085     public enum _Fields implements TFieldIdEnum {
7086       SUCCESS((short)0, "success"),
7087       IO((short)1, "io");
7088 
7089       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7090       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7091 
7092       static {
7093         for (_Fields field : EnumSet.allOf(_Fields.class)) {
7094           byId.put((int)field._thriftId, field);
7095           byName.put(field.getFieldName(), field);
7096         }
7097       }
7098 
7099       /**
7100        * Find the _Fields constant that matches fieldId, or null if its not found.
7101        */
7102       public static _Fields findByThriftId(int fieldId) {
7103         return byId.get(fieldId);
7104       }
7105 
7106       /**
7107        * Find the _Fields constant that matches fieldId, throwing an exception
7108        * if it is not found.
7109        */
7110       public static _Fields findByThriftIdOrThrow(int fieldId) {
7111         _Fields fields = findByThriftId(fieldId);
7112         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7113         return fields;
7114       }
7115 
7116       /**
7117        * Find the _Fields constant that matches name, or null if its not found.
7118        */
7119       public static _Fields findByName(String name) {
7120         return byName.get(name);
7121       }
7122 
7123       private final short _thriftId;
7124       private final String _fieldName;
7125 
7126       _Fields(short thriftId, String fieldName) {
7127         _thriftId = thriftId;
7128         _fieldName = fieldName;
7129       }
7130 
7131       public short getThriftFieldId() {
7132         return _thriftId;
7133       }
7134 
7135       public String getFieldName() {
7136         return _fieldName;
7137       }
7138     }
7139 
7140     // isset id assignments
7141 
7142     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7143       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
7144           new MapMetaData(TType.MAP,
7145               new FieldValueMetaData(TType.STRING),
7146               new StructMetaData(TType.STRUCT, ColumnDescriptor.class))));
7147       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
7148           new FieldValueMetaData(TType.STRUCT)));
7149     }});
7150 
7151     static {
7152       FieldMetaData.addStructMetaDataMap(getColumnDescriptors_result.class, metaDataMap);
7153     }
7154 
7155     public getColumnDescriptors_result() {
7156     }
7157 
7158     public getColumnDescriptors_result(
7159       Map<byte[],ColumnDescriptor> success,
7160       IOError io)
7161     {
7162       this();
7163       this.success = success;
7164       this.io = io;
7165     }
7166 
7167     /**
7168      * Performs a deep copy on <i>other</i>.
7169      */
7170     public getColumnDescriptors_result(getColumnDescriptors_result other) {
7171       if (other.isSetSuccess()) {
7172         Map<byte[],ColumnDescriptor> __this__success = new HashMap<byte[],ColumnDescriptor>();
7173         for (Map.Entry<byte[], ColumnDescriptor> other_element : other.success.entrySet()) {
7174 
7175           byte[] other_element_key = other_element.getKey();
7176           ColumnDescriptor other_element_value = other_element.getValue();
7177 
7178           byte[] __this__success_copy_key = other_element_key;
7179 
7180           ColumnDescriptor __this__success_copy_value = new ColumnDescriptor(other_element_value);
7181 
7182           __this__success.put(__this__success_copy_key, __this__success_copy_value);
7183         }
7184         this.success = __this__success;
7185       }
7186       if (other.isSetIo()) {
7187         this.io = new IOError(other.io);
7188       }
7189     }
7190 
7191     public getColumnDescriptors_result deepCopy() {
7192       return new getColumnDescriptors_result(this);
7193     }
7194 
7195     @Deprecated
7196     public getColumnDescriptors_result clone() {
7197       return new getColumnDescriptors_result(this);
7198     }
7199 
7200     public int getSuccessSize() {
7201       return (this.success == null) ? 0 : this.success.size();
7202     }
7203 
7204     public void putToSuccess(byte[] key, ColumnDescriptor val) {
7205       if (this.success == null) {
7206         this.success = new HashMap<byte[],ColumnDescriptor>();
7207       }
7208       this.success.put(key, val);
7209     }
7210 
7211     public Map<byte[],ColumnDescriptor> getSuccess() {
7212       return this.success;
7213     }
7214 
7215     public getColumnDescriptors_result setSuccess(Map<byte[],ColumnDescriptor> success) {
7216       this.success = success;
7217       return this;
7218     }
7219 
7220     public void unsetSuccess() {
7221       this.success = null;
7222     }
7223 
7224     /** Returns true if field success is set (has been asigned a value) and false otherwise */
7225     public boolean isSetSuccess() {
7226       return this.success != null;
7227     }
7228 
7229     public void setSuccessIsSet(boolean value) {
7230       if (!value) {
7231         this.success = null;
7232       }
7233     }
7234 
7235     public IOError getIo() {
7236       return this.io;
7237     }
7238 
7239     public getColumnDescriptors_result setIo(IOError io) {
7240       this.io = io;
7241       return this;
7242     }
7243 
7244     public void unsetIo() {
7245       this.io = null;
7246     }
7247 
7248     /** Returns true if field io is set (has been asigned a value) and false otherwise */
7249     public boolean isSetIo() {
7250       return this.io != null;
7251     }
7252 
7253     public void setIoIsSet(boolean value) {
7254       if (!value) {
7255         this.io = null;
7256       }
7257     }
7258 
7259     public void setFieldValue(_Fields field, Object value) {
7260       switch (field) {
7261       case SUCCESS:
7262         if (value == null) {
7263           unsetSuccess();
7264         } else {
7265           setSuccess((Map<byte[],ColumnDescriptor>)value);
7266         }
7267         break;
7268 
7269       case IO:
7270         if (value == null) {
7271           unsetIo();
7272         } else {
7273           setIo((IOError)value);
7274         }
7275         break;
7276 
7277       }
7278     }
7279 
7280     public void setFieldValue(int fieldID, Object value) {
7281       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7282     }
7283 
7284     public Object getFieldValue(_Fields field) {
7285       switch (field) {
7286       case SUCCESS:
7287         return getSuccess();
7288 
7289       case IO:
7290         return getIo();
7291 
7292       }
7293       throw new IllegalStateException();
7294     }
7295 
7296     public Object getFieldValue(int fieldId) {
7297       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7298     }
7299 
7300     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
7301     public boolean isSet(_Fields field) {
7302       switch (field) {
7303       case SUCCESS:
7304         return isSetSuccess();
7305       case IO:
7306         return isSetIo();
7307       }
7308       throw new IllegalStateException();
7309     }
7310 
7311     public boolean isSet(int fieldID) {
7312       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
7313     }
7314 
7315     @Override
7316     public boolean equals(Object that) {
7317       if (that == null)
7318         return false;
7319       if (that instanceof getColumnDescriptors_result)
7320         return this.equals((getColumnDescriptors_result)that);
7321       return false;
7322     }
7323 
7324     public boolean equals(getColumnDescriptors_result that) {
7325       if (that == null)
7326         return false;
7327 
7328       boolean this_present_success = true && this.isSetSuccess();
7329       boolean that_present_success = true && that.isSetSuccess();
7330       if (this_present_success || that_present_success) {
7331         if (!(this_present_success && that_present_success))
7332           return false;
7333         if (!this.success.equals(that.success))
7334           return false;
7335       }
7336 
7337       boolean this_present_io = true && this.isSetIo();
7338       boolean that_present_io = true && that.isSetIo();
7339       if (this_present_io || that_present_io) {
7340         if (!(this_present_io && that_present_io))
7341           return false;
7342         if (!this.io.equals(that.io))
7343           return false;
7344       }
7345 
7346       return true;
7347     }
7348 
7349     @Override
7350     public int hashCode() {
7351       HashCodeBuilder builder = new HashCodeBuilder();
7352 
7353       boolean present_success = true && (isSetSuccess());
7354       builder.append(present_success);
7355       if (present_success)
7356         builder.append(success);
7357 
7358       boolean present_io = true && (isSetIo());
7359       builder.append(present_io);
7360       if (present_io)
7361         builder.append(io);
7362 
7363       return builder.toHashCode();
7364     }
7365 
7366     public void read(TProtocol iprot) throws TException {
7367       TField field;
7368       iprot.readStructBegin();
7369       while (true)
7370       {
7371         field = iprot.readFieldBegin();
7372         if (field.type == TType.STOP) {
7373           break;
7374         }
7375         _Fields fieldId = _Fields.findByThriftId(field.id);
7376         if (fieldId == null) {
7377           TProtocolUtil.skip(iprot, field.type);
7378         } else {
7379           switch (fieldId) {
7380             case SUCCESS:
7381               if (field.type == TType.MAP) {
7382                 {
7383                   TMap _map13 = iprot.readMapBegin();
7384                   this.success = new HashMap<byte[],ColumnDescriptor>(2*_map13.size);
7385                   for (int _i14 = 0; _i14 < _map13.size; ++_i14)
7386                   {
7387                     byte[] _key15;
7388                     ColumnDescriptor _val16;
7389                     _key15 = iprot.readBinary();
7390                     _val16 = new ColumnDescriptor();
7391                     _val16.read(iprot);
7392                     this.success.put(_key15, _val16);
7393                   }
7394                   iprot.readMapEnd();
7395                 }
7396               } else {
7397                 TProtocolUtil.skip(iprot, field.type);
7398               }
7399               break;
7400             case IO:
7401               if (field.type == TType.STRUCT) {
7402                 this.io = new IOError();
7403                 this.io.read(iprot);
7404               } else {
7405                 TProtocolUtil.skip(iprot, field.type);
7406               }
7407               break;
7408           }
7409           iprot.readFieldEnd();
7410         }
7411       }
7412       iprot.readStructEnd();
7413 
7414       // check for required fields of primitive type, which can't be checked in the validate method
7415       validate();
7416     }
7417 
7418     public void write(TProtocol oprot) throws TException {
7419       oprot.writeStructBegin(STRUCT_DESC);
7420 
7421       if (this.isSetSuccess()) {
7422         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
7423         {
7424           oprot.writeMapBegin(new TMap(TType.STRING, TType.STRUCT, this.success.size()));
7425           for (Map.Entry<byte[], ColumnDescriptor> _iter17 : this.success.entrySet())
7426           {
7427             oprot.writeBinary(_iter17.getKey());
7428             _iter17.getValue().write(oprot);
7429           }
7430           oprot.writeMapEnd();
7431         }
7432         oprot.writeFieldEnd();
7433       } else if (this.isSetIo()) {
7434         oprot.writeFieldBegin(IO_FIELD_DESC);
7435         this.io.write(oprot);
7436         oprot.writeFieldEnd();
7437       }
7438       oprot.writeFieldStop();
7439       oprot.writeStructEnd();
7440     }
7441 
7442     @Override
7443     public String toString() {
7444       StringBuilder sb = new StringBuilder("getColumnDescriptors_result(");
7445       boolean first = true;
7446 
7447       sb.append("success:");
7448       if (this.success == null) {
7449         sb.append("null");
7450       } else {
7451         sb.append(this.success);
7452       }
7453       first = false;
7454       if (!first) sb.append(", ");
7455       sb.append("io:");
7456       if (this.io == null) {
7457         sb.append("null");
7458       } else {
7459         sb.append(this.io);
7460       }
7461       first = false;
7462       sb.append(")");
7463       return sb.toString();
7464     }
7465 
7466     public void validate() throws TException {
7467       // check for required fields
7468     }
7469 
7470   }
7471 
7472   public static class getTableRegions_args implements TBase<getTableRegions_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_args>   {
7473     private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_args");
7474 
7475     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
7476 
7477     /**
7478      * table name
7479      */
7480     public byte[] tableName;
7481 
7482     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
7483     public enum _Fields implements TFieldIdEnum {
7484       /**
7485        * table name
7486        */
7487       TABLE_NAME((short)1, "tableName");
7488 
7489       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7490       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7491 
7492       static {
7493         for (_Fields field : EnumSet.allOf(_Fields.class)) {
7494           byId.put((int)field._thriftId, field);
7495           byName.put(field.getFieldName(), field);
7496         }
7497       }
7498 
7499       /**
7500        * Find the _Fields constant that matches fieldId, or null if its not found.
7501        */
7502       public static _Fields findByThriftId(int fieldId) {
7503         return byId.get(fieldId);
7504       }
7505 
7506       /**
7507        * Find the _Fields constant that matches fieldId, throwing an exception
7508        * if it is not found.
7509        */
7510       public static _Fields findByThriftIdOrThrow(int fieldId) {
7511         _Fields fields = findByThriftId(fieldId);
7512         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7513         return fields;
7514       }
7515 
7516       /**
7517        * Find the _Fields constant that matches name, or null if its not found.
7518        */
7519       public static _Fields findByName(String name) {
7520         return byName.get(name);
7521       }
7522 
7523       private final short _thriftId;
7524       private final String _fieldName;
7525 
7526       _Fields(short thriftId, String fieldName) {
7527         _thriftId = thriftId;
7528         _fieldName = fieldName;
7529       }
7530 
7531       public short getThriftFieldId() {
7532         return _thriftId;
7533       }
7534 
7535       public String getFieldName() {
7536         return _fieldName;
7537       }
7538     }
7539 
7540     // isset id assignments
7541 
7542     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7543       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
7544           new FieldValueMetaData(TType.STRING)));
7545     }});
7546 
7547     static {
7548       FieldMetaData.addStructMetaDataMap(getTableRegions_args.class, metaDataMap);
7549     }
7550 
7551     public getTableRegions_args() {
7552     }
7553 
7554     public getTableRegions_args(
7555       byte[] tableName)
7556     {
7557       this();
7558       this.tableName = tableName;
7559     }
7560 
7561     /**
7562      * Performs a deep copy on <i>other</i>.
7563      */
7564     public getTableRegions_args(getTableRegions_args other) {
7565       if (other.isSetTableName()) {
7566         this.tableName = other.tableName;
7567       }
7568     }
7569 
7570     public getTableRegions_args deepCopy() {
7571       return new getTableRegions_args(this);
7572     }
7573 
7574     @Deprecated
7575     public getTableRegions_args clone() {
7576       return new getTableRegions_args(this);
7577     }
7578 
7579     /**
7580      * table name
7581      */
7582     public byte[] getTableName() {
7583       return this.tableName;
7584     }
7585 
7586     /**
7587      * table name
7588      */
7589     public getTableRegions_args setTableName(byte[] tableName) {
7590       this.tableName = tableName;
7591       return this;
7592     }
7593 
7594     public void unsetTableName() {
7595       this.tableName = null;
7596     }
7597 
7598     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
7599     public boolean isSetTableName() {
7600       return this.tableName != null;
7601     }
7602 
7603     public void setTableNameIsSet(boolean value) {
7604       if (!value) {
7605         this.tableName = null;
7606       }
7607     }
7608 
7609     public void setFieldValue(_Fields field, Object value) {
7610       switch (field) {
7611       case TABLE_NAME:
7612         if (value == null) {
7613           unsetTableName();
7614         } else {
7615           setTableName((byte[])value);
7616         }
7617         break;
7618 
7619       }
7620     }
7621 
7622     public void setFieldValue(int fieldID, Object value) {
7623       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7624     }
7625 
7626     public Object getFieldValue(_Fields field) {
7627       switch (field) {
7628       case TABLE_NAME:
7629         return getTableName();
7630 
7631       }
7632       throw new IllegalStateException();
7633     }
7634 
7635     public Object getFieldValue(int fieldId) {
7636       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7637     }
7638 
7639     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
7640     public boolean isSet(_Fields field) {
7641       switch (field) {
7642       case TABLE_NAME:
7643         return isSetTableName();
7644       }
7645       throw new IllegalStateException();
7646     }
7647 
7648     public boolean isSet(int fieldID) {
7649       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
7650     }
7651 
7652     @Override
7653     public boolean equals(Object that) {
7654       if (that == null)
7655         return false;
7656       if (that instanceof getTableRegions_args)
7657         return this.equals((getTableRegions_args)that);
7658       return false;
7659     }
7660 
7661     public boolean equals(getTableRegions_args that) {
7662       if (that == null)
7663         return false;
7664 
7665       boolean this_present_tableName = true && this.isSetTableName();
7666       boolean that_present_tableName = true && that.isSetTableName();
7667       if (this_present_tableName || that_present_tableName) {
7668         if (!(this_present_tableName && that_present_tableName))
7669           return false;
7670         if (!java.util.Arrays.equals(this.tableName, that.tableName))
7671           return false;
7672       }
7673 
7674       return true;
7675     }
7676 
7677     @Override
7678     public int hashCode() {
7679       HashCodeBuilder builder = new HashCodeBuilder();
7680 
7681       boolean present_tableName = true && (isSetTableName());
7682       builder.append(present_tableName);
7683       if (present_tableName)
7684         builder.append(tableName);
7685 
7686       return builder.toHashCode();
7687     }
7688 
7689     public int compareTo(getTableRegions_args other) {
7690       if (!getClass().equals(other.getClass())) {
7691         return getClass().getName().compareTo(other.getClass().getName());
7692       }
7693 
7694       int lastComparison = 0;
7695       getTableRegions_args typedOther = (getTableRegions_args)other;
7696 
7697       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
7698       if (lastComparison != 0) {
7699         return lastComparison;
7700       }
7701       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
7702       if (lastComparison != 0) {
7703         return lastComparison;
7704       }
7705       return 0;
7706     }
7707 
7708     public void read(TProtocol iprot) throws TException {
7709       TField field;
7710       iprot.readStructBegin();
7711       while (true)
7712       {
7713         field = iprot.readFieldBegin();
7714         if (field.type == TType.STOP) {
7715           break;
7716         }
7717         _Fields fieldId = _Fields.findByThriftId(field.id);
7718         if (fieldId == null) {
7719           TProtocolUtil.skip(iprot, field.type);
7720         } else {
7721           switch (fieldId) {
7722             case TABLE_NAME:
7723               if (field.type == TType.STRING) {
7724                 this.tableName = iprot.readBinary();
7725               } else {
7726                 TProtocolUtil.skip(iprot, field.type);
7727               }
7728               break;
7729           }
7730           iprot.readFieldEnd();
7731         }
7732       }
7733       iprot.readStructEnd();
7734 
7735       // check for required fields of primitive type, which can't be checked in the validate method
7736       validate();
7737     }
7738 
7739     public void write(TProtocol oprot) throws TException {
7740       validate();
7741 
7742       oprot.writeStructBegin(STRUCT_DESC);
7743       if (this.tableName != null) {
7744         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
7745         oprot.writeBinary(this.tableName);
7746         oprot.writeFieldEnd();
7747       }
7748       oprot.writeFieldStop();
7749       oprot.writeStructEnd();
7750     }
7751 
7752     @Override
7753     public String toString() {
7754       StringBuilder sb = new StringBuilder("getTableRegions_args(");
7755       boolean first = true;
7756 
7757       sb.append("tableName:");
7758       if (this.tableName == null) {
7759         sb.append("null");
7760       } else {
7761         sb.append(this.tableName);
7762       }
7763       first = false;
7764       sb.append(")");
7765       return sb.toString();
7766     }
7767 
7768     public void validate() throws TException {
7769       // check for required fields
7770     }
7771 
7772   }
7773 
7774   public static class getTableRegions_result implements TBase<getTableRegions_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_result>   {
7775     private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_result");
7776 
7777     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
7778     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
7779 
7780     public List<TRegionInfo> success;
7781     public IOError io;
7782 
7783     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
7784     public enum _Fields implements TFieldIdEnum {
7785       SUCCESS((short)0, "success"),
7786       IO((short)1, "io");
7787 
7788       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7789       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7790 
7791       static {
7792         for (_Fields field : EnumSet.allOf(_Fields.class)) {
7793           byId.put((int)field._thriftId, field);
7794           byName.put(field.getFieldName(), field);
7795         }
7796       }
7797 
7798       /**
7799        * Find the _Fields constant that matches fieldId, or null if its not found.
7800        */
7801       public static _Fields findByThriftId(int fieldId) {
7802         return byId.get(fieldId);
7803       }
7804 
7805       /**
7806        * Find the _Fields constant that matches fieldId, throwing an exception
7807        * if it is not found.
7808        */
7809       public static _Fields findByThriftIdOrThrow(int fieldId) {
7810         _Fields fields = findByThriftId(fieldId);
7811         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7812         return fields;
7813       }
7814 
7815       /**
7816        * Find the _Fields constant that matches name, or null if its not found.
7817        */
7818       public static _Fields findByName(String name) {
7819         return byName.get(name);
7820       }
7821 
7822       private final short _thriftId;
7823       private final String _fieldName;
7824 
7825       _Fields(short thriftId, String fieldName) {
7826         _thriftId = thriftId;
7827         _fieldName = fieldName;
7828       }
7829 
7830       public short getThriftFieldId() {
7831         return _thriftId;
7832       }
7833 
7834       public String getFieldName() {
7835         return _fieldName;
7836       }
7837     }
7838 
7839     // isset id assignments
7840 
7841     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7842       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
7843           new ListMetaData(TType.LIST,
7844               new StructMetaData(TType.STRUCT, TRegionInfo.class))));
7845       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
7846           new FieldValueMetaData(TType.STRUCT)));
7847     }});
7848 
7849     static {
7850       FieldMetaData.addStructMetaDataMap(getTableRegions_result.class, metaDataMap);
7851     }
7852 
7853     public getTableRegions_result() {
7854     }
7855 
7856     public getTableRegions_result(
7857       List<TRegionInfo> success,
7858       IOError io)
7859     {
7860       this();
7861       this.success = success;
7862       this.io = io;
7863     }
7864 
7865     /**
7866      * Performs a deep copy on <i>other</i>.
7867      */
7868     public getTableRegions_result(getTableRegions_result other) {
7869       if (other.isSetSuccess()) {
7870         List<TRegionInfo> __this__success = new ArrayList<TRegionInfo>();
7871         for (TRegionInfo other_element : other.success) {
7872           __this__success.add(new TRegionInfo(other_element));
7873         }
7874         this.success = __this__success;
7875       }
7876       if (other.isSetIo()) {
7877         this.io = new IOError(other.io);
7878       }
7879     }
7880 
7881     public getTableRegions_result deepCopy() {
7882       return new getTableRegions_result(this);
7883     }
7884 
7885     @Deprecated
7886     public getTableRegions_result clone() {
7887       return new getTableRegions_result(this);
7888     }
7889 
7890     public int getSuccessSize() {
7891       return (this.success == null) ? 0 : this.success.size();
7892     }
7893 
7894     public java.util.Iterator<TRegionInfo> getSuccessIterator() {
7895       return (this.success == null) ? null : this.success.iterator();
7896     }
7897 
7898     public void addToSuccess(TRegionInfo elem) {
7899       if (this.success == null) {
7900         this.success = new ArrayList<TRegionInfo>();
7901       }
7902       this.success.add(elem);
7903     }
7904 
7905     public List<TRegionInfo> getSuccess() {
7906       return this.success;
7907     }
7908 
7909     public getTableRegions_result setSuccess(List<TRegionInfo> success) {
7910       this.success = success;
7911       return this;
7912     }
7913 
7914     public void unsetSuccess() {
7915       this.success = null;
7916     }
7917 
7918     /** Returns true if field success is set (has been asigned a value) and false otherwise */
7919     public boolean isSetSuccess() {
7920       return this.success != null;
7921     }
7922 
7923     public void setSuccessIsSet(boolean value) {
7924       if (!value) {
7925         this.success = null;
7926       }
7927     }
7928 
7929     public IOError getIo() {
7930       return this.io;
7931     }
7932 
7933     public getTableRegions_result setIo(IOError io) {
7934       this.io = io;
7935       return this;
7936     }
7937 
7938     public void unsetIo() {
7939       this.io = null;
7940     }
7941 
7942     /** Returns true if field io is set (has been asigned a value) and false otherwise */
7943     public boolean isSetIo() {
7944       return this.io != null;
7945     }
7946 
7947     public void setIoIsSet(boolean value) {
7948       if (!value) {
7949         this.io = null;
7950       }
7951     }
7952 
7953     public void setFieldValue(_Fields field, Object value) {
7954       switch (field) {
7955       case SUCCESS:
7956         if (value == null) {
7957           unsetSuccess();
7958         } else {
7959           setSuccess((List<TRegionInfo>)value);
7960         }
7961         break;
7962 
7963       case IO:
7964         if (value == null) {
7965           unsetIo();
7966         } else {
7967           setIo((IOError)value);
7968         }
7969         break;
7970 
7971       }
7972     }
7973 
7974     public void setFieldValue(int fieldID, Object value) {
7975       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7976     }
7977 
7978     public Object getFieldValue(_Fields field) {
7979       switch (field) {
7980       case SUCCESS:
7981         return getSuccess();
7982 
7983       case IO:
7984         return getIo();
7985 
7986       }
7987       throw new IllegalStateException();
7988     }
7989 
7990     public Object getFieldValue(int fieldId) {
7991       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7992     }
7993 
7994     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
7995     public boolean isSet(_Fields field) {
7996       switch (field) {
7997       case SUCCESS:
7998         return isSetSuccess();
7999       case IO:
8000         return isSetIo();
8001       }
8002       throw new IllegalStateException();
8003     }
8004 
8005     public boolean isSet(int fieldID) {
8006       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8007     }
8008 
8009     @Override
8010     public boolean equals(Object that) {
8011       if (that == null)
8012         return false;
8013       if (that instanceof getTableRegions_result)
8014         return this.equals((getTableRegions_result)that);
8015       return false;
8016     }
8017 
8018     public boolean equals(getTableRegions_result that) {
8019       if (that == null)
8020         return false;
8021 
8022       boolean this_present_success = true && this.isSetSuccess();
8023       boolean that_present_success = true && that.isSetSuccess();
8024       if (this_present_success || that_present_success) {
8025         if (!(this_present_success && that_present_success))
8026           return false;
8027         if (!this.success.equals(that.success))
8028           return false;
8029       }
8030 
8031       boolean this_present_io = true && this.isSetIo();
8032       boolean that_present_io = true && that.isSetIo();
8033       if (this_present_io || that_present_io) {
8034         if (!(this_present_io && that_present_io))
8035           return false;
8036         if (!this.io.equals(that.io))
8037           return false;
8038       }
8039 
8040       return true;
8041     }
8042 
8043     @Override
8044     public int hashCode() {
8045       HashCodeBuilder builder = new HashCodeBuilder();
8046 
8047       boolean present_success = true && (isSetSuccess());
8048       builder.append(present_success);
8049       if (present_success)
8050         builder.append(success);
8051 
8052       boolean present_io = true && (isSetIo());
8053       builder.append(present_io);
8054       if (present_io)
8055         builder.append(io);
8056 
8057       return builder.toHashCode();
8058     }
8059 
8060     public int compareTo(getTableRegions_result other) {
8061       if (!getClass().equals(other.getClass())) {
8062         return getClass().getName().compareTo(other.getClass().getName());
8063       }
8064 
8065       int lastComparison = 0;
8066       getTableRegions_result typedOther = (getTableRegions_result)other;
8067 
8068       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
8069       if (lastComparison != 0) {
8070         return lastComparison;
8071       }
8072       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
8073       if (lastComparison != 0) {
8074         return lastComparison;
8075       }
8076       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
8077       if (lastComparison != 0) {
8078         return lastComparison;
8079       }
8080       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
8081       if (lastComparison != 0) {
8082         return lastComparison;
8083       }
8084       return 0;
8085     }
8086 
8087     public void read(TProtocol iprot) throws TException {
8088       TField field;
8089       iprot.readStructBegin();
8090       while (true)
8091       {
8092         field = iprot.readFieldBegin();
8093         if (field.type == TType.STOP) {
8094           break;
8095         }
8096         _Fields fieldId = _Fields.findByThriftId(field.id);
8097         if (fieldId == null) {
8098           TProtocolUtil.skip(iprot, field.type);
8099         } else {
8100           switch (fieldId) {
8101             case SUCCESS:
8102               if (field.type == TType.LIST) {
8103                 {
8104                   TList _list18 = iprot.readListBegin();
8105                   this.success = new ArrayList<TRegionInfo>(_list18.size);
8106                   for (int _i19 = 0; _i19 < _list18.size; ++_i19)
8107                   {
8108                     TRegionInfo _elem20;
8109                     _elem20 = new TRegionInfo();
8110                     _elem20.read(iprot);
8111                     this.success.add(_elem20);
8112                   }
8113                   iprot.readListEnd();
8114                 }
8115               } else {
8116                 TProtocolUtil.skip(iprot, field.type);
8117               }
8118               break;
8119             case IO:
8120               if (field.type == TType.STRUCT) {
8121                 this.io = new IOError();
8122                 this.io.read(iprot);
8123               } else {
8124                 TProtocolUtil.skip(iprot, field.type);
8125               }
8126               break;
8127           }
8128           iprot.readFieldEnd();
8129         }
8130       }
8131       iprot.readStructEnd();
8132 
8133       // check for required fields of primitive type, which can't be checked in the validate method
8134       validate();
8135     }
8136 
8137     public void write(TProtocol oprot) throws TException {
8138       oprot.writeStructBegin(STRUCT_DESC);
8139 
8140       if (this.isSetSuccess()) {
8141         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
8142         {
8143           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
8144           for (TRegionInfo _iter21 : this.success)
8145           {
8146             _iter21.write(oprot);
8147           }
8148           oprot.writeListEnd();
8149         }
8150         oprot.writeFieldEnd();
8151       } else if (this.isSetIo()) {
8152         oprot.writeFieldBegin(IO_FIELD_DESC);
8153         this.io.write(oprot);
8154         oprot.writeFieldEnd();
8155       }
8156       oprot.writeFieldStop();
8157       oprot.writeStructEnd();
8158     }
8159 
8160     @Override
8161     public String toString() {
8162       StringBuilder sb = new StringBuilder("getTableRegions_result(");
8163       boolean first = true;
8164 
8165       sb.append("success:");
8166       if (this.success == null) {
8167         sb.append("null");
8168       } else {
8169         sb.append(this.success);
8170       }
8171       first = false;
8172       if (!first) sb.append(", ");
8173       sb.append("io:");
8174       if (this.io == null) {
8175         sb.append("null");
8176       } else {
8177         sb.append(this.io);
8178       }
8179       first = false;
8180       sb.append(")");
8181       return sb.toString();
8182     }
8183 
8184     public void validate() throws TException {
8185       // check for required fields
8186     }
8187 
8188   }
8189 
8190   public static class createTable_args implements TBase<createTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_args>   {
8191     private static final TStruct STRUCT_DESC = new TStruct("createTable_args");
8192 
8193     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
8194     private static final TField COLUMN_FAMILIES_FIELD_DESC = new TField("columnFamilies", TType.LIST, (short)2);
8195 
8196     /**
8197      * name of table to create
8198      */
8199     public byte[] tableName;
8200     /**
8201      * list of column family descriptors
8202      */
8203     public List<ColumnDescriptor> columnFamilies;
8204 
8205     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
8206     public enum _Fields implements TFieldIdEnum {
8207       /**
8208        * name of table to create
8209        */
8210       TABLE_NAME((short)1, "tableName"),
8211       /**
8212        * list of column family descriptors
8213        */
8214       COLUMN_FAMILIES((short)2, "columnFamilies");
8215 
8216       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
8217       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8218 
8219       static {
8220         for (_Fields field : EnumSet.allOf(_Fields.class)) {
8221           byId.put((int)field._thriftId, field);
8222           byName.put(field.getFieldName(), field);
8223         }
8224       }
8225 
8226       /**
8227        * Find the _Fields constant that matches fieldId, or null if its not found.
8228        */
8229       public static _Fields findByThriftId(int fieldId) {
8230         return byId.get(fieldId);
8231       }
8232 
8233       /**
8234        * Find the _Fields constant that matches fieldId, throwing an exception
8235        * if it is not found.
8236        */
8237       public static _Fields findByThriftIdOrThrow(int fieldId) {
8238         _Fields fields = findByThriftId(fieldId);
8239         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8240         return fields;
8241       }
8242 
8243       /**
8244        * Find the _Fields constant that matches name, or null if its not found.
8245        */
8246       public static _Fields findByName(String name) {
8247         return byName.get(name);
8248       }
8249 
8250       private final short _thriftId;
8251       private final String _fieldName;
8252 
8253       _Fields(short thriftId, String fieldName) {
8254         _thriftId = thriftId;
8255         _fieldName = fieldName;
8256       }
8257 
8258       public short getThriftFieldId() {
8259         return _thriftId;
8260       }
8261 
8262       public String getFieldName() {
8263         return _fieldName;
8264       }
8265     }
8266 
8267     // isset id assignments
8268 
8269     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
8270       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
8271           new FieldValueMetaData(TType.STRING)));
8272       put(_Fields.COLUMN_FAMILIES, new FieldMetaData("columnFamilies", TFieldRequirementType.DEFAULT,
8273           new ListMetaData(TType.LIST,
8274               new StructMetaData(TType.STRUCT, ColumnDescriptor.class))));
8275     }});
8276 
8277     static {
8278       FieldMetaData.addStructMetaDataMap(createTable_args.class, metaDataMap);
8279     }
8280 
8281     public createTable_args() {
8282     }
8283 
8284     public createTable_args(
8285       byte[] tableName,
8286       List<ColumnDescriptor> columnFamilies)
8287     {
8288       this();
8289       this.tableName = tableName;
8290       this.columnFamilies = columnFamilies;
8291     }
8292 
8293     /**
8294      * Performs a deep copy on <i>other</i>.
8295      */
8296     public createTable_args(createTable_args other) {
8297       if (other.isSetTableName()) {
8298         this.tableName = other.tableName;
8299       }
8300       if (other.isSetColumnFamilies()) {
8301         List<ColumnDescriptor> __this__columnFamilies = new ArrayList<ColumnDescriptor>();
8302         for (ColumnDescriptor other_element : other.columnFamilies) {
8303           __this__columnFamilies.add(new ColumnDescriptor(other_element));
8304         }
8305         this.columnFamilies = __this__columnFamilies;
8306       }
8307     }
8308 
8309     public createTable_args deepCopy() {
8310       return new createTable_args(this);
8311     }
8312 
8313     @Deprecated
8314     public createTable_args clone() {
8315       return new createTable_args(this);
8316     }
8317 
8318     /**
8319      * name of table to create
8320      */
8321     public byte[] getTableName() {
8322       return this.tableName;
8323     }
8324 
8325     /**
8326      * name of table to create
8327      */
8328     public createTable_args setTableName(byte[] tableName) {
8329       this.tableName = tableName;
8330       return this;
8331     }
8332 
8333     public void unsetTableName() {
8334       this.tableName = null;
8335     }
8336 
8337     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
8338     public boolean isSetTableName() {
8339       return this.tableName != null;
8340     }
8341 
8342     public void setTableNameIsSet(boolean value) {
8343       if (!value) {
8344         this.tableName = null;
8345       }
8346     }
8347 
8348     public int getColumnFamiliesSize() {
8349       return (this.columnFamilies == null) ? 0 : this.columnFamilies.size();
8350     }
8351 
8352     public java.util.Iterator<ColumnDescriptor> getColumnFamiliesIterator() {
8353       return (this.columnFamilies == null) ? null : this.columnFamilies.iterator();
8354     }
8355 
8356     public void addToColumnFamilies(ColumnDescriptor elem) {
8357       if (this.columnFamilies == null) {
8358         this.columnFamilies = new ArrayList<ColumnDescriptor>();
8359       }
8360       this.columnFamilies.add(elem);
8361     }
8362 
8363     /**
8364      * list of column family descriptors
8365      */
8366     public List<ColumnDescriptor> getColumnFamilies() {
8367       return this.columnFamilies;
8368     }
8369 
8370     /**
8371      * list of column family descriptors
8372      */
8373     public createTable_args setColumnFamilies(List<ColumnDescriptor> columnFamilies) {
8374       this.columnFamilies = columnFamilies;
8375       return this;
8376     }
8377 
8378     public void unsetColumnFamilies() {
8379       this.columnFamilies = null;
8380     }
8381 
8382     /** Returns true if field columnFamilies is set (has been asigned a value) and false otherwise */
8383     public boolean isSetColumnFamilies() {
8384       return this.columnFamilies != null;
8385     }
8386 
8387     public void setColumnFamiliesIsSet(boolean value) {
8388       if (!value) {
8389         this.columnFamilies = null;
8390       }
8391     }
8392 
8393     public void setFieldValue(_Fields field, Object value) {
8394       switch (field) {
8395       case TABLE_NAME:
8396         if (value == null) {
8397           unsetTableName();
8398         } else {
8399           setTableName((byte[])value);
8400         }
8401         break;
8402 
8403       case COLUMN_FAMILIES:
8404         if (value == null) {
8405           unsetColumnFamilies();
8406         } else {
8407           setColumnFamilies((List<ColumnDescriptor>)value);
8408         }
8409         break;
8410 
8411       }
8412     }
8413 
8414     public void setFieldValue(int fieldID, Object value) {
8415       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8416     }
8417 
8418     public Object getFieldValue(_Fields field) {
8419       switch (field) {
8420       case TABLE_NAME:
8421         return getTableName();
8422 
8423       case COLUMN_FAMILIES:
8424         return getColumnFamilies();
8425 
8426       }
8427       throw new IllegalStateException();
8428     }
8429 
8430     public Object getFieldValue(int fieldId) {
8431       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8432     }
8433 
8434     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
8435     public boolean isSet(_Fields field) {
8436       switch (field) {
8437       case TABLE_NAME:
8438         return isSetTableName();
8439       case COLUMN_FAMILIES:
8440         return isSetColumnFamilies();
8441       }
8442       throw new IllegalStateException();
8443     }
8444 
8445     public boolean isSet(int fieldID) {
8446       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8447     }
8448 
8449     @Override
8450     public boolean equals(Object that) {
8451       if (that == null)
8452         return false;
8453       if (that instanceof createTable_args)
8454         return this.equals((createTable_args)that);
8455       return false;
8456     }
8457 
8458     public boolean equals(createTable_args that) {
8459       if (that == null)
8460         return false;
8461 
8462       boolean this_present_tableName = true && this.isSetTableName();
8463       boolean that_present_tableName = true && that.isSetTableName();
8464       if (this_present_tableName || that_present_tableName) {
8465         if (!(this_present_tableName && that_present_tableName))
8466           return false;
8467         if (!java.util.Arrays.equals(this.tableName, that.tableName))
8468           return false;
8469       }
8470 
8471       boolean this_present_columnFamilies = true && this.isSetColumnFamilies();
8472       boolean that_present_columnFamilies = true && that.isSetColumnFamilies();
8473       if (this_present_columnFamilies || that_present_columnFamilies) {
8474         if (!(this_present_columnFamilies && that_present_columnFamilies))
8475           return false;
8476         if (!this.columnFamilies.equals(that.columnFamilies))
8477           return false;
8478       }
8479 
8480       return true;
8481     }
8482 
8483     @Override
8484     public int hashCode() {
8485       HashCodeBuilder builder = new HashCodeBuilder();
8486 
8487       boolean present_tableName = true && (isSetTableName());
8488       builder.append(present_tableName);
8489       if (present_tableName)
8490         builder.append(tableName);
8491 
8492       boolean present_columnFamilies = true && (isSetColumnFamilies());
8493       builder.append(present_columnFamilies);
8494       if (present_columnFamilies)
8495         builder.append(columnFamilies);
8496 
8497       return builder.toHashCode();
8498     }
8499 
8500     public int compareTo(createTable_args other) {
8501       if (!getClass().equals(other.getClass())) {
8502         return getClass().getName().compareTo(other.getClass().getName());
8503       }
8504 
8505       int lastComparison = 0;
8506       createTable_args typedOther = (createTable_args)other;
8507 
8508       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
8509       if (lastComparison != 0) {
8510         return lastComparison;
8511       }
8512       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
8513       if (lastComparison != 0) {
8514         return lastComparison;
8515       }
8516       lastComparison = Boolean.valueOf(isSetColumnFamilies()).compareTo(isSetColumnFamilies());
8517       if (lastComparison != 0) {
8518         return lastComparison;
8519       }
8520       lastComparison = TBaseHelper.compareTo(columnFamilies, typedOther.columnFamilies);
8521       if (lastComparison != 0) {
8522         return lastComparison;
8523       }
8524       return 0;
8525     }
8526 
8527     public void read(TProtocol iprot) throws TException {
8528       TField field;
8529       iprot.readStructBegin();
8530       while (true)
8531       {
8532         field = iprot.readFieldBegin();
8533         if (field.type == TType.STOP) {
8534           break;
8535         }
8536         _Fields fieldId = _Fields.findByThriftId(field.id);
8537         if (fieldId == null) {
8538           TProtocolUtil.skip(iprot, field.type);
8539         } else {
8540           switch (fieldId) {
8541             case TABLE_NAME:
8542               if (field.type == TType.STRING) {
8543                 this.tableName = iprot.readBinary();
8544               } else {
8545                 TProtocolUtil.skip(iprot, field.type);
8546               }
8547               break;
8548             case COLUMN_FAMILIES:
8549               if (field.type == TType.LIST) {
8550                 {
8551                   TList _list22 = iprot.readListBegin();
8552                   this.columnFamilies = new ArrayList<ColumnDescriptor>(_list22.size);
8553                   for (int _i23 = 0; _i23 < _list22.size; ++_i23)
8554                   {
8555                     ColumnDescriptor _elem24;
8556                     _elem24 = new ColumnDescriptor();
8557                     _elem24.read(iprot);
8558                     this.columnFamilies.add(_elem24);
8559                   }
8560                   iprot.readListEnd();
8561                 }
8562               } else {
8563                 TProtocolUtil.skip(iprot, field.type);
8564               }
8565               break;
8566           }
8567           iprot.readFieldEnd();
8568         }
8569       }
8570       iprot.readStructEnd();
8571 
8572       // check for required fields of primitive type, which can't be checked in the validate method
8573       validate();
8574     }
8575 
8576     public void write(TProtocol oprot) throws TException {
8577       validate();
8578 
8579       oprot.writeStructBegin(STRUCT_DESC);
8580       if (this.tableName != null) {
8581         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
8582         oprot.writeBinary(this.tableName);
8583         oprot.writeFieldEnd();
8584       }
8585       if (this.columnFamilies != null) {
8586         oprot.writeFieldBegin(COLUMN_FAMILIES_FIELD_DESC);
8587         {
8588           oprot.writeListBegin(new TList(TType.STRUCT, this.columnFamilies.size()));
8589           for (ColumnDescriptor _iter25 : this.columnFamilies)
8590           {
8591             _iter25.write(oprot);
8592           }
8593           oprot.writeListEnd();
8594         }
8595         oprot.writeFieldEnd();
8596       }
8597       oprot.writeFieldStop();
8598       oprot.writeStructEnd();
8599     }
8600 
8601     @Override
8602     public String toString() {
8603       StringBuilder sb = new StringBuilder("createTable_args(");
8604       boolean first = true;
8605 
8606       sb.append("tableName:");
8607       if (this.tableName == null) {
8608         sb.append("null");
8609       } else {
8610         sb.append(this.tableName);
8611       }
8612       first = false;
8613       if (!first) sb.append(", ");
8614       sb.append("columnFamilies:");
8615       if (this.columnFamilies == null) {
8616         sb.append("null");
8617       } else {
8618         sb.append(this.columnFamilies);
8619       }
8620       first = false;
8621       sb.append(")");
8622       return sb.toString();
8623     }
8624 
8625     public void validate() throws TException {
8626       // check for required fields
8627     }
8628 
8629   }
8630 
8631   public static class createTable_result implements TBase<createTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_result>   {
8632     private static final TStruct STRUCT_DESC = new TStruct("createTable_result");
8633 
8634     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
8635     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
8636     private static final TField EXIST_FIELD_DESC = new TField("exist", TType.STRUCT, (short)3);
8637 
8638     public IOError io;
8639     public IllegalArgument ia;
8640     public AlreadyExists exist;
8641 
8642     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
8643     public enum _Fields implements TFieldIdEnum {
8644       IO((short)1, "io"),
8645       IA((short)2, "ia"),
8646       EXIST((short)3, "exist");
8647 
8648       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
8649       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8650 
8651       static {
8652         for (_Fields field : EnumSet.allOf(_Fields.class)) {
8653           byId.put((int)field._thriftId, field);
8654           byName.put(field.getFieldName(), field);
8655         }
8656       }
8657 
8658       /**
8659        * Find the _Fields constant that matches fieldId, or null if its not found.
8660        */
8661       public static _Fields findByThriftId(int fieldId) {
8662         return byId.get(fieldId);
8663       }
8664 
8665       /**
8666        * Find the _Fields constant that matches fieldId, throwing an exception
8667        * if it is not found.
8668        */
8669       public static _Fields findByThriftIdOrThrow(int fieldId) {
8670         _Fields fields = findByThriftId(fieldId);
8671         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8672         return fields;
8673       }
8674 
8675       /**
8676        * Find the _Fields constant that matches name, or null if its not found.
8677        */
8678       public static _Fields findByName(String name) {
8679         return byName.get(name);
8680       }
8681 
8682       private final short _thriftId;
8683       private final String _fieldName;
8684 
8685       _Fields(short thriftId, String fieldName) {
8686         _thriftId = thriftId;
8687         _fieldName = fieldName;
8688       }
8689 
8690       public short getThriftFieldId() {
8691         return _thriftId;
8692       }
8693 
8694       public String getFieldName() {
8695         return _fieldName;
8696       }
8697     }
8698 
8699     // isset id assignments
8700 
8701     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
8702       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
8703           new FieldValueMetaData(TType.STRUCT)));
8704       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
8705           new FieldValueMetaData(TType.STRUCT)));
8706       put(_Fields.EXIST, new FieldMetaData("exist", TFieldRequirementType.DEFAULT,
8707           new FieldValueMetaData(TType.STRUCT)));
8708     }});
8709 
8710     static {
8711       FieldMetaData.addStructMetaDataMap(createTable_result.class, metaDataMap);
8712     }
8713 
8714     public createTable_result() {
8715     }
8716 
8717     public createTable_result(
8718       IOError io,
8719       IllegalArgument ia,
8720       AlreadyExists exist)
8721     {
8722       this();
8723       this.io = io;
8724       this.ia = ia;
8725       this.exist = exist;
8726     }
8727 
8728     /**
8729      * Performs a deep copy on <i>other</i>.
8730      */
8731     public createTable_result(createTable_result other) {
8732       if (other.isSetIo()) {
8733         this.io = new IOError(other.io);
8734       }
8735       if (other.isSetIa()) {
8736         this.ia = new IllegalArgument(other.ia);
8737       }
8738       if (other.isSetExist()) {
8739         this.exist = new AlreadyExists(other.exist);
8740       }
8741     }
8742 
8743     public createTable_result deepCopy() {
8744       return new createTable_result(this);
8745     }
8746 
8747     @Deprecated
8748     public createTable_result clone() {
8749       return new createTable_result(this);
8750     }
8751 
8752     public IOError getIo() {
8753       return this.io;
8754     }
8755 
8756     public createTable_result setIo(IOError io) {
8757       this.io = io;
8758       return this;
8759     }
8760 
8761     public void unsetIo() {
8762       this.io = null;
8763     }
8764 
8765     /** Returns true if field io is set (has been asigned a value) and false otherwise */
8766     public boolean isSetIo() {
8767       return this.io != null;
8768     }
8769 
8770     public void setIoIsSet(boolean value) {
8771       if (!value) {
8772         this.io = null;
8773       }
8774     }
8775 
8776     public IllegalArgument getIa() {
8777       return this.ia;
8778     }
8779 
8780     public createTable_result setIa(IllegalArgument ia) {
8781       this.ia = ia;
8782       return this;
8783     }
8784 
8785     public void unsetIa() {
8786       this.ia = null;
8787     }
8788 
8789     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
8790     public boolean isSetIa() {
8791       return this.ia != null;
8792     }
8793 
8794     public void setIaIsSet(boolean value) {
8795       if (!value) {
8796         this.ia = null;
8797       }
8798     }
8799 
8800     public AlreadyExists getExist() {
8801       return this.exist;
8802     }
8803 
8804     public createTable_result setExist(AlreadyExists exist) {
8805       this.exist = exist;
8806       return this;
8807     }
8808 
8809     public void unsetExist() {
8810       this.exist = null;
8811     }
8812 
8813     /** Returns true if field exist is set (has been asigned a value) and false otherwise */
8814     public boolean isSetExist() {
8815       return this.exist != null;
8816     }
8817 
8818     public void setExistIsSet(boolean value) {
8819       if (!value) {
8820         this.exist = null;
8821       }
8822     }
8823 
8824     public void setFieldValue(_Fields field, Object value) {
8825       switch (field) {
8826       case IO:
8827         if (value == null) {
8828           unsetIo();
8829         } else {
8830           setIo((IOError)value);
8831         }
8832         break;
8833 
8834       case IA:
8835         if (value == null) {
8836           unsetIa();
8837         } else {
8838           setIa((IllegalArgument)value);
8839         }
8840         break;
8841 
8842       case EXIST:
8843         if (value == null) {
8844           unsetExist();
8845         } else {
8846           setExist((AlreadyExists)value);
8847         }
8848         break;
8849 
8850       }
8851     }
8852 
8853     public void setFieldValue(int fieldID, Object value) {
8854       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8855     }
8856 
8857     public Object getFieldValue(_Fields field) {
8858       switch (field) {
8859       case IO:
8860         return getIo();
8861 
8862       case IA:
8863         return getIa();
8864 
8865       case EXIST:
8866         return getExist();
8867 
8868       }
8869       throw new IllegalStateException();
8870     }
8871 
8872     public Object getFieldValue(int fieldId) {
8873       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8874     }
8875 
8876     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
8877     public boolean isSet(_Fields field) {
8878       switch (field) {
8879       case IO:
8880         return isSetIo();
8881       case IA:
8882         return isSetIa();
8883       case EXIST:
8884         return isSetExist();
8885       }
8886       throw new IllegalStateException();
8887     }
8888 
8889     public boolean isSet(int fieldID) {
8890       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8891     }
8892 
8893     @Override
8894     public boolean equals(Object that) {
8895       if (that == null)
8896         return false;
8897       if (that instanceof createTable_result)
8898         return this.equals((createTable_result)that);
8899       return false;
8900     }
8901 
8902     public boolean equals(createTable_result that) {
8903       if (that == null)
8904         return false;
8905 
8906       boolean this_present_io = true && this.isSetIo();
8907       boolean that_present_io = true && that.isSetIo();
8908       if (this_present_io || that_present_io) {
8909         if (!(this_present_io && that_present_io))
8910           return false;
8911         if (!this.io.equals(that.io))
8912           return false;
8913       }
8914 
8915       boolean this_present_ia = true && this.isSetIa();
8916       boolean that_present_ia = true && that.isSetIa();
8917       if (this_present_ia || that_present_ia) {
8918         if (!(this_present_ia && that_present_ia))
8919           return false;
8920         if (!this.ia.equals(that.ia))
8921           return false;
8922       }
8923 
8924       boolean this_present_exist = true && this.isSetExist();
8925       boolean that_present_exist = true && that.isSetExist();
8926       if (this_present_exist || that_present_exist) {
8927         if (!(this_present_exist && that_present_exist))
8928           return false;
8929         if (!this.exist.equals(that.exist))
8930           return false;
8931       }
8932 
8933       return true;
8934     }
8935 
8936     @Override
8937     public int hashCode() {
8938       HashCodeBuilder builder = new HashCodeBuilder();
8939 
8940       boolean present_io = true && (isSetIo());
8941       builder.append(present_io);
8942       if (present_io)
8943         builder.append(io);
8944 
8945       boolean present_ia = true && (isSetIa());
8946       builder.append(present_ia);
8947       if (present_ia)
8948         builder.append(ia);
8949 
8950       boolean present_exist = true && (isSetExist());
8951       builder.append(present_exist);
8952       if (present_exist)
8953         builder.append(exist);
8954 
8955       return builder.toHashCode();
8956     }
8957 
8958     public int compareTo(createTable_result other) {
8959       if (!getClass().equals(other.getClass())) {
8960         return getClass().getName().compareTo(other.getClass().getName());
8961       }
8962 
8963       int lastComparison = 0;
8964       createTable_result typedOther = (createTable_result)other;
8965 
8966       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
8967       if (lastComparison != 0) {
8968         return lastComparison;
8969       }
8970       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
8971       if (lastComparison != 0) {
8972         return lastComparison;
8973       }
8974       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
8975       if (lastComparison != 0) {
8976         return lastComparison;
8977       }
8978       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
8979       if (lastComparison != 0) {
8980         return lastComparison;
8981       }
8982       lastComparison = Boolean.valueOf(isSetExist()).compareTo(isSetExist());
8983       if (lastComparison != 0) {
8984         return lastComparison;
8985       }
8986       lastComparison = TBaseHelper.compareTo(exist, typedOther.exist);
8987       if (lastComparison != 0) {
8988         return lastComparison;
8989       }
8990       return 0;
8991     }
8992 
8993     public void read(TProtocol iprot) throws TException {
8994       TField field;
8995       iprot.readStructBegin();
8996       while (true)
8997       {
8998         field = iprot.readFieldBegin();
8999         if (field.type == TType.STOP) {
9000           break;
9001         }
9002         _Fields fieldId = _Fields.findByThriftId(field.id);
9003         if (fieldId == null) {
9004           TProtocolUtil.skip(iprot, field.type);
9005         } else {
9006           switch (fieldId) {
9007             case IO:
9008               if (field.type == TType.STRUCT) {
9009                 this.io = new IOError();
9010                 this.io.read(iprot);
9011               } else {
9012                 TProtocolUtil.skip(iprot, field.type);
9013               }
9014               break;
9015             case IA:
9016               if (field.type == TType.STRUCT) {
9017                 this.ia = new IllegalArgument();
9018                 this.ia.read(iprot);
9019               } else {
9020                 TProtocolUtil.skip(iprot, field.type);
9021               }
9022               break;
9023             case EXIST:
9024               if (field.type == TType.STRUCT) {
9025                 this.exist = new AlreadyExists();
9026                 this.exist.read(iprot);
9027               } else {
9028                 TProtocolUtil.skip(iprot, field.type);
9029               }
9030               break;
9031           }
9032           iprot.readFieldEnd();
9033         }
9034       }
9035       iprot.readStructEnd();
9036 
9037       // check for required fields of primitive type, which can't be checked in the validate method
9038       validate();
9039     }
9040 
9041     public void write(TProtocol oprot) throws TException {
9042       oprot.writeStructBegin(STRUCT_DESC);
9043 
9044       if (this.isSetIo()) {
9045         oprot.writeFieldBegin(IO_FIELD_DESC);
9046         this.io.write(oprot);
9047         oprot.writeFieldEnd();
9048       } else if (this.isSetIa()) {
9049         oprot.writeFieldBegin(IA_FIELD_DESC);
9050         this.ia.write(oprot);
9051         oprot.writeFieldEnd();
9052       } else if (this.isSetExist()) {
9053         oprot.writeFieldBegin(EXIST_FIELD_DESC);
9054         this.exist.write(oprot);
9055         oprot.writeFieldEnd();
9056       }
9057       oprot.writeFieldStop();
9058       oprot.writeStructEnd();
9059     }
9060 
9061     @Override
9062     public String toString() {
9063       StringBuilder sb = new StringBuilder("createTable_result(");
9064       boolean first = true;
9065 
9066       sb.append("io:");
9067       if (this.io == null) {
9068         sb.append("null");
9069       } else {
9070         sb.append(this.io);
9071       }
9072       first = false;
9073       if (!first) sb.append(", ");
9074       sb.append("ia:");
9075       if (this.ia == null) {
9076         sb.append("null");
9077       } else {
9078         sb.append(this.ia);
9079       }
9080       first = false;
9081       if (!first) sb.append(", ");
9082       sb.append("exist:");
9083       if (this.exist == null) {
9084         sb.append("null");
9085       } else {
9086         sb.append(this.exist);
9087       }
9088       first = false;
9089       sb.append(")");
9090       return sb.toString();
9091     }
9092 
9093     public void validate() throws TException {
9094       // check for required fields
9095     }
9096 
9097   }
9098 
9099   public static class deleteTable_args implements TBase<deleteTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_args>   {
9100     private static final TStruct STRUCT_DESC = new TStruct("deleteTable_args");
9101 
9102     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
9103 
9104     /**
9105      * name of table to delete
9106      */
9107     public byte[] tableName;
9108 
9109     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
9110     public enum _Fields implements TFieldIdEnum {
9111       /**
9112        * name of table to delete
9113        */
9114       TABLE_NAME((short)1, "tableName");
9115 
9116       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9117       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9118 
9119       static {
9120         for (_Fields field : EnumSet.allOf(_Fields.class)) {
9121           byId.put((int)field._thriftId, field);
9122           byName.put(field.getFieldName(), field);
9123         }
9124       }
9125 
9126       /**
9127        * Find the _Fields constant that matches fieldId, or null if its not found.
9128        */
9129       public static _Fields findByThriftId(int fieldId) {
9130         return byId.get(fieldId);
9131       }
9132 
9133       /**
9134        * Find the _Fields constant that matches fieldId, throwing an exception
9135        * if it is not found.
9136        */
9137       public static _Fields findByThriftIdOrThrow(int fieldId) {
9138         _Fields fields = findByThriftId(fieldId);
9139         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9140         return fields;
9141       }
9142 
9143       /**
9144        * Find the _Fields constant that matches name, or null if its not found.
9145        */
9146       public static _Fields findByName(String name) {
9147         return byName.get(name);
9148       }
9149 
9150       private final short _thriftId;
9151       private final String _fieldName;
9152 
9153       _Fields(short thriftId, String fieldName) {
9154         _thriftId = thriftId;
9155         _fieldName = fieldName;
9156       }
9157 
9158       public short getThriftFieldId() {
9159         return _thriftId;
9160       }
9161 
9162       public String getFieldName() {
9163         return _fieldName;
9164       }
9165     }
9166 
9167     // isset id assignments
9168 
9169     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9170       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
9171           new FieldValueMetaData(TType.STRING)));
9172     }});
9173 
9174     static {
9175       FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap);
9176     }
9177 
9178     public deleteTable_args() {
9179     }
9180 
9181     public deleteTable_args(
9182       byte[] tableName)
9183     {
9184       this();
9185       this.tableName = tableName;
9186     }
9187 
9188     /**
9189      * Performs a deep copy on <i>other</i>.
9190      */
9191     public deleteTable_args(deleteTable_args other) {
9192       if (other.isSetTableName()) {
9193         this.tableName = other.tableName;
9194       }
9195     }
9196 
9197     public deleteTable_args deepCopy() {
9198       return new deleteTable_args(this);
9199     }
9200 
9201     @Deprecated
9202     public deleteTable_args clone() {
9203       return new deleteTable_args(this);
9204     }
9205 
9206     /**
9207      * name of table to delete
9208      */
9209     public byte[] getTableName() {
9210       return this.tableName;
9211     }
9212 
9213     /**
9214      * name of table to delete
9215      */
9216     public deleteTable_args setTableName(byte[] tableName) {
9217       this.tableName = tableName;
9218       return this;
9219     }
9220 
9221     public void unsetTableName() {
9222       this.tableName = null;
9223     }
9224 
9225     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
9226     public boolean isSetTableName() {
9227       return this.tableName != null;
9228     }
9229 
9230     public void setTableNameIsSet(boolean value) {
9231       if (!value) {
9232         this.tableName = null;
9233       }
9234     }
9235 
9236     public void setFieldValue(_Fields field, Object value) {
9237       switch (field) {
9238       case TABLE_NAME:
9239         if (value == null) {
9240           unsetTableName();
9241         } else {
9242           setTableName((byte[])value);
9243         }
9244         break;
9245 
9246       }
9247     }
9248 
9249     public void setFieldValue(int fieldID, Object value) {
9250       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9251     }
9252 
9253     public Object getFieldValue(_Fields field) {
9254       switch (field) {
9255       case TABLE_NAME:
9256         return getTableName();
9257 
9258       }
9259       throw new IllegalStateException();
9260     }
9261 
9262     public Object getFieldValue(int fieldId) {
9263       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9264     }
9265 
9266     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
9267     public boolean isSet(_Fields field) {
9268       switch (field) {
9269       case TABLE_NAME:
9270         return isSetTableName();
9271       }
9272       throw new IllegalStateException();
9273     }
9274 
9275     public boolean isSet(int fieldID) {
9276       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9277     }
9278 
9279     @Override
9280     public boolean equals(Object that) {
9281       if (that == null)
9282         return false;
9283       if (that instanceof deleteTable_args)
9284         return this.equals((deleteTable_args)that);
9285       return false;
9286     }
9287 
9288     public boolean equals(deleteTable_args that) {
9289       if (that == null)
9290         return false;
9291 
9292       boolean this_present_tableName = true && this.isSetTableName();
9293       boolean that_present_tableName = true && that.isSetTableName();
9294       if (this_present_tableName || that_present_tableName) {
9295         if (!(this_present_tableName && that_present_tableName))
9296           return false;
9297         if (!java.util.Arrays.equals(this.tableName, that.tableName))
9298           return false;
9299       }
9300 
9301       return true;
9302     }
9303 
9304     @Override
9305     public int hashCode() {
9306       HashCodeBuilder builder = new HashCodeBuilder();
9307 
9308       boolean present_tableName = true && (isSetTableName());
9309       builder.append(present_tableName);
9310       if (present_tableName)
9311         builder.append(tableName);
9312 
9313       return builder.toHashCode();
9314     }
9315 
9316     public int compareTo(deleteTable_args other) {
9317       if (!getClass().equals(other.getClass())) {
9318         return getClass().getName().compareTo(other.getClass().getName());
9319       }
9320 
9321       int lastComparison = 0;
9322       deleteTable_args typedOther = (deleteTable_args)other;
9323 
9324       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
9325       if (lastComparison != 0) {
9326         return lastComparison;
9327       }
9328       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
9329       if (lastComparison != 0) {
9330         return lastComparison;
9331       }
9332       return 0;
9333     }
9334 
9335     public void read(TProtocol iprot) throws TException {
9336       TField field;
9337       iprot.readStructBegin();
9338       while (true)
9339       {
9340         field = iprot.readFieldBegin();
9341         if (field.type == TType.STOP) {
9342           break;
9343         }
9344         _Fields fieldId = _Fields.findByThriftId(field.id);
9345         if (fieldId == null) {
9346           TProtocolUtil.skip(iprot, field.type);
9347         } else {
9348           switch (fieldId) {
9349             case TABLE_NAME:
9350               if (field.type == TType.STRING) {
9351                 this.tableName = iprot.readBinary();
9352               } else {
9353                 TProtocolUtil.skip(iprot, field.type);
9354               }
9355               break;
9356           }
9357           iprot.readFieldEnd();
9358         }
9359       }
9360       iprot.readStructEnd();
9361 
9362       // check for required fields of primitive type, which can't be checked in the validate method
9363       validate();
9364     }
9365 
9366     public void write(TProtocol oprot) throws TException {
9367       validate();
9368 
9369       oprot.writeStructBegin(STRUCT_DESC);
9370       if (this.tableName != null) {
9371         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
9372         oprot.writeBinary(this.tableName);
9373         oprot.writeFieldEnd();
9374       }
9375       oprot.writeFieldStop();
9376       oprot.writeStructEnd();
9377     }
9378 
9379     @Override
9380     public String toString() {
9381       StringBuilder sb = new StringBuilder("deleteTable_args(");
9382       boolean first = true;
9383 
9384       sb.append("tableName:");
9385       if (this.tableName == null) {
9386         sb.append("null");
9387       } else {
9388         sb.append(this.tableName);
9389       }
9390       first = false;
9391       sb.append(")");
9392       return sb.toString();
9393     }
9394 
9395     public void validate() throws TException {
9396       // check for required fields
9397     }
9398 
9399   }
9400 
9401   public static class deleteTable_result implements TBase<deleteTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_result>   {
9402     private static final TStruct STRUCT_DESC = new TStruct("deleteTable_result");
9403 
9404     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
9405 
9406     public IOError io;
9407 
9408     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
9409     public enum _Fields implements TFieldIdEnum {
9410       IO((short)1, "io");
9411 
9412       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9413       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9414 
9415       static {
9416         for (_Fields field : EnumSet.allOf(_Fields.class)) {
9417           byId.put((int)field._thriftId, field);
9418           byName.put(field.getFieldName(), field);
9419         }
9420       }
9421 
9422       /**
9423        * Find the _Fields constant that matches fieldId, or null if its not found.
9424        */
9425       public static _Fields findByThriftId(int fieldId) {
9426         return byId.get(fieldId);
9427       }
9428 
9429       /**
9430        * Find the _Fields constant that matches fieldId, throwing an exception
9431        * if it is not found.
9432        */
9433       public static _Fields findByThriftIdOrThrow(int fieldId) {
9434         _Fields fields = findByThriftId(fieldId);
9435         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9436         return fields;
9437       }
9438 
9439       /**
9440        * Find the _Fields constant that matches name, or null if its not found.
9441        */
9442       public static _Fields findByName(String name) {
9443         return byName.get(name);
9444       }
9445 
9446       private final short _thriftId;
9447       private final String _fieldName;
9448 
9449       _Fields(short thriftId, String fieldName) {
9450         _thriftId = thriftId;
9451         _fieldName = fieldName;
9452       }
9453 
9454       public short getThriftFieldId() {
9455         return _thriftId;
9456       }
9457 
9458       public String getFieldName() {
9459         return _fieldName;
9460       }
9461     }
9462 
9463     // isset id assignments
9464 
9465     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9466       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
9467           new FieldValueMetaData(TType.STRUCT)));
9468     }});
9469 
9470     static {
9471       FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap);
9472     }
9473 
9474     public deleteTable_result() {
9475     }
9476 
9477     public deleteTable_result(
9478       IOError io)
9479     {
9480       this();
9481       this.io = io;
9482     }
9483 
9484     /**
9485      * Performs a deep copy on <i>other</i>.
9486      */
9487     public deleteTable_result(deleteTable_result other) {
9488       if (other.isSetIo()) {
9489         this.io = new IOError(other.io);
9490       }
9491     }
9492 
9493     public deleteTable_result deepCopy() {
9494       return new deleteTable_result(this);
9495     }
9496 
9497     @Deprecated
9498     public deleteTable_result clone() {
9499       return new deleteTable_result(this);
9500     }
9501 
9502     public IOError getIo() {
9503       return this.io;
9504     }
9505 
9506     public deleteTable_result setIo(IOError io) {
9507       this.io = io;
9508       return this;
9509     }
9510 
9511     public void unsetIo() {
9512       this.io = null;
9513     }
9514 
9515     /** Returns true if field io is set (has been asigned a value) and false otherwise */
9516     public boolean isSetIo() {
9517       return this.io != null;
9518     }
9519 
9520     public void setIoIsSet(boolean value) {
9521       if (!value) {
9522         this.io = null;
9523       }
9524     }
9525 
9526     public void setFieldValue(_Fields field, Object value) {
9527       switch (field) {
9528       case IO:
9529         if (value == null) {
9530           unsetIo();
9531         } else {
9532           setIo((IOError)value);
9533         }
9534         break;
9535 
9536       }
9537     }
9538 
9539     public void setFieldValue(int fieldID, Object value) {
9540       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9541     }
9542 
9543     public Object getFieldValue(_Fields field) {
9544       switch (field) {
9545       case IO:
9546         return getIo();
9547 
9548       }
9549       throw new IllegalStateException();
9550     }
9551 
9552     public Object getFieldValue(int fieldId) {
9553       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9554     }
9555 
9556     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
9557     public boolean isSet(_Fields field) {
9558       switch (field) {
9559       case IO:
9560         return isSetIo();
9561       }
9562       throw new IllegalStateException();
9563     }
9564 
9565     public boolean isSet(int fieldID) {
9566       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9567     }
9568 
9569     @Override
9570     public boolean equals(Object that) {
9571       if (that == null)
9572         return false;
9573       if (that instanceof deleteTable_result)
9574         return this.equals((deleteTable_result)that);
9575       return false;
9576     }
9577 
9578     public boolean equals(deleteTable_result that) {
9579       if (that == null)
9580         return false;
9581 
9582       boolean this_present_io = true && this.isSetIo();
9583       boolean that_present_io = true && that.isSetIo();
9584       if (this_present_io || that_present_io) {
9585         if (!(this_present_io && that_present_io))
9586           return false;
9587         if (!this.io.equals(that.io))
9588           return false;
9589       }
9590 
9591       return true;
9592     }
9593 
9594     @Override
9595     public int hashCode() {
9596       HashCodeBuilder builder = new HashCodeBuilder();
9597 
9598       boolean present_io = true && (isSetIo());
9599       builder.append(present_io);
9600       if (present_io)
9601         builder.append(io);
9602 
9603       return builder.toHashCode();
9604     }
9605 
9606     public int compareTo(deleteTable_result other) {
9607       if (!getClass().equals(other.getClass())) {
9608         return getClass().getName().compareTo(other.getClass().getName());
9609       }
9610 
9611       int lastComparison = 0;
9612       deleteTable_result typedOther = (deleteTable_result)other;
9613 
9614       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
9615       if (lastComparison != 0) {
9616         return lastComparison;
9617       }
9618       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
9619       if (lastComparison != 0) {
9620         return lastComparison;
9621       }
9622       return 0;
9623     }
9624 
9625     public void read(TProtocol iprot) throws TException {
9626       TField field;
9627       iprot.readStructBegin();
9628       while (true)
9629       {
9630         field = iprot.readFieldBegin();
9631         if (field.type == TType.STOP) {
9632           break;
9633         }
9634         _Fields fieldId = _Fields.findByThriftId(field.id);
9635         if (fieldId == null) {
9636           TProtocolUtil.skip(iprot, field.type);
9637         } else {
9638           switch (fieldId) {
9639             case IO:
9640               if (field.type == TType.STRUCT) {
9641                 this.io = new IOError();
9642                 this.io.read(iprot);
9643               } else {
9644                 TProtocolUtil.skip(iprot, field.type);
9645               }
9646               break;
9647           }
9648           iprot.readFieldEnd();
9649         }
9650       }
9651       iprot.readStructEnd();
9652 
9653       // check for required fields of primitive type, which can't be checked in the validate method
9654       validate();
9655     }
9656 
9657     public void write(TProtocol oprot) throws TException {
9658       oprot.writeStructBegin(STRUCT_DESC);
9659 
9660       if (this.isSetIo()) {
9661         oprot.writeFieldBegin(IO_FIELD_DESC);
9662         this.io.write(oprot);
9663         oprot.writeFieldEnd();
9664       }
9665       oprot.writeFieldStop();
9666       oprot.writeStructEnd();
9667     }
9668 
9669     @Override
9670     public String toString() {
9671       StringBuilder sb = new StringBuilder("deleteTable_result(");
9672       boolean first = true;
9673 
9674       sb.append("io:");
9675       if (this.io == null) {
9676         sb.append("null");
9677       } else {
9678         sb.append(this.io);
9679       }
9680       first = false;
9681       sb.append(")");
9682       return sb.toString();
9683     }
9684 
9685     public void validate() throws TException {
9686       // check for required fields
9687     }
9688 
9689   }
9690 
9691   public static class get_args implements TBase<get_args._Fields>, java.io.Serializable, Cloneable, Comparable<get_args>   {
9692     private static final TStruct STRUCT_DESC = new TStruct("get_args");
9693 
9694     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
9695     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
9696     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
9697 
9698     /**
9699      * name of table
9700      */
9701     public byte[] tableName;
9702     /**
9703      * row key
9704      */
9705     public byte[] row;
9706     /**
9707      * column name
9708      */
9709     public byte[] column;
9710 
9711     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
9712     public enum _Fields implements TFieldIdEnum {
9713       /**
9714        * name of table
9715        */
9716       TABLE_NAME((short)1, "tableName"),
9717       /**
9718        * row key
9719        */
9720       ROW((short)2, "row"),
9721       /**
9722        * column name
9723        */
9724       COLUMN((short)3, "column");
9725 
9726       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9727       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9728 
9729       static {
9730         for (_Fields field : EnumSet.allOf(_Fields.class)) {
9731           byId.put((int)field._thriftId, field);
9732           byName.put(field.getFieldName(), field);
9733         }
9734       }
9735 
9736       /**
9737        * Find the _Fields constant that matches fieldId, or null if its not found.
9738        */
9739       public static _Fields findByThriftId(int fieldId) {
9740         return byId.get(fieldId);
9741       }
9742 
9743       /**
9744        * Find the _Fields constant that matches fieldId, throwing an exception
9745        * if it is not found.
9746        */
9747       public static _Fields findByThriftIdOrThrow(int fieldId) {
9748         _Fields fields = findByThriftId(fieldId);
9749         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9750         return fields;
9751       }
9752 
9753       /**
9754        * Find the _Fields constant that matches name, or null if its not found.
9755        */
9756       public static _Fields findByName(String name) {
9757         return byName.get(name);
9758       }
9759 
9760       private final short _thriftId;
9761       private final String _fieldName;
9762 
9763       _Fields(short thriftId, String fieldName) {
9764         _thriftId = thriftId;
9765         _fieldName = fieldName;
9766       }
9767 
9768       public short getThriftFieldId() {
9769         return _thriftId;
9770       }
9771 
9772       public String getFieldName() {
9773         return _fieldName;
9774       }
9775     }
9776 
9777     // isset id assignments
9778 
9779     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9780       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
9781           new FieldValueMetaData(TType.STRING)));
9782       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
9783           new FieldValueMetaData(TType.STRING)));
9784       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
9785           new FieldValueMetaData(TType.STRING)));
9786     }});
9787 
9788     static {
9789       FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
9790     }
9791 
9792     public get_args() {
9793     }
9794 
9795     public get_args(
9796       byte[] tableName,
9797       byte[] row,
9798       byte[] column)
9799     {
9800       this();
9801       this.tableName = tableName;
9802       this.row = row;
9803       this.column = column;
9804     }
9805 
9806     /**
9807      * Performs a deep copy on <i>other</i>.
9808      */
9809     public get_args(get_args other) {
9810       if (other.isSetTableName()) {
9811         this.tableName = other.tableName;
9812       }
9813       if (other.isSetRow()) {
9814         this.row = other.row;
9815       }
9816       if (other.isSetColumn()) {
9817         this.column = other.column;
9818       }
9819     }
9820 
9821     public get_args deepCopy() {
9822       return new get_args(this);
9823     }
9824 
9825     @Deprecated
9826     public get_args clone() {
9827       return new get_args(this);
9828     }
9829 
9830     /**
9831      * name of table
9832      */
9833     public byte[] getTableName() {
9834       return this.tableName;
9835     }
9836 
9837     /**
9838      * name of table
9839      */
9840     public get_args setTableName(byte[] tableName) {
9841       this.tableName = tableName;
9842       return this;
9843     }
9844 
9845     public void unsetTableName() {
9846       this.tableName = null;
9847     }
9848 
9849     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
9850     public boolean isSetTableName() {
9851       return this.tableName != null;
9852     }
9853 
9854     public void setTableNameIsSet(boolean value) {
9855       if (!value) {
9856         this.tableName = null;
9857       }
9858     }
9859 
9860     /**
9861      * row key
9862      */
9863     public byte[] getRow() {
9864       return this.row;
9865     }
9866 
9867     /**
9868      * row key
9869      */
9870     public get_args setRow(byte[] row) {
9871       this.row = row;
9872       return this;
9873     }
9874 
9875     public void unsetRow() {
9876       this.row = null;
9877     }
9878 
9879     /** Returns true if field row is set (has been asigned a value) and false otherwise */
9880     public boolean isSetRow() {
9881       return this.row != null;
9882     }
9883 
9884     public void setRowIsSet(boolean value) {
9885       if (!value) {
9886         this.row = null;
9887       }
9888     }
9889 
9890     /**
9891      * column name
9892      */
9893     public byte[] getColumn() {
9894       return this.column;
9895     }
9896 
9897     /**
9898      * column name
9899      */
9900     public get_args setColumn(byte[] column) {
9901       this.column = column;
9902       return this;
9903     }
9904 
9905     public void unsetColumn() {
9906       this.column = null;
9907     }
9908 
9909     /** Returns true if field column is set (has been asigned a value) and false otherwise */
9910     public boolean isSetColumn() {
9911       return this.column != null;
9912     }
9913 
9914     public void setColumnIsSet(boolean value) {
9915       if (!value) {
9916         this.column = null;
9917       }
9918     }
9919 
9920     public void setFieldValue(_Fields field, Object value) {
9921       switch (field) {
9922       case TABLE_NAME:
9923         if (value == null) {
9924           unsetTableName();
9925         } else {
9926           setTableName((byte[])value);
9927         }
9928         break;
9929 
9930       case ROW:
9931         if (value == null) {
9932           unsetRow();
9933         } else {
9934           setRow((byte[])value);
9935         }
9936         break;
9937 
9938       case COLUMN:
9939         if (value == null) {
9940           unsetColumn();
9941         } else {
9942           setColumn((byte[])value);
9943         }
9944         break;
9945 
9946       }
9947     }
9948 
9949     public void setFieldValue(int fieldID, Object value) {
9950       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9951     }
9952 
9953     public Object getFieldValue(_Fields field) {
9954       switch (field) {
9955       case TABLE_NAME:
9956         return getTableName();
9957 
9958       case ROW:
9959         return getRow();
9960 
9961       case COLUMN:
9962         return getColumn();
9963 
9964       }
9965       throw new IllegalStateException();
9966     }
9967 
9968     public Object getFieldValue(int fieldId) {
9969       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9970     }
9971 
9972     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
9973     public boolean isSet(_Fields field) {
9974       switch (field) {
9975       case TABLE_NAME:
9976         return isSetTableName();
9977       case ROW:
9978         return isSetRow();
9979       case COLUMN:
9980         return isSetColumn();
9981       }
9982       throw new IllegalStateException();
9983     }
9984 
9985     public boolean isSet(int fieldID) {
9986       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9987     }
9988 
9989     @Override
9990     public boolean equals(Object that) {
9991       if (that == null)
9992         return false;
9993       if (that instanceof get_args)
9994         return this.equals((get_args)that);
9995       return false;
9996     }
9997 
9998     public boolean equals(get_args that) {
9999       if (that == null)
10000         return false;
10001 
10002       boolean this_present_tableName = true && this.isSetTableName();
10003       boolean that_present_tableName = true && that.isSetTableName();
10004       if (this_present_tableName || that_present_tableName) {
10005         if (!(this_present_tableName && that_present_tableName))
10006           return false;
10007         if (!java.util.Arrays.equals(this.tableName, that.tableName))
10008           return false;
10009       }
10010 
10011       boolean this_present_row = true && this.isSetRow();
10012       boolean that_present_row = true && that.isSetRow();
10013       if (this_present_row || that_present_row) {
10014         if (!(this_present_row && that_present_row))
10015           return false;
10016         if (!java.util.Arrays.equals(this.row, that.row))
10017           return false;
10018       }
10019 
10020       boolean this_present_column = true && this.isSetColumn();
10021       boolean that_present_column = true && that.isSetColumn();
10022       if (this_present_column || that_present_column) {
10023         if (!(this_present_column && that_present_column))
10024           return false;
10025         if (!java.util.Arrays.equals(this.column, that.column))
10026           return false;
10027       }
10028 
10029       return true;
10030     }
10031 
10032     @Override
10033     public int hashCode() {
10034       HashCodeBuilder builder = new HashCodeBuilder();
10035 
10036       boolean present_tableName = true && (isSetTableName());
10037       builder.append(present_tableName);
10038       if (present_tableName)
10039         builder.append(tableName);
10040 
10041       boolean present_row = true && (isSetRow());
10042       builder.append(present_row);
10043       if (present_row)
10044         builder.append(row);
10045 
10046       boolean present_column = true && (isSetColumn());
10047       builder.append(present_column);
10048       if (present_column)
10049         builder.append(column);
10050 
10051       return builder.toHashCode();
10052     }
10053 
10054     public int compareTo(get_args other) {
10055       if (!getClass().equals(other.getClass())) {
10056         return getClass().getName().compareTo(other.getClass().getName());
10057       }
10058 
10059       int lastComparison = 0;
10060       get_args typedOther = (get_args)other;
10061 
10062       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
10063       if (lastComparison != 0) {
10064         return lastComparison;
10065       }
10066       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
10067       if (lastComparison != 0) {
10068         return lastComparison;
10069       }
10070       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
10071       if (lastComparison != 0) {
10072         return lastComparison;
10073       }
10074       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
10075       if (lastComparison != 0) {
10076         return lastComparison;
10077       }
10078       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
10079       if (lastComparison != 0) {
10080         return lastComparison;
10081       }
10082       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
10083       if (lastComparison != 0) {
10084         return lastComparison;
10085       }
10086       return 0;
10087     }
10088 
10089     public void read(TProtocol iprot) throws TException {
10090       TField field;
10091       iprot.readStructBegin();
10092       while (true)
10093       {
10094         field = iprot.readFieldBegin();
10095         if (field.type == TType.STOP) {
10096           break;
10097         }
10098         _Fields fieldId = _Fields.findByThriftId(field.id);
10099         if (fieldId == null) {
10100           TProtocolUtil.skip(iprot, field.type);
10101         } else {
10102           switch (fieldId) {
10103             case TABLE_NAME:
10104               if (field.type == TType.STRING) {
10105                 this.tableName = iprot.readBinary();
10106               } else {
10107                 TProtocolUtil.skip(iprot, field.type);
10108               }
10109               break;
10110             case ROW:
10111               if (field.type == TType.STRING) {
10112                 this.row = iprot.readBinary();
10113               } else {
10114                 TProtocolUtil.skip(iprot, field.type);
10115               }
10116               break;
10117             case COLUMN:
10118               if (field.type == TType.STRING) {
10119                 this.column = iprot.readBinary();
10120               } else {
10121                 TProtocolUtil.skip(iprot, field.type);
10122               }
10123               break;
10124           }
10125           iprot.readFieldEnd();
10126         }
10127       }
10128       iprot.readStructEnd();
10129 
10130       // check for required fields of primitive type, which can't be checked in the validate method
10131       validate();
10132     }
10133 
10134     public void write(TProtocol oprot) throws TException {
10135       validate();
10136 
10137       oprot.writeStructBegin(STRUCT_DESC);
10138       if (this.tableName != null) {
10139         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
10140         oprot.writeBinary(this.tableName);
10141         oprot.writeFieldEnd();
10142       }
10143       if (this.row != null) {
10144         oprot.writeFieldBegin(ROW_FIELD_DESC);
10145         oprot.writeBinary(this.row);
10146         oprot.writeFieldEnd();
10147       }
10148       if (this.column != null) {
10149         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
10150         oprot.writeBinary(this.column);
10151         oprot.writeFieldEnd();
10152       }
10153       oprot.writeFieldStop();
10154       oprot.writeStructEnd();
10155     }
10156 
10157     @Override
10158     public String toString() {
10159       StringBuilder sb = new StringBuilder("get_args(");
10160       boolean first = true;
10161 
10162       sb.append("tableName:");
10163       if (this.tableName == null) {
10164         sb.append("null");
10165       } else {
10166         sb.append(this.tableName);
10167       }
10168       first = false;
10169       if (!first) sb.append(", ");
10170       sb.append("row:");
10171       if (this.row == null) {
10172         sb.append("null");
10173       } else {
10174         sb.append(this.row);
10175       }
10176       first = false;
10177       if (!first) sb.append(", ");
10178       sb.append("column:");
10179       if (this.column == null) {
10180         sb.append("null");
10181       } else {
10182         sb.append(this.column);
10183       }
10184       first = false;
10185       sb.append(")");
10186       return sb.toString();
10187     }
10188 
10189     public void validate() throws TException {
10190       // check for required fields
10191     }
10192 
10193   }
10194 
10195   public static class get_result implements TBase<get_result._Fields>, java.io.Serializable, Cloneable, Comparable<get_result>   {
10196     private static final TStruct STRUCT_DESC = new TStruct("get_result");
10197 
10198     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
10199     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
10200 
10201     public List<TCell> success;
10202     public IOError io;
10203 
10204     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
10205     public enum _Fields implements TFieldIdEnum {
10206       SUCCESS((short)0, "success"),
10207       IO((short)1, "io");
10208 
10209       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
10210       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10211 
10212       static {
10213         for (_Fields field : EnumSet.allOf(_Fields.class)) {
10214           byId.put((int)field._thriftId, field);
10215           byName.put(field.getFieldName(), field);
10216         }
10217       }
10218 
10219       /**
10220        * Find the _Fields constant that matches fieldId, or null if its not found.
10221        */
10222       public static _Fields findByThriftId(int fieldId) {
10223         return byId.get(fieldId);
10224       }
10225 
10226       /**
10227        * Find the _Fields constant that matches fieldId, throwing an exception
10228        * if it is not found.
10229        */
10230       public static _Fields findByThriftIdOrThrow(int fieldId) {
10231         _Fields fields = findByThriftId(fieldId);
10232         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10233         return fields;
10234       }
10235 
10236       /**
10237        * Find the _Fields constant that matches name, or null if its not found.
10238        */
10239       public static _Fields findByName(String name) {
10240         return byName.get(name);
10241       }
10242 
10243       private final short _thriftId;
10244       private final String _fieldName;
10245 
10246       _Fields(short thriftId, String fieldName) {
10247         _thriftId = thriftId;
10248         _fieldName = fieldName;
10249       }
10250 
10251       public short getThriftFieldId() {
10252         return _thriftId;
10253       }
10254 
10255       public String getFieldName() {
10256         return _fieldName;
10257       }
10258     }
10259 
10260     // isset id assignments
10261 
10262     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
10263       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
10264           new ListMetaData(TType.LIST,
10265               new StructMetaData(TType.STRUCT, TCell.class))));
10266       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
10267           new FieldValueMetaData(TType.STRUCT)));
10268     }});
10269 
10270     static {
10271       FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
10272     }
10273 
10274     public get_result() {
10275     }
10276 
10277     public get_result(
10278       List<TCell> success,
10279       IOError io)
10280     {
10281       this();
10282       this.success = success;
10283       this.io = io;
10284     }
10285 
10286     /**
10287      * Performs a deep copy on <i>other</i>.
10288      */
10289     public get_result(get_result other) {
10290       if (other.isSetSuccess()) {
10291         List<TCell> __this__success = new ArrayList<TCell>();
10292         for (TCell other_element : other.success) {
10293           __this__success.add(new TCell(other_element));
10294         }
10295         this.success = __this__success;
10296       }
10297       if (other.isSetIo()) {
10298         this.io = new IOError(other.io);
10299       }
10300     }
10301 
10302     public get_result deepCopy() {
10303       return new get_result(this);
10304     }
10305 
10306     @Deprecated
10307     public get_result clone() {
10308       return new get_result(this);
10309     }
10310 
10311     public int getSuccessSize() {
10312       return (this.success == null) ? 0 : this.success.size();
10313     }
10314 
10315     public java.util.Iterator<TCell> getSuccessIterator() {
10316       return (this.success == null) ? null : this.success.iterator();
10317     }
10318 
10319     public void addToSuccess(TCell elem) {
10320       if (this.success == null) {
10321         this.success = new ArrayList<TCell>();
10322       }
10323       this.success.add(elem);
10324     }
10325 
10326     public List<TCell> getSuccess() {
10327       return this.success;
10328     }
10329 
10330     public get_result setSuccess(List<TCell> success) {
10331       this.success = success;
10332       return this;
10333     }
10334 
10335     public void unsetSuccess() {
10336       this.success = null;
10337     }
10338 
10339     /** Returns true if field success is set (has been asigned a value) and false otherwise */
10340     public boolean isSetSuccess() {
10341       return this.success != null;
10342     }
10343 
10344     public void setSuccessIsSet(boolean value) {
10345       if (!value) {
10346         this.success = null;
10347       }
10348     }
10349 
10350     public IOError getIo() {
10351       return this.io;
10352     }
10353 
10354     public get_result setIo(IOError io) {
10355       this.io = io;
10356       return this;
10357     }
10358 
10359     public void unsetIo() {
10360       this.io = null;
10361     }
10362 
10363     /** Returns true if field io is set (has been asigned a value) and false otherwise */
10364     public boolean isSetIo() {
10365       return this.io != null;
10366     }
10367 
10368     public void setIoIsSet(boolean value) {
10369       if (!value) {
10370         this.io = null;
10371       }
10372     }
10373 
10374     public void setFieldValue(_Fields field, Object value) {
10375       switch (field) {
10376       case SUCCESS:
10377         if (value == null) {
10378           unsetSuccess();
10379         } else {
10380           setSuccess((List<TCell>)value);
10381         }
10382         break;
10383 
10384       case IO:
10385         if (value == null) {
10386           unsetIo();
10387         } else {
10388           setIo((IOError)value);
10389         }
10390         break;
10391 
10392       }
10393     }
10394 
10395     public void setFieldValue(int fieldID, Object value) {
10396       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
10397     }
10398 
10399     public Object getFieldValue(_Fields field) {
10400       switch (field) {
10401       case SUCCESS:
10402         return getSuccess();
10403 
10404       case IO:
10405         return getIo();
10406 
10407       }
10408       throw new IllegalStateException();
10409     }
10410 
10411     public Object getFieldValue(int fieldId) {
10412       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
10413     }
10414 
10415     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
10416     public boolean isSet(_Fields field) {
10417       switch (field) {
10418       case SUCCESS:
10419         return isSetSuccess();
10420       case IO:
10421         return isSetIo();
10422       }
10423       throw new IllegalStateException();
10424     }
10425 
10426     public boolean isSet(int fieldID) {
10427       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
10428     }
10429 
10430     @Override
10431     public boolean equals(Object that) {
10432       if (that == null)
10433         return false;
10434       if (that instanceof get_result)
10435         return this.equals((get_result)that);
10436       return false;
10437     }
10438 
10439     public boolean equals(get_result that) {
10440       if (that == null)
10441         return false;
10442 
10443       boolean this_present_success = true && this.isSetSuccess();
10444       boolean that_present_success = true && that.isSetSuccess();
10445       if (this_present_success || that_present_success) {
10446         if (!(this_present_success && that_present_success))
10447           return false;
10448         if (!this.success.equals(that.success))
10449           return false;
10450       }
10451 
10452       boolean this_present_io = true && this.isSetIo();
10453       boolean that_present_io = true && that.isSetIo();
10454       if (this_present_io || that_present_io) {
10455         if (!(this_present_io && that_present_io))
10456           return false;
10457         if (!this.io.equals(that.io))
10458           return false;
10459       }
10460 
10461       return true;
10462     }
10463 
10464     @Override
10465     public int hashCode() {
10466       HashCodeBuilder builder = new HashCodeBuilder();
10467 
10468       boolean present_success = true && (isSetSuccess());
10469       builder.append(present_success);
10470       if (present_success)
10471         builder.append(success);
10472 
10473       boolean present_io = true && (isSetIo());
10474       builder.append(present_io);
10475       if (present_io)
10476         builder.append(io);
10477 
10478       return builder.toHashCode();
10479     }
10480 
10481     public int compareTo(get_result other) {
10482       if (!getClass().equals(other.getClass())) {
10483         return getClass().getName().compareTo(other.getClass().getName());
10484       }
10485 
10486       int lastComparison = 0;
10487       get_result typedOther = (get_result)other;
10488 
10489       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
10490       if (lastComparison != 0) {
10491         return lastComparison;
10492       }
10493       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
10494       if (lastComparison != 0) {
10495         return lastComparison;
10496       }
10497       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
10498       if (lastComparison != 0) {
10499         return lastComparison;
10500       }
10501       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
10502       if (lastComparison != 0) {
10503         return lastComparison;
10504       }
10505       return 0;
10506     }
10507 
10508     public void read(TProtocol iprot) throws TException {
10509       TField field;
10510       iprot.readStructBegin();
10511       while (true)
10512       {
10513         field = iprot.readFieldBegin();
10514         if (field.type == TType.STOP) {
10515           break;
10516         }
10517         _Fields fieldId = _Fields.findByThriftId(field.id);
10518         if (fieldId == null) {
10519           TProtocolUtil.skip(iprot, field.type);
10520         } else {
10521           switch (fieldId) {
10522             case SUCCESS:
10523               if (field.type == TType.LIST) {
10524                 {
10525                   TList _list26 = iprot.readListBegin();
10526                   this.success = new ArrayList<TCell>(_list26.size);
10527                   for (int _i27 = 0; _i27 < _list26.size; ++_i27)
10528                   {
10529                     TCell _elem28;
10530                     _elem28 = new TCell();
10531                     _elem28.read(iprot);
10532                     this.success.add(_elem28);
10533                   }
10534                   iprot.readListEnd();
10535                 }
10536               } else {
10537                 TProtocolUtil.skip(iprot, field.type);
10538               }
10539               break;
10540             case IO:
10541               if (field.type == TType.STRUCT) {
10542                 this.io = new IOError();
10543                 this.io.read(iprot);
10544               } else {
10545                 TProtocolUtil.skip(iprot, field.type);
10546               }
10547               break;
10548           }
10549           iprot.readFieldEnd();
10550         }
10551       }
10552       iprot.readStructEnd();
10553 
10554       // check for required fields of primitive type, which can't be checked in the validate method
10555       validate();
10556     }
10557 
10558     public void write(TProtocol oprot) throws TException {
10559       oprot.writeStructBegin(STRUCT_DESC);
10560 
10561       if (this.isSetSuccess()) {
10562         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
10563         {
10564           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
10565           for (TCell _iter29 : this.success)
10566           {
10567             _iter29.write(oprot);
10568           }
10569           oprot.writeListEnd();
10570         }
10571         oprot.writeFieldEnd();
10572       } else if (this.isSetIo()) {
10573         oprot.writeFieldBegin(IO_FIELD_DESC);
10574         this.io.write(oprot);
10575         oprot.writeFieldEnd();
10576       }
10577       oprot.writeFieldStop();
10578       oprot.writeStructEnd();
10579     }
10580 
10581     @Override
10582     public String toString() {
10583       StringBuilder sb = new StringBuilder("get_result(");
10584       boolean first = true;
10585 
10586       sb.append("success:");
10587       if (this.success == null) {
10588         sb.append("null");
10589       } else {
10590         sb.append(this.success);
10591       }
10592       first = false;
10593       if (!first) sb.append(", ");
10594       sb.append("io:");
10595       if (this.io == null) {
10596         sb.append("null");
10597       } else {
10598         sb.append(this.io);
10599       }
10600       first = false;
10601       sb.append(")");
10602       return sb.toString();
10603     }
10604 
10605     public void validate() throws TException {
10606       // check for required fields
10607     }
10608 
10609   }
10610 
10611   public static class getVer_args implements TBase<getVer_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_args>   {
10612     private static final TStruct STRUCT_DESC = new TStruct("getVer_args");
10613 
10614     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
10615     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
10616     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
10617     private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)4);
10618 
10619     /**
10620      * name of table
10621      */
10622     public byte[] tableName;
10623     /**
10624      * row key
10625      */
10626     public byte[] row;
10627     /**
10628      * column name
10629      */
10630     public byte[] column;
10631     /**
10632      * number of versions to retrieve
10633      */
10634     public int numVersions;
10635 
10636     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
10637     public enum _Fields implements TFieldIdEnum {
10638       /**
10639        * name of table
10640        */
10641       TABLE_NAME((short)1, "tableName"),
10642       /**
10643        * row key
10644        */
10645       ROW((short)2, "row"),
10646       /**
10647        * column name
10648        */
10649       COLUMN((short)3, "column"),
10650       /**
10651        * number of versions to retrieve
10652        */
10653       NUM_VERSIONS((short)4, "numVersions");
10654 
10655       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
10656       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10657 
10658       static {
10659         for (_Fields field : EnumSet.allOf(_Fields.class)) {
10660           byId.put((int)field._thriftId, field);
10661           byName.put(field.getFieldName(), field);
10662         }
10663       }
10664 
10665       /**
10666        * Find the _Fields constant that matches fieldId, or null if its not found.
10667        */
10668       public static _Fields findByThriftId(int fieldId) {
10669         return byId.get(fieldId);
10670       }
10671 
10672       /**
10673        * Find the _Fields constant that matches fieldId, throwing an exception
10674        * if it is not found.
10675        */
10676       public static _Fields findByThriftIdOrThrow(int fieldId) {
10677         _Fields fields = findByThriftId(fieldId);
10678         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10679         return fields;
10680       }
10681 
10682       /**
10683        * Find the _Fields constant that matches name, or null if its not found.
10684        */
10685       public static _Fields findByName(String name) {
10686         return byName.get(name);
10687       }
10688 
10689       private final short _thriftId;
10690       private final String _fieldName;
10691 
10692       _Fields(short thriftId, String fieldName) {
10693         _thriftId = thriftId;
10694         _fieldName = fieldName;
10695       }
10696 
10697       public short getThriftFieldId() {
10698         return _thriftId;
10699       }
10700 
10701       public String getFieldName() {
10702         return _fieldName;
10703       }
10704     }
10705 
10706     // isset id assignments
10707     private static final int __NUMVERSIONS_ISSET_ID = 0;
10708     private BitSet __isset_bit_vector = new BitSet(1);
10709 
10710     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
10711       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
10712           new FieldValueMetaData(TType.STRING)));
10713       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
10714           new FieldValueMetaData(TType.STRING)));
10715       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
10716           new FieldValueMetaData(TType.STRING)));
10717       put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT,
10718           new FieldValueMetaData(TType.I32)));
10719     }});
10720 
10721     static {
10722       FieldMetaData.addStructMetaDataMap(getVer_args.class, metaDataMap);
10723     }
10724 
10725     public getVer_args() {
10726     }
10727 
10728     public getVer_args(
10729       byte[] tableName,
10730       byte[] row,
10731       byte[] column,
10732       int numVersions)
10733     {
10734       this();
10735       this.tableName = tableName;
10736       this.row = row;
10737       this.column = column;
10738       this.numVersions = numVersions;
10739       setNumVersionsIsSet(true);
10740     }
10741 
10742     /**
10743      * Performs a deep copy on <i>other</i>.
10744      */
10745     public getVer_args(getVer_args other) {
10746       __isset_bit_vector.clear();
10747       __isset_bit_vector.or(other.__isset_bit_vector);
10748       if (other.isSetTableName()) {
10749         this.tableName = other.tableName;
10750       }
10751       if (other.isSetRow()) {
10752         this.row = other.row;
10753       }
10754       if (other.isSetColumn()) {
10755         this.column = other.column;
10756       }
10757       this.numVersions = other.numVersions;
10758     }
10759 
10760     public getVer_args deepCopy() {
10761       return new getVer_args(this);
10762     }
10763 
10764     @Deprecated
10765     public getVer_args clone() {
10766       return new getVer_args(this);
10767     }
10768 
10769     /**
10770      * name of table
10771      */
10772     public byte[] getTableName() {
10773       return this.tableName;
10774     }
10775 
10776     /**
10777      * name of table
10778      */
10779     public getVer_args setTableName(byte[] tableName) {
10780       this.tableName = tableName;
10781       return this;
10782     }
10783 
10784     public void unsetTableName() {
10785       this.tableName = null;
10786     }
10787 
10788     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
10789     public boolean isSetTableName() {
10790       return this.tableName != null;
10791     }
10792 
10793     public void setTableNameIsSet(boolean value) {
10794       if (!value) {
10795         this.tableName = null;
10796       }
10797     }
10798 
10799     /**
10800      * row key
10801      */
10802     public byte[] getRow() {
10803       return this.row;
10804     }
10805 
10806     /**
10807      * row key
10808      */
10809     public getVer_args setRow(byte[] row) {
10810       this.row = row;
10811       return this;
10812     }
10813 
10814     public void unsetRow() {
10815       this.row = null;
10816     }
10817 
10818     /** Returns true if field row is set (has been asigned a value) and false otherwise */
10819     public boolean isSetRow() {
10820       return this.row != null;
10821     }
10822 
10823     public void setRowIsSet(boolean value) {
10824       if (!value) {
10825         this.row = null;
10826       }
10827     }
10828 
10829     /**
10830      * column name
10831      */
10832     public byte[] getColumn() {
10833       return this.column;
10834     }
10835 
10836     /**
10837      * column name
10838      */
10839     public getVer_args setColumn(byte[] column) {
10840       this.column = column;
10841       return this;
10842     }
10843 
10844     public void unsetColumn() {
10845       this.column = null;
10846     }
10847 
10848     /** Returns true if field column is set (has been asigned a value) and false otherwise */
10849     public boolean isSetColumn() {
10850       return this.column != null;
10851     }
10852 
10853     public void setColumnIsSet(boolean value) {
10854       if (!value) {
10855         this.column = null;
10856       }
10857     }
10858 
10859     /**
10860      * number of versions to retrieve
10861      */
10862     public int getNumVersions() {
10863       return this.numVersions;
10864     }
10865 
10866     /**
10867      * number of versions to retrieve
10868      */
10869     public getVer_args setNumVersions(int numVersions) {
10870       this.numVersions = numVersions;
10871       setNumVersionsIsSet(true);
10872       return this;
10873     }
10874 
10875     public void unsetNumVersions() {
10876       __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID);
10877     }
10878 
10879     /** Returns true if field numVersions is set (has been asigned a value) and false otherwise */
10880     public boolean isSetNumVersions() {
10881       return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID);
10882     }
10883 
10884     public void setNumVersionsIsSet(boolean value) {
10885       __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value);
10886     }
10887 
10888     public void setFieldValue(_Fields field, Object value) {
10889       switch (field) {
10890       case TABLE_NAME:
10891         if (value == null) {
10892           unsetTableName();
10893         } else {
10894           setTableName((byte[])value);
10895         }
10896         break;
10897 
10898       case ROW:
10899         if (value == null) {
10900           unsetRow();
10901         } else {
10902           setRow((byte[])value);
10903         }
10904         break;
10905 
10906       case COLUMN:
10907         if (value == null) {
10908           unsetColumn();
10909         } else {
10910           setColumn((byte[])value);
10911         }
10912         break;
10913 
10914       case NUM_VERSIONS:
10915         if (value == null) {
10916           unsetNumVersions();
10917         } else {
10918           setNumVersions((Integer)value);
10919         }
10920         break;
10921 
10922       }
10923     }
10924 
10925     public void setFieldValue(int fieldID, Object value) {
10926       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
10927     }
10928 
10929     public Object getFieldValue(_Fields field) {
10930       switch (field) {
10931       case TABLE_NAME:
10932         return getTableName();
10933 
10934       case ROW:
10935         return getRow();
10936 
10937       case COLUMN:
10938         return getColumn();
10939 
10940       case NUM_VERSIONS:
10941         return new Integer(getNumVersions());
10942 
10943       }
10944       throw new IllegalStateException();
10945     }
10946 
10947     public Object getFieldValue(int fieldId) {
10948       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
10949     }
10950 
10951     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
10952     public boolean isSet(_Fields field) {
10953       switch (field) {
10954       case TABLE_NAME:
10955         return isSetTableName();
10956       case ROW:
10957         return isSetRow();
10958       case COLUMN:
10959         return isSetColumn();
10960       case NUM_VERSIONS:
10961         return isSetNumVersions();
10962       }
10963       throw new IllegalStateException();
10964     }
10965 
10966     public boolean isSet(int fieldID) {
10967       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
10968     }
10969 
10970     @Override
10971     public boolean equals(Object that) {
10972       if (that == null)
10973         return false;
10974       if (that instanceof getVer_args)
10975         return this.equals((getVer_args)that);
10976       return false;
10977     }
10978 
10979     public boolean equals(getVer_args that) {
10980       if (that == null)
10981         return false;
10982 
10983       boolean this_present_tableName = true && this.isSetTableName();
10984       boolean that_present_tableName = true && that.isSetTableName();
10985       if (this_present_tableName || that_present_tableName) {
10986         if (!(this_present_tableName && that_present_tableName))
10987           return false;
10988         if (!java.util.Arrays.equals(this.tableName, that.tableName))
10989           return false;
10990       }
10991 
10992       boolean this_present_row = true && this.isSetRow();
10993       boolean that_present_row = true && that.isSetRow();
10994       if (this_present_row || that_present_row) {
10995         if (!(this_present_row && that_present_row))
10996           return false;
10997         if (!java.util.Arrays.equals(this.row, that.row))
10998           return false;
10999       }
11000 
11001       boolean this_present_column = true && this.isSetColumn();
11002       boolean that_present_column = true && that.isSetColumn();
11003       if (this_present_column || that_present_column) {
11004         if (!(this_present_column && that_present_column))
11005           return false;
11006         if (!java.util.Arrays.equals(this.column, that.column))
11007           return false;
11008       }
11009 
11010       boolean this_present_numVersions = true;
11011       boolean that_present_numVersions = true;
11012       if (this_present_numVersions || that_present_numVersions) {
11013         if (!(this_present_numVersions && that_present_numVersions))
11014           return false;
11015         if (this.numVersions != that.numVersions)
11016           return false;
11017       }
11018 
11019       return true;
11020     }
11021 
11022     @Override
11023     public int hashCode() {
11024       HashCodeBuilder builder = new HashCodeBuilder();
11025 
11026       boolean present_tableName = true && (isSetTableName());
11027       builder.append(present_tableName);
11028       if (present_tableName)
11029         builder.append(tableName);
11030 
11031       boolean present_row = true && (isSetRow());
11032       builder.append(present_row);
11033       if (present_row)
11034         builder.append(row);
11035 
11036       boolean present_column = true && (isSetColumn());
11037       builder.append(present_column);
11038       if (present_column)
11039         builder.append(column);
11040 
11041       boolean present_numVersions = true;
11042       builder.append(present_numVersions);
11043       if (present_numVersions)
11044         builder.append(numVersions);
11045 
11046       return builder.toHashCode();
11047     }
11048 
11049     public int compareTo(getVer_args other) {
11050       if (!getClass().equals(other.getClass())) {
11051         return getClass().getName().compareTo(other.getClass().getName());
11052       }
11053 
11054       int lastComparison = 0;
11055       getVer_args typedOther = (getVer_args)other;
11056 
11057       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
11058       if (lastComparison != 0) {
11059         return lastComparison;
11060       }
11061       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
11062       if (lastComparison != 0) {
11063         return lastComparison;
11064       }
11065       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
11066       if (lastComparison != 0) {
11067         return lastComparison;
11068       }
11069       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
11070       if (lastComparison != 0) {
11071         return lastComparison;
11072       }
11073       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
11074       if (lastComparison != 0) {
11075         return lastComparison;
11076       }
11077       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
11078       if (lastComparison != 0) {
11079         return lastComparison;
11080       }
11081       lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(isSetNumVersions());
11082       if (lastComparison != 0) {
11083         return lastComparison;
11084       }
11085       lastComparison = TBaseHelper.compareTo(numVersions, typedOther.numVersions);
11086       if (lastComparison != 0) {
11087         return lastComparison;
11088       }
11089       return 0;
11090     }
11091 
11092     public void read(TProtocol iprot) throws TException {
11093       TField field;
11094       iprot.readStructBegin();
11095       while (true)
11096       {
11097         field = iprot.readFieldBegin();
11098         if (field.type == TType.STOP) {
11099           break;
11100         }
11101         _Fields fieldId = _Fields.findByThriftId(field.id);
11102         if (fieldId == null) {
11103           TProtocolUtil.skip(iprot, field.type);
11104         } else {
11105           switch (fieldId) {
11106             case TABLE_NAME:
11107               if (field.type == TType.STRING) {
11108                 this.tableName = iprot.readBinary();
11109               } else {
11110                 TProtocolUtil.skip(iprot, field.type);
11111               }
11112               break;
11113             case ROW:
11114               if (field.type == TType.STRING) {
11115                 this.row = iprot.readBinary();
11116               } else {
11117                 TProtocolUtil.skip(iprot, field.type);
11118               }
11119               break;
11120             case COLUMN:
11121               if (field.type == TType.STRING) {
11122                 this.column = iprot.readBinary();
11123               } else {
11124                 TProtocolUtil.skip(iprot, field.type);
11125               }
11126               break;
11127             case NUM_VERSIONS:
11128               if (field.type == TType.I32) {
11129                 this.numVersions = iprot.readI32();
11130                 setNumVersionsIsSet(true);
11131               } else {
11132                 TProtocolUtil.skip(iprot, field.type);
11133               }
11134               break;
11135           }
11136           iprot.readFieldEnd();
11137         }
11138       }
11139       iprot.readStructEnd();
11140 
11141       // check for required fields of primitive type, which can't be checked in the validate method
11142       validate();
11143     }
11144 
11145     public void write(TProtocol oprot) throws TException {
11146       validate();
11147 
11148       oprot.writeStructBegin(STRUCT_DESC);
11149       if (this.tableName != null) {
11150         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
11151         oprot.writeBinary(this.tableName);
11152         oprot.writeFieldEnd();
11153       }
11154       if (this.row != null) {
11155         oprot.writeFieldBegin(ROW_FIELD_DESC);
11156         oprot.writeBinary(this.row);
11157         oprot.writeFieldEnd();
11158       }
11159       if (this.column != null) {
11160         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
11161         oprot.writeBinary(this.column);
11162         oprot.writeFieldEnd();
11163       }
11164       oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
11165       oprot.writeI32(this.numVersions);
11166       oprot.writeFieldEnd();
11167       oprot.writeFieldStop();
11168       oprot.writeStructEnd();
11169     }
11170 
11171     @Override
11172     public String toString() {
11173       StringBuilder sb = new StringBuilder("getVer_args(");
11174       boolean first = true;
11175 
11176       sb.append("tableName:");
11177       if (this.tableName == null) {
11178         sb.append("null");
11179       } else {
11180         sb.append(this.tableName);
11181       }
11182       first = false;
11183       if (!first) sb.append(", ");
11184       sb.append("row:");
11185       if (this.row == null) {
11186         sb.append("null");
11187       } else {
11188         sb.append(this.row);
11189       }
11190       first = false;
11191       if (!first) sb.append(", ");
11192       sb.append("column:");
11193       if (this.column == null) {
11194         sb.append("null");
11195       } else {
11196         sb.append(this.column);
11197       }
11198       first = false;
11199       if (!first) sb.append(", ");
11200       sb.append("numVersions:");
11201       sb.append(this.numVersions);
11202       first = false;
11203       sb.append(")");
11204       return sb.toString();
11205     }
11206 
11207     public void validate() throws TException {
11208       // check for required fields
11209     }
11210 
11211   }
11212 
11213   public static class getVer_result implements TBase<getVer_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_result>   {
11214     private static final TStruct STRUCT_DESC = new TStruct("getVer_result");
11215 
11216     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
11217     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
11218 
11219     public List<TCell> success;
11220     public IOError io;
11221 
11222     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
11223     public enum _Fields implements TFieldIdEnum {
11224       SUCCESS((short)0, "success"),
11225       IO((short)1, "io");
11226 
11227       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
11228       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11229 
11230       static {
11231         for (_Fields field : EnumSet.allOf(_Fields.class)) {
11232           byId.put((int)field._thriftId, field);
11233           byName.put(field.getFieldName(), field);
11234         }
11235       }
11236 
11237       /**
11238        * Find the _Fields constant that matches fieldId, or null if its not found.
11239        */
11240       public static _Fields findByThriftId(int fieldId) {
11241         return byId.get(fieldId);
11242       }
11243 
11244       /**
11245        * Find the _Fields constant that matches fieldId, throwing an exception
11246        * if it is not found.
11247        */
11248       public static _Fields findByThriftIdOrThrow(int fieldId) {
11249         _Fields fields = findByThriftId(fieldId);
11250         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11251         return fields;
11252       }
11253 
11254       /**
11255        * Find the _Fields constant that matches name, or null if its not found.
11256        */
11257       public static _Fields findByName(String name) {
11258         return byName.get(name);
11259       }
11260 
11261       private final short _thriftId;
11262       private final String _fieldName;
11263 
11264       _Fields(short thriftId, String fieldName) {
11265         _thriftId = thriftId;
11266         _fieldName = fieldName;
11267       }
11268 
11269       public short getThriftFieldId() {
11270         return _thriftId;
11271       }
11272 
11273       public String getFieldName() {
11274         return _fieldName;
11275       }
11276     }
11277 
11278     // isset id assignments
11279 
11280     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
11281       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
11282           new ListMetaData(TType.LIST,
11283               new StructMetaData(TType.STRUCT, TCell.class))));
11284       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
11285           new FieldValueMetaData(TType.STRUCT)));
11286     }});
11287 
11288     static {
11289       FieldMetaData.addStructMetaDataMap(getVer_result.class, metaDataMap);
11290     }
11291 
11292     public getVer_result() {
11293     }
11294 
11295     public getVer_result(
11296       List<TCell> success,
11297       IOError io)
11298     {
11299       this();
11300       this.success = success;
11301       this.io = io;
11302     }
11303 
11304     /**
11305      * Performs a deep copy on <i>other</i>.
11306      */
11307     public getVer_result(getVer_result other) {
11308       if (other.isSetSuccess()) {
11309         List<TCell> __this__success = new ArrayList<TCell>();
11310         for (TCell other_element : other.success) {
11311           __this__success.add(new TCell(other_element));
11312         }
11313         this.success = __this__success;
11314       }
11315       if (other.isSetIo()) {
11316         this.io = new IOError(other.io);
11317       }
11318     }
11319 
11320     public getVer_result deepCopy() {
11321       return new getVer_result(this);
11322     }
11323 
11324     @Deprecated
11325     public getVer_result clone() {
11326       return new getVer_result(this);
11327     }
11328 
11329     public int getSuccessSize() {
11330       return (this.success == null) ? 0 : this.success.size();
11331     }
11332 
11333     public java.util.Iterator<TCell> getSuccessIterator() {
11334       return (this.success == null) ? null : this.success.iterator();
11335     }
11336 
11337     public void addToSuccess(TCell elem) {
11338       if (this.success == null) {
11339         this.success = new ArrayList<TCell>();
11340       }
11341       this.success.add(elem);
11342     }
11343 
11344     public List<TCell> getSuccess() {
11345       return this.success;
11346     }
11347 
11348     public getVer_result setSuccess(List<TCell> success) {
11349       this.success = success;
11350       return this;
11351     }
11352 
11353     public void unsetSuccess() {
11354       this.success = null;
11355     }
11356 
11357     /** Returns true if field success is set (has been asigned a value) and false otherwise */
11358     public boolean isSetSuccess() {
11359       return this.success != null;
11360     }
11361 
11362     public void setSuccessIsSet(boolean value) {
11363       if (!value) {
11364         this.success = null;
11365       }
11366     }
11367 
11368     public IOError getIo() {
11369       return this.io;
11370     }
11371 
11372     public getVer_result setIo(IOError io) {
11373       this.io = io;
11374       return this;
11375     }
11376 
11377     public void unsetIo() {
11378       this.io = null;
11379     }
11380 
11381     /** Returns true if field io is set (has been asigned a value) and false otherwise */
11382     public boolean isSetIo() {
11383       return this.io != null;
11384     }
11385 
11386     public void setIoIsSet(boolean value) {
11387       if (!value) {
11388         this.io = null;
11389       }
11390     }
11391 
11392     public void setFieldValue(_Fields field, Object value) {
11393       switch (field) {
11394       case SUCCESS:
11395         if (value == null) {
11396           unsetSuccess();
11397         } else {
11398           setSuccess((List<TCell>)value);
11399         }
11400         break;
11401 
11402       case IO:
11403         if (value == null) {
11404           unsetIo();
11405         } else {
11406           setIo((IOError)value);
11407         }
11408         break;
11409 
11410       }
11411     }
11412 
11413     public void setFieldValue(int fieldID, Object value) {
11414       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
11415     }
11416 
11417     public Object getFieldValue(_Fields field) {
11418       switch (field) {
11419       case SUCCESS:
11420         return getSuccess();
11421 
11422       case IO:
11423         return getIo();
11424 
11425       }
11426       throw new IllegalStateException();
11427     }
11428 
11429     public Object getFieldValue(int fieldId) {
11430       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
11431     }
11432 
11433     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
11434     public boolean isSet(_Fields field) {
11435       switch (field) {
11436       case SUCCESS:
11437         return isSetSuccess();
11438       case IO:
11439         return isSetIo();
11440       }
11441       throw new IllegalStateException();
11442     }
11443 
11444     public boolean isSet(int fieldID) {
11445       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
11446     }
11447 
11448     @Override
11449     public boolean equals(Object that) {
11450       if (that == null)
11451         return false;
11452       if (that instanceof getVer_result)
11453         return this.equals((getVer_result)that);
11454       return false;
11455     }
11456 
11457     public boolean equals(getVer_result that) {
11458       if (that == null)
11459         return false;
11460 
11461       boolean this_present_success = true && this.isSetSuccess();
11462       boolean that_present_success = true && that.isSetSuccess();
11463       if (this_present_success || that_present_success) {
11464         if (!(this_present_success && that_present_success))
11465           return false;
11466         if (!this.success.equals(that.success))
11467           return false;
11468       }
11469 
11470       boolean this_present_io = true && this.isSetIo();
11471       boolean that_present_io = true && that.isSetIo();
11472       if (this_present_io || that_present_io) {
11473         if (!(this_present_io && that_present_io))
11474           return false;
11475         if (!this.io.equals(that.io))
11476           return false;
11477       }
11478 
11479       return true;
11480     }
11481 
11482     @Override
11483     public int hashCode() {
11484       HashCodeBuilder builder = new HashCodeBuilder();
11485 
11486       boolean present_success = true && (isSetSuccess());
11487       builder.append(present_success);
11488       if (present_success)
11489         builder.append(success);
11490 
11491       boolean present_io = true && (isSetIo());
11492       builder.append(present_io);
11493       if (present_io)
11494         builder.append(io);
11495 
11496       return builder.toHashCode();
11497     }
11498 
11499     public int compareTo(getVer_result other) {
11500       if (!getClass().equals(other.getClass())) {
11501         return getClass().getName().compareTo(other.getClass().getName());
11502       }
11503 
11504       int lastComparison = 0;
11505       getVer_result typedOther = (getVer_result)other;
11506 
11507       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
11508       if (lastComparison != 0) {
11509         return lastComparison;
11510       }
11511       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
11512       if (lastComparison != 0) {
11513         return lastComparison;
11514       }
11515       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
11516       if (lastComparison != 0) {
11517         return lastComparison;
11518       }
11519       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
11520       if (lastComparison != 0) {
11521         return lastComparison;
11522       }
11523       return 0;
11524     }
11525 
11526     public void read(TProtocol iprot) throws TException {
11527       TField field;
11528       iprot.readStructBegin();
11529       while (true)
11530       {
11531         field = iprot.readFieldBegin();
11532         if (field.type == TType.STOP) {
11533           break;
11534         }
11535         _Fields fieldId = _Fields.findByThriftId(field.id);
11536         if (fieldId == null) {
11537           TProtocolUtil.skip(iprot, field.type);
11538         } else {
11539           switch (fieldId) {
11540             case SUCCESS:
11541               if (field.type == TType.LIST) {
11542                 {
11543                   TList _list30 = iprot.readListBegin();
11544                   this.success = new ArrayList<TCell>(_list30.size);
11545                   for (int _i31 = 0; _i31 < _list30.size; ++_i31)
11546                   {
11547                     TCell _elem32;
11548                     _elem32 = new TCell();
11549                     _elem32.read(iprot);
11550                     this.success.add(_elem32);
11551                   }
11552                   iprot.readListEnd();
11553                 }
11554               } else {
11555                 TProtocolUtil.skip(iprot, field.type);
11556               }
11557               break;
11558             case IO:
11559               if (field.type == TType.STRUCT) {
11560                 this.io = new IOError();
11561                 this.io.read(iprot);
11562               } else {
11563                 TProtocolUtil.skip(iprot, field.type);
11564               }
11565               break;
11566           }
11567           iprot.readFieldEnd();
11568         }
11569       }
11570       iprot.readStructEnd();
11571 
11572       // check for required fields of primitive type, which can't be checked in the validate method
11573       validate();
11574     }
11575 
11576     public void write(TProtocol oprot) throws TException {
11577       oprot.writeStructBegin(STRUCT_DESC);
11578 
11579       if (this.isSetSuccess()) {
11580         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11581         {
11582           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
11583           for (TCell _iter33 : this.success)
11584           {
11585             _iter33.write(oprot);
11586           }
11587           oprot.writeListEnd();
11588         }
11589         oprot.writeFieldEnd();
11590       } else if (this.isSetIo()) {
11591         oprot.writeFieldBegin(IO_FIELD_DESC);
11592         this.io.write(oprot);
11593         oprot.writeFieldEnd();
11594       }
11595       oprot.writeFieldStop();
11596       oprot.writeStructEnd();
11597     }
11598 
11599     @Override
11600     public String toString() {
11601       StringBuilder sb = new StringBuilder("getVer_result(");
11602       boolean first = true;
11603 
11604       sb.append("success:");
11605       if (this.success == null) {
11606         sb.append("null");
11607       } else {
11608         sb.append(this.success);
11609       }
11610       first = false;
11611       if (!first) sb.append(", ");
11612       sb.append("io:");
11613       if (this.io == null) {
11614         sb.append("null");
11615       } else {
11616         sb.append(this.io);
11617       }
11618       first = false;
11619       sb.append(")");
11620       return sb.toString();
11621     }
11622 
11623     public void validate() throws TException {
11624       // check for required fields
11625     }
11626 
11627   }
11628 
11629   public static class getVerTs_args implements TBase<getVerTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_args>   {
11630     private static final TStruct STRUCT_DESC = new TStruct("getVerTs_args");
11631 
11632     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
11633     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
11634     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
11635     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
11636     private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)5);
11637 
11638     /**
11639      * name of table
11640      */
11641     public byte[] tableName;
11642     /**
11643      * row key
11644      */
11645     public byte[] row;
11646     /**
11647      * column name
11648      */
11649     public byte[] column;
11650     /**
11651      * timestamp
11652      */
11653     public long timestamp;
11654     /**
11655      * number of versions to retrieve
11656      */
11657     public int numVersions;
11658 
11659     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
11660     public enum _Fields implements TFieldIdEnum {
11661       /**
11662        * name of table
11663        */
11664       TABLE_NAME((short)1, "tableName"),
11665       /**
11666        * row key
11667        */
11668       ROW((short)2, "row"),
11669       /**
11670        * column name
11671        */
11672       COLUMN((short)3, "column"),
11673       /**
11674        * timestamp
11675        */
11676       TIMESTAMP((short)4, "timestamp"),
11677       /**
11678        * number of versions to retrieve
11679        */
11680       NUM_VERSIONS((short)5, "numVersions");
11681 
11682       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
11683       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11684 
11685       static {
11686         for (_Fields field : EnumSet.allOf(_Fields.class)) {
11687           byId.put((int)field._thriftId, field);
11688           byName.put(field.getFieldName(), field);
11689         }
11690       }
11691 
11692       /**
11693        * Find the _Fields constant that matches fieldId, or null if its not found.
11694        */
11695       public static _Fields findByThriftId(int fieldId) {
11696         return byId.get(fieldId);
11697       }
11698 
11699       /**
11700        * Find the _Fields constant that matches fieldId, throwing an exception
11701        * if it is not found.
11702        */
11703       public static _Fields findByThriftIdOrThrow(int fieldId) {
11704         _Fields fields = findByThriftId(fieldId);
11705         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11706         return fields;
11707       }
11708 
11709       /**
11710        * Find the _Fields constant that matches name, or null if its not found.
11711        */
11712       public static _Fields findByName(String name) {
11713         return byName.get(name);
11714       }
11715 
11716       private final short _thriftId;
11717       private final String _fieldName;
11718 
11719       _Fields(short thriftId, String fieldName) {
11720         _thriftId = thriftId;
11721         _fieldName = fieldName;
11722       }
11723 
11724       public short getThriftFieldId() {
11725         return _thriftId;
11726       }
11727 
11728       public String getFieldName() {
11729         return _fieldName;
11730       }
11731     }
11732 
11733     // isset id assignments
11734     private static final int __TIMESTAMP_ISSET_ID = 0;
11735     private static final int __NUMVERSIONS_ISSET_ID = 1;
11736     private BitSet __isset_bit_vector = new BitSet(2);
11737 
11738     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
11739       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
11740           new FieldValueMetaData(TType.STRING)));
11741       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
11742           new FieldValueMetaData(TType.STRING)));
11743       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
11744           new FieldValueMetaData(TType.STRING)));
11745       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
11746           new FieldValueMetaData(TType.I64)));
11747       put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT,
11748           new FieldValueMetaData(TType.I32)));
11749     }});
11750 
11751     static {
11752       FieldMetaData.addStructMetaDataMap(getVerTs_args.class, metaDataMap);
11753     }
11754 
11755     public getVerTs_args() {
11756     }
11757 
11758     public getVerTs_args(
11759       byte[] tableName,
11760       byte[] row,
11761       byte[] column,
11762       long timestamp,
11763       int numVersions)
11764     {
11765       this();
11766       this.tableName = tableName;
11767       this.row = row;
11768       this.column = column;
11769       this.timestamp = timestamp;
11770       setTimestampIsSet(true);
11771       this.numVersions = numVersions;
11772       setNumVersionsIsSet(true);
11773     }
11774 
11775     /**
11776      * Performs a deep copy on <i>other</i>.
11777      */
11778     public getVerTs_args(getVerTs_args other) {
11779       __isset_bit_vector.clear();
11780       __isset_bit_vector.or(other.__isset_bit_vector);
11781       if (other.isSetTableName()) {
11782         this.tableName = other.tableName;
11783       }
11784       if (other.isSetRow()) {
11785         this.row = other.row;
11786       }
11787       if (other.isSetColumn()) {
11788         this.column = other.column;
11789       }
11790       this.timestamp = other.timestamp;
11791       this.numVersions = other.numVersions;
11792     }
11793 
11794     public getVerTs_args deepCopy() {
11795       return new getVerTs_args(this);
11796     }
11797 
11798     @Deprecated
11799     public getVerTs_args clone() {
11800       return new getVerTs_args(this);
11801     }
11802 
11803     /**
11804      * name of table
11805      */
11806     public byte[] getTableName() {
11807       return this.tableName;
11808     }
11809 
11810     /**
11811      * name of table
11812      */
11813     public getVerTs_args setTableName(byte[] tableName) {
11814       this.tableName = tableName;
11815       return this;
11816     }
11817 
11818     public void unsetTableName() {
11819       this.tableName = null;
11820     }
11821 
11822     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
11823     public boolean isSetTableName() {
11824       return this.tableName != null;
11825     }
11826 
11827     public void setTableNameIsSet(boolean value) {
11828       if (!value) {
11829         this.tableName = null;
11830       }
11831     }
11832 
11833     /**
11834      * row key
11835      */
11836     public byte[] getRow() {
11837       return this.row;
11838     }
11839 
11840     /**
11841      * row key
11842      */
11843     public getVerTs_args setRow(byte[] row) {
11844       this.row = row;
11845       return this;
11846     }
11847 
11848     public void unsetRow() {
11849       this.row = null;
11850     }
11851 
11852     /** Returns true if field row is set (has been asigned a value) and false otherwise */
11853     public boolean isSetRow() {
11854       return this.row != null;
11855     }
11856 
11857     public void setRowIsSet(boolean value) {
11858       if (!value) {
11859         this.row = null;
11860       }
11861     }
11862 
11863     /**
11864      * column name
11865      */
11866     public byte[] getColumn() {
11867       return this.column;
11868     }
11869 
11870     /**
11871      * column name
11872      */
11873     public getVerTs_args setColumn(byte[] column) {
11874       this.column = column;
11875       return this;
11876     }
11877 
11878     public void unsetColumn() {
11879       this.column = null;
11880     }
11881 
11882     /** Returns true if field column is set (has been asigned a value) and false otherwise */
11883     public boolean isSetColumn() {
11884       return this.column != null;
11885     }
11886 
11887     public void setColumnIsSet(boolean value) {
11888       if (!value) {
11889         this.column = null;
11890       }
11891     }
11892 
11893     /**
11894      * timestamp
11895      */
11896     public long getTimestamp() {
11897       return this.timestamp;
11898     }
11899 
11900     /**
11901      * timestamp
11902      */
11903     public getVerTs_args setTimestamp(long timestamp) {
11904       this.timestamp = timestamp;
11905       setTimestampIsSet(true);
11906       return this;
11907     }
11908 
11909     public void unsetTimestamp() {
11910       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
11911     }
11912 
11913     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
11914     public boolean isSetTimestamp() {
11915       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
11916     }
11917 
11918     public void setTimestampIsSet(boolean value) {
11919       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
11920     }
11921 
11922     /**
11923      * number of versions to retrieve
11924      */
11925     public int getNumVersions() {
11926       return this.numVersions;
11927     }
11928 
11929     /**
11930      * number of versions to retrieve
11931      */
11932     public getVerTs_args setNumVersions(int numVersions) {
11933       this.numVersions = numVersions;
11934       setNumVersionsIsSet(true);
11935       return this;
11936     }
11937 
11938     public void unsetNumVersions() {
11939       __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID);
11940     }
11941 
11942     /** Returns true if field numVersions is set (has been asigned a value) and false otherwise */
11943     public boolean isSetNumVersions() {
11944       return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID);
11945     }
11946 
11947     public void setNumVersionsIsSet(boolean value) {
11948       __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value);
11949     }
11950 
11951     public void setFieldValue(_Fields field, Object value) {
11952       switch (field) {
11953       case TABLE_NAME:
11954         if (value == null) {
11955           unsetTableName();
11956         } else {
11957           setTableName((byte[])value);
11958         }
11959         break;
11960 
11961       case ROW:
11962         if (value == null) {
11963           unsetRow();
11964         } else {
11965           setRow((byte[])value);
11966         }
11967         break;
11968 
11969       case COLUMN:
11970         if (value == null) {
11971           unsetColumn();
11972         } else {
11973           setColumn((byte[])value);
11974         }
11975         break;
11976 
11977       case TIMESTAMP:
11978         if (value == null) {
11979           unsetTimestamp();
11980         } else {
11981           setTimestamp((Long)value);
11982         }
11983         break;
11984 
11985       case NUM_VERSIONS:
11986         if (value == null) {
11987           unsetNumVersions();
11988         } else {
11989           setNumVersions((Integer)value);
11990         }
11991         break;
11992 
11993       }
11994     }
11995 
11996     public void setFieldValue(int fieldID, Object value) {
11997       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
11998     }
11999 
12000     public Object getFieldValue(_Fields field) {
12001       switch (field) {
12002       case TABLE_NAME:
12003         return getTableName();
12004 
12005       case ROW:
12006         return getRow();
12007 
12008       case COLUMN:
12009         return getColumn();
12010 
12011       case TIMESTAMP:
12012         return new Long(getTimestamp());
12013 
12014       case NUM_VERSIONS:
12015         return new Integer(getNumVersions());
12016 
12017       }
12018       throw new IllegalStateException();
12019     }
12020 
12021     public Object getFieldValue(int fieldId) {
12022       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12023     }
12024 
12025     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
12026     public boolean isSet(_Fields field) {
12027       switch (field) {
12028       case TABLE_NAME:
12029         return isSetTableName();
12030       case ROW:
12031         return isSetRow();
12032       case COLUMN:
12033         return isSetColumn();
12034       case TIMESTAMP:
12035         return isSetTimestamp();
12036       case NUM_VERSIONS:
12037         return isSetNumVersions();
12038       }
12039       throw new IllegalStateException();
12040     }
12041 
12042     public boolean isSet(int fieldID) {
12043       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12044     }
12045 
12046     @Override
12047     public boolean equals(Object that) {
12048       if (that == null)
12049         return false;
12050       if (that instanceof getVerTs_args)
12051         return this.equals((getVerTs_args)that);
12052       return false;
12053     }
12054 
12055     public boolean equals(getVerTs_args that) {
12056       if (that == null)
12057         return false;
12058 
12059       boolean this_present_tableName = true && this.isSetTableName();
12060       boolean that_present_tableName = true && that.isSetTableName();
12061       if (this_present_tableName || that_present_tableName) {
12062         if (!(this_present_tableName && that_present_tableName))
12063           return false;
12064         if (!java.util.Arrays.equals(this.tableName, that.tableName))
12065           return false;
12066       }
12067 
12068       boolean this_present_row = true && this.isSetRow();
12069       boolean that_present_row = true && that.isSetRow();
12070       if (this_present_row || that_present_row) {
12071         if (!(this_present_row && that_present_row))
12072           return false;
12073         if (!java.util.Arrays.equals(this.row, that.row))
12074           return false;
12075       }
12076 
12077       boolean this_present_column = true && this.isSetColumn();
12078       boolean that_present_column = true && that.isSetColumn();
12079       if (this_present_column || that_present_column) {
12080         if (!(this_present_column && that_present_column))
12081           return false;
12082         if (!java.util.Arrays.equals(this.column, that.column))
12083           return false;
12084       }
12085 
12086       boolean this_present_timestamp = true;
12087       boolean that_present_timestamp = true;
12088       if (this_present_timestamp || that_present_timestamp) {
12089         if (!(this_present_timestamp && that_present_timestamp))
12090           return false;
12091         if (this.timestamp != that.timestamp)
12092           return false;
12093       }
12094 
12095       boolean this_present_numVersions = true;
12096       boolean that_present_numVersions = true;
12097       if (this_present_numVersions || that_present_numVersions) {
12098         if (!(this_present_numVersions && that_present_numVersions))
12099           return false;
12100         if (this.numVersions != that.numVersions)
12101           return false;
12102       }
12103 
12104       return true;
12105     }
12106 
12107     @Override
12108     public int hashCode() {
12109       HashCodeBuilder builder = new HashCodeBuilder();
12110 
12111       boolean present_tableName = true && (isSetTableName());
12112       builder.append(present_tableName);
12113       if (present_tableName)
12114         builder.append(tableName);
12115 
12116       boolean present_row = true && (isSetRow());
12117       builder.append(present_row);
12118       if (present_row)
12119         builder.append(row);
12120 
12121       boolean present_column = true && (isSetColumn());
12122       builder.append(present_column);
12123       if (present_column)
12124         builder.append(column);
12125 
12126       boolean present_timestamp = true;
12127       builder.append(present_timestamp);
12128       if (present_timestamp)
12129         builder.append(timestamp);
12130 
12131       boolean present_numVersions = true;
12132       builder.append(present_numVersions);
12133       if (present_numVersions)
12134         builder.append(numVersions);
12135 
12136       return builder.toHashCode();
12137     }
12138 
12139     public int compareTo(getVerTs_args other) {
12140       if (!getClass().equals(other.getClass())) {
12141         return getClass().getName().compareTo(other.getClass().getName());
12142       }
12143 
12144       int lastComparison = 0;
12145       getVerTs_args typedOther = (getVerTs_args)other;
12146 
12147       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
12148       if (lastComparison != 0) {
12149         return lastComparison;
12150       }
12151       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
12152       if (lastComparison != 0) {
12153         return lastComparison;
12154       }
12155       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
12156       if (lastComparison != 0) {
12157         return lastComparison;
12158       }
12159       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
12160       if (lastComparison != 0) {
12161         return lastComparison;
12162       }
12163       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
12164       if (lastComparison != 0) {
12165         return lastComparison;
12166       }
12167       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
12168       if (lastComparison != 0) {
12169         return lastComparison;
12170       }
12171       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
12172       if (lastComparison != 0) {
12173         return lastComparison;
12174       }
12175       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
12176       if (lastComparison != 0) {
12177         return lastComparison;
12178       }
12179       lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(isSetNumVersions());
12180       if (lastComparison != 0) {
12181         return lastComparison;
12182       }
12183       lastComparison = TBaseHelper.compareTo(numVersions, typedOther.numVersions);
12184       if (lastComparison != 0) {
12185         return lastComparison;
12186       }
12187       return 0;
12188     }
12189 
12190     public void read(TProtocol iprot) throws TException {
12191       TField field;
12192       iprot.readStructBegin();
12193       while (true)
12194       {
12195         field = iprot.readFieldBegin();
12196         if (field.type == TType.STOP) {
12197           break;
12198         }
12199         _Fields fieldId = _Fields.findByThriftId(field.id);
12200         if (fieldId == null) {
12201           TProtocolUtil.skip(iprot, field.type);
12202         } else {
12203           switch (fieldId) {
12204             case TABLE_NAME:
12205               if (field.type == TType.STRING) {
12206                 this.tableName = iprot.readBinary();
12207               } else {
12208                 TProtocolUtil.skip(iprot, field.type);
12209               }
12210               break;
12211             case ROW:
12212               if (field.type == TType.STRING) {
12213                 this.row = iprot.readBinary();
12214               } else {
12215                 TProtocolUtil.skip(iprot, field.type);
12216               }
12217               break;
12218             case COLUMN:
12219               if (field.type == TType.STRING) {
12220                 this.column = iprot.readBinary();
12221               } else {
12222                 TProtocolUtil.skip(iprot, field.type);
12223               }
12224               break;
12225             case TIMESTAMP:
12226               if (field.type == TType.I64) {
12227                 this.timestamp = iprot.readI64();
12228                 setTimestampIsSet(true);
12229               } else {
12230                 TProtocolUtil.skip(iprot, field.type);
12231               }
12232               break;
12233             case NUM_VERSIONS:
12234               if (field.type == TType.I32) {
12235                 this.numVersions = iprot.readI32();
12236                 setNumVersionsIsSet(true);
12237               } else {
12238                 TProtocolUtil.skip(iprot, field.type);
12239               }
12240               break;
12241           }
12242           iprot.readFieldEnd();
12243         }
12244       }
12245       iprot.readStructEnd();
12246 
12247       // check for required fields of primitive type, which can't be checked in the validate method
12248       validate();
12249     }
12250 
12251     public void write(TProtocol oprot) throws TException {
12252       validate();
12253 
12254       oprot.writeStructBegin(STRUCT_DESC);
12255       if (this.tableName != null) {
12256         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
12257         oprot.writeBinary(this.tableName);
12258         oprot.writeFieldEnd();
12259       }
12260       if (this.row != null) {
12261         oprot.writeFieldBegin(ROW_FIELD_DESC);
12262         oprot.writeBinary(this.row);
12263         oprot.writeFieldEnd();
12264       }
12265       if (this.column != null) {
12266         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
12267         oprot.writeBinary(this.column);
12268         oprot.writeFieldEnd();
12269       }
12270       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
12271       oprot.writeI64(this.timestamp);
12272       oprot.writeFieldEnd();
12273       oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
12274       oprot.writeI32(this.numVersions);
12275       oprot.writeFieldEnd();
12276       oprot.writeFieldStop();
12277       oprot.writeStructEnd();
12278     }
12279 
12280     @Override
12281     public String toString() {
12282       StringBuilder sb = new StringBuilder("getVerTs_args(");
12283       boolean first = true;
12284 
12285       sb.append("tableName:");
12286       if (this.tableName == null) {
12287         sb.append("null");
12288       } else {
12289         sb.append(this.tableName);
12290       }
12291       first = false;
12292       if (!first) sb.append(", ");
12293       sb.append("row:");
12294       if (this.row == null) {
12295         sb.append("null");
12296       } else {
12297         sb.append(this.row);
12298       }
12299       first = false;
12300       if (!first) sb.append(", ");
12301       sb.append("column:");
12302       if (this.column == null) {
12303         sb.append("null");
12304       } else {
12305         sb.append(this.column);
12306       }
12307       first = false;
12308       if (!first) sb.append(", ");
12309       sb.append("timestamp:");
12310       sb.append(this.timestamp);
12311       first = false;
12312       if (!first) sb.append(", ");
12313       sb.append("numVersions:");
12314       sb.append(this.numVersions);
12315       first = false;
12316       sb.append(")");
12317       return sb.toString();
12318     }
12319 
12320     public void validate() throws TException {
12321       // check for required fields
12322     }
12323 
12324   }
12325 
12326   public static class getVerTs_result implements TBase<getVerTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_result>   {
12327     private static final TStruct STRUCT_DESC = new TStruct("getVerTs_result");
12328 
12329     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
12330     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
12331 
12332     public List<TCell> success;
12333     public IOError io;
12334 
12335     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
12336     public enum _Fields implements TFieldIdEnum {
12337       SUCCESS((short)0, "success"),
12338       IO((short)1, "io");
12339 
12340       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12341       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12342 
12343       static {
12344         for (_Fields field : EnumSet.allOf(_Fields.class)) {
12345           byId.put((int)field._thriftId, field);
12346           byName.put(field.getFieldName(), field);
12347         }
12348       }
12349 
12350       /**
12351        * Find the _Fields constant that matches fieldId, or null if its not found.
12352        */
12353       public static _Fields findByThriftId(int fieldId) {
12354         return byId.get(fieldId);
12355       }
12356 
12357       /**
12358        * Find the _Fields constant that matches fieldId, throwing an exception
12359        * if it is not found.
12360        */
12361       public static _Fields findByThriftIdOrThrow(int fieldId) {
12362         _Fields fields = findByThriftId(fieldId);
12363         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12364         return fields;
12365       }
12366 
12367       /**
12368        * Find the _Fields constant that matches name, or null if its not found.
12369        */
12370       public static _Fields findByName(String name) {
12371         return byName.get(name);
12372       }
12373 
12374       private final short _thriftId;
12375       private final String _fieldName;
12376 
12377       _Fields(short thriftId, String fieldName) {
12378         _thriftId = thriftId;
12379         _fieldName = fieldName;
12380       }
12381 
12382       public short getThriftFieldId() {
12383         return _thriftId;
12384       }
12385 
12386       public String getFieldName() {
12387         return _fieldName;
12388       }
12389     }
12390 
12391     // isset id assignments
12392 
12393     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12394       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
12395           new ListMetaData(TType.LIST,
12396               new StructMetaData(TType.STRUCT, TCell.class))));
12397       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
12398           new FieldValueMetaData(TType.STRUCT)));
12399     }});
12400 
12401     static {
12402       FieldMetaData.addStructMetaDataMap(getVerTs_result.class, metaDataMap);
12403     }
12404 
12405     public getVerTs_result() {
12406     }
12407 
12408     public getVerTs_result(
12409       List<TCell> success,
12410       IOError io)
12411     {
12412       this();
12413       this.success = success;
12414       this.io = io;
12415     }
12416 
12417     /**
12418      * Performs a deep copy on <i>other</i>.
12419      */
12420     public getVerTs_result(getVerTs_result other) {
12421       if (other.isSetSuccess()) {
12422         List<TCell> __this__success = new ArrayList<TCell>();
12423         for (TCell other_element : other.success) {
12424           __this__success.add(new TCell(other_element));
12425         }
12426         this.success = __this__success;
12427       }
12428       if (other.isSetIo()) {
12429         this.io = new IOError(other.io);
12430       }
12431     }
12432 
12433     public getVerTs_result deepCopy() {
12434       return new getVerTs_result(this);
12435     }
12436 
12437     @Deprecated
12438     public getVerTs_result clone() {
12439       return new getVerTs_result(this);
12440     }
12441 
12442     public int getSuccessSize() {
12443       return (this.success == null) ? 0 : this.success.size();
12444     }
12445 
12446     public java.util.Iterator<TCell> getSuccessIterator() {
12447       return (this.success == null) ? null : this.success.iterator();
12448     }
12449 
12450     public void addToSuccess(TCell elem) {
12451       if (this.success == null) {
12452         this.success = new ArrayList<TCell>();
12453       }
12454       this.success.add(elem);
12455     }
12456 
12457     public List<TCell> getSuccess() {
12458       return this.success;
12459     }
12460 
12461     public getVerTs_result setSuccess(List<TCell> success) {
12462       this.success = success;
12463       return this;
12464     }
12465 
12466     public void unsetSuccess() {
12467       this.success = null;
12468     }
12469 
12470     /** Returns true if field success is set (has been asigned a value) and false otherwise */
12471     public boolean isSetSuccess() {
12472       return this.success != null;
12473     }
12474 
12475     public void setSuccessIsSet(boolean value) {
12476       if (!value) {
12477         this.success = null;
12478       }
12479     }
12480 
12481     public IOError getIo() {
12482       return this.io;
12483     }
12484 
12485     public getVerTs_result setIo(IOError io) {
12486       this.io = io;
12487       return this;
12488     }
12489 
12490     public void unsetIo() {
12491       this.io = null;
12492     }
12493 
12494     /** Returns true if field io is set (has been asigned a value) and false otherwise */
12495     public boolean isSetIo() {
12496       return this.io != null;
12497     }
12498 
12499     public void setIoIsSet(boolean value) {
12500       if (!value) {
12501         this.io = null;
12502       }
12503     }
12504 
12505     public void setFieldValue(_Fields field, Object value) {
12506       switch (field) {
12507       case SUCCESS:
12508         if (value == null) {
12509           unsetSuccess();
12510         } else {
12511           setSuccess((List<TCell>)value);
12512         }
12513         break;
12514 
12515       case IO:
12516         if (value == null) {
12517           unsetIo();
12518         } else {
12519           setIo((IOError)value);
12520         }
12521         break;
12522 
12523       }
12524     }
12525 
12526     public void setFieldValue(int fieldID, Object value) {
12527       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
12528     }
12529 
12530     public Object getFieldValue(_Fields field) {
12531       switch (field) {
12532       case SUCCESS:
12533         return getSuccess();
12534 
12535       case IO:
12536         return getIo();
12537 
12538       }
12539       throw new IllegalStateException();
12540     }
12541 
12542     public Object getFieldValue(int fieldId) {
12543       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12544     }
12545 
12546     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
12547     public boolean isSet(_Fields field) {
12548       switch (field) {
12549       case SUCCESS:
12550         return isSetSuccess();
12551       case IO:
12552         return isSetIo();
12553       }
12554       throw new IllegalStateException();
12555     }
12556 
12557     public boolean isSet(int fieldID) {
12558       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12559     }
12560 
12561     @Override
12562     public boolean equals(Object that) {
12563       if (that == null)
12564         return false;
12565       if (that instanceof getVerTs_result)
12566         return this.equals((getVerTs_result)that);
12567       return false;
12568     }
12569 
12570     public boolean equals(getVerTs_result that) {
12571       if (that == null)
12572         return false;
12573 
12574       boolean this_present_success = true && this.isSetSuccess();
12575       boolean that_present_success = true && that.isSetSuccess();
12576       if (this_present_success || that_present_success) {
12577         if (!(this_present_success && that_present_success))
12578           return false;
12579         if (!this.success.equals(that.success))
12580           return false;
12581       }
12582 
12583       boolean this_present_io = true && this.isSetIo();
12584       boolean that_present_io = true && that.isSetIo();
12585       if (this_present_io || that_present_io) {
12586         if (!(this_present_io && that_present_io))
12587           return false;
12588         if (!this.io.equals(that.io))
12589           return false;
12590       }
12591 
12592       return true;
12593     }
12594 
12595     @Override
12596     public int hashCode() {
12597       HashCodeBuilder builder = new HashCodeBuilder();
12598 
12599       boolean present_success = true && (isSetSuccess());
12600       builder.append(present_success);
12601       if (present_success)
12602         builder.append(success);
12603 
12604       boolean present_io = true && (isSetIo());
12605       builder.append(present_io);
12606       if (present_io)
12607         builder.append(io);
12608 
12609       return builder.toHashCode();
12610     }
12611 
12612     public int compareTo(getVerTs_result other) {
12613       if (!getClass().equals(other.getClass())) {
12614         return getClass().getName().compareTo(other.getClass().getName());
12615       }
12616 
12617       int lastComparison = 0;
12618       getVerTs_result typedOther = (getVerTs_result)other;
12619 
12620       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
12621       if (lastComparison != 0) {
12622         return lastComparison;
12623       }
12624       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
12625       if (lastComparison != 0) {
12626         return lastComparison;
12627       }
12628       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
12629       if (lastComparison != 0) {
12630         return lastComparison;
12631       }
12632       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
12633       if (lastComparison != 0) {
12634         return lastComparison;
12635       }
12636       return 0;
12637     }
12638 
12639     public void read(TProtocol iprot) throws TException {
12640       TField field;
12641       iprot.readStructBegin();
12642       while (true)
12643       {
12644         field = iprot.readFieldBegin();
12645         if (field.type == TType.STOP) {
12646           break;
12647         }
12648         _Fields fieldId = _Fields.findByThriftId(field.id);
12649         if (fieldId == null) {
12650           TProtocolUtil.skip(iprot, field.type);
12651         } else {
12652           switch (fieldId) {
12653             case SUCCESS:
12654               if (field.type == TType.LIST) {
12655                 {
12656                   TList _list34 = iprot.readListBegin();
12657                   this.success = new ArrayList<TCell>(_list34.size);
12658                   for (int _i35 = 0; _i35 < _list34.size; ++_i35)
12659                   {
12660                     TCell _elem36;
12661                     _elem36 = new TCell();
12662                     _elem36.read(iprot);
12663                     this.success.add(_elem36);
12664                   }
12665                   iprot.readListEnd();
12666                 }
12667               } else {
12668                 TProtocolUtil.skip(iprot, field.type);
12669               }
12670               break;
12671             case IO:
12672               if (field.type == TType.STRUCT) {
12673                 this.io = new IOError();
12674                 this.io.read(iprot);
12675               } else {
12676                 TProtocolUtil.skip(iprot, field.type);
12677               }
12678               break;
12679           }
12680           iprot.readFieldEnd();
12681         }
12682       }
12683       iprot.readStructEnd();
12684 
12685       // check for required fields of primitive type, which can't be checked in the validate method
12686       validate();
12687     }
12688 
12689     public void write(TProtocol oprot) throws TException {
12690       oprot.writeStructBegin(STRUCT_DESC);
12691 
12692       if (this.isSetSuccess()) {
12693         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12694         {
12695           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
12696           for (TCell _iter37 : this.success)
12697           {
12698             _iter37.write(oprot);
12699           }
12700           oprot.writeListEnd();
12701         }
12702         oprot.writeFieldEnd();
12703       } else if (this.isSetIo()) {
12704         oprot.writeFieldBegin(IO_FIELD_DESC);
12705         this.io.write(oprot);
12706         oprot.writeFieldEnd();
12707       }
12708       oprot.writeFieldStop();
12709       oprot.writeStructEnd();
12710     }
12711 
12712     @Override
12713     public String toString() {
12714       StringBuilder sb = new StringBuilder("getVerTs_result(");
12715       boolean first = true;
12716 
12717       sb.append("success:");
12718       if (this.success == null) {
12719         sb.append("null");
12720       } else {
12721         sb.append(this.success);
12722       }
12723       first = false;
12724       if (!first) sb.append(", ");
12725       sb.append("io:");
12726       if (this.io == null) {
12727         sb.append("null");
12728       } else {
12729         sb.append(this.io);
12730       }
12731       first = false;
12732       sb.append(")");
12733       return sb.toString();
12734     }
12735 
12736     public void validate() throws TException {
12737       // check for required fields
12738     }
12739 
12740   }
12741 
12742   public static class getRow_args implements TBase<getRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRow_args>   {
12743     private static final TStruct STRUCT_DESC = new TStruct("getRow_args");
12744 
12745     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
12746     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
12747 
12748     /**
12749      * name of table
12750      */
12751     public byte[] tableName;
12752     /**
12753      * row key
12754      */
12755     public byte[] row;
12756 
12757     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
12758     public enum _Fields implements TFieldIdEnum {
12759       /**
12760        * name of table
12761        */
12762       TABLE_NAME((short)1, "tableName"),
12763       /**
12764        * row key
12765        */
12766       ROW((short)2, "row");
12767 
12768       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12769       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12770 
12771       static {
12772         for (_Fields field : EnumSet.allOf(_Fields.class)) {
12773           byId.put((int)field._thriftId, field);
12774           byName.put(field.getFieldName(), field);
12775         }
12776       }
12777 
12778       /**
12779        * Find the _Fields constant that matches fieldId, or null if its not found.
12780        */
12781       public static _Fields findByThriftId(int fieldId) {
12782         return byId.get(fieldId);
12783       }
12784 
12785       /**
12786        * Find the _Fields constant that matches fieldId, throwing an exception
12787        * if it is not found.
12788        */
12789       public static _Fields findByThriftIdOrThrow(int fieldId) {
12790         _Fields fields = findByThriftId(fieldId);
12791         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12792         return fields;
12793       }
12794 
12795       /**
12796        * Find the _Fields constant that matches name, or null if its not found.
12797        */
12798       public static _Fields findByName(String name) {
12799         return byName.get(name);
12800       }
12801 
12802       private final short _thriftId;
12803       private final String _fieldName;
12804 
12805       _Fields(short thriftId, String fieldName) {
12806         _thriftId = thriftId;
12807         _fieldName = fieldName;
12808       }
12809 
12810       public short getThriftFieldId() {
12811         return _thriftId;
12812       }
12813 
12814       public String getFieldName() {
12815         return _fieldName;
12816       }
12817     }
12818 
12819     // isset id assignments
12820 
12821     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12822       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
12823           new FieldValueMetaData(TType.STRING)));
12824       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
12825           new FieldValueMetaData(TType.STRING)));
12826     }});
12827 
12828     static {
12829       FieldMetaData.addStructMetaDataMap(getRow_args.class, metaDataMap);
12830     }
12831 
12832     public getRow_args() {
12833     }
12834 
12835     public getRow_args(
12836       byte[] tableName,
12837       byte[] row)
12838     {
12839       this();
12840       this.tableName = tableName;
12841       this.row = row;
12842     }
12843 
12844     /**
12845      * Performs a deep copy on <i>other</i>.
12846      */
12847     public getRow_args(getRow_args other) {
12848       if (other.isSetTableName()) {
12849         this.tableName = other.tableName;
12850       }
12851       if (other.isSetRow()) {
12852         this.row = other.row;
12853       }
12854     }
12855 
12856     public getRow_args deepCopy() {
12857       return new getRow_args(this);
12858     }
12859 
12860     @Deprecated
12861     public getRow_args clone() {
12862       return new getRow_args(this);
12863     }
12864 
12865     /**
12866      * name of table
12867      */
12868     public byte[] getTableName() {
12869       return this.tableName;
12870     }
12871 
12872     /**
12873      * name of table
12874      */
12875     public getRow_args setTableName(byte[] tableName) {
12876       this.tableName = tableName;
12877       return this;
12878     }
12879 
12880     public void unsetTableName() {
12881       this.tableName = null;
12882     }
12883 
12884     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
12885     public boolean isSetTableName() {
12886       return this.tableName != null;
12887     }
12888 
12889     public void setTableNameIsSet(boolean value) {
12890       if (!value) {
12891         this.tableName = null;
12892       }
12893     }
12894 
12895     /**
12896      * row key
12897      */
12898     public byte[] getRow() {
12899       return this.row;
12900     }
12901 
12902     /**
12903      * row key
12904      */
12905     public getRow_args setRow(byte[] row) {
12906       this.row = row;
12907       return this;
12908     }
12909 
12910     public void unsetRow() {
12911       this.row = null;
12912     }
12913 
12914     /** Returns true if field row is set (has been asigned a value) and false otherwise */
12915     public boolean isSetRow() {
12916       return this.row != null;
12917     }
12918 
12919     public void setRowIsSet(boolean value) {
12920       if (!value) {
12921         this.row = null;
12922       }
12923     }
12924 
12925     public void setFieldValue(_Fields field, Object value) {
12926       switch (field) {
12927       case TABLE_NAME:
12928         if (value == null) {
12929           unsetTableName();
12930         } else {
12931           setTableName((byte[])value);
12932         }
12933         break;
12934 
12935       case ROW:
12936         if (value == null) {
12937           unsetRow();
12938         } else {
12939           setRow((byte[])value);
12940         }
12941         break;
12942 
12943       }
12944     }
12945 
12946     public void setFieldValue(int fieldID, Object value) {
12947       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
12948     }
12949 
12950     public Object getFieldValue(_Fields field) {
12951       switch (field) {
12952       case TABLE_NAME:
12953         return getTableName();
12954 
12955       case ROW:
12956         return getRow();
12957 
12958       }
12959       throw new IllegalStateException();
12960     }
12961 
12962     public Object getFieldValue(int fieldId) {
12963       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12964     }
12965 
12966     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
12967     public boolean isSet(_Fields field) {
12968       switch (field) {
12969       case TABLE_NAME:
12970         return isSetTableName();
12971       case ROW:
12972         return isSetRow();
12973       }
12974       throw new IllegalStateException();
12975     }
12976 
12977     public boolean isSet(int fieldID) {
12978       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12979     }
12980 
12981     @Override
12982     public boolean equals(Object that) {
12983       if (that == null)
12984         return false;
12985       if (that instanceof getRow_args)
12986         return this.equals((getRow_args)that);
12987       return false;
12988     }
12989 
12990     public boolean equals(getRow_args that) {
12991       if (that == null)
12992         return false;
12993 
12994       boolean this_present_tableName = true && this.isSetTableName();
12995       boolean that_present_tableName = true && that.isSetTableName();
12996       if (this_present_tableName || that_present_tableName) {
12997         if (!(this_present_tableName && that_present_tableName))
12998           return false;
12999         if (!java.util.Arrays.equals(this.tableName, that.tableName))
13000           return false;
13001       }
13002 
13003       boolean this_present_row = true && this.isSetRow();
13004       boolean that_present_row = true && that.isSetRow();
13005       if (this_present_row || that_present_row) {
13006         if (!(this_present_row && that_present_row))
13007           return false;
13008         if (!java.util.Arrays.equals(this.row, that.row))
13009           return false;
13010       }
13011 
13012       return true;
13013     }
13014 
13015     @Override
13016     public int hashCode() {
13017       HashCodeBuilder builder = new HashCodeBuilder();
13018 
13019       boolean present_tableName = true && (isSetTableName());
13020       builder.append(present_tableName);
13021       if (present_tableName)
13022         builder.append(tableName);
13023 
13024       boolean present_row = true && (isSetRow());
13025       builder.append(present_row);
13026       if (present_row)
13027         builder.append(row);
13028 
13029       return builder.toHashCode();
13030     }
13031 
13032     public int compareTo(getRow_args other) {
13033       if (!getClass().equals(other.getClass())) {
13034         return getClass().getName().compareTo(other.getClass().getName());
13035       }
13036 
13037       int lastComparison = 0;
13038       getRow_args typedOther = (getRow_args)other;
13039 
13040       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
13041       if (lastComparison != 0) {
13042         return lastComparison;
13043       }
13044       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
13045       if (lastComparison != 0) {
13046         return lastComparison;
13047       }
13048       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
13049       if (lastComparison != 0) {
13050         return lastComparison;
13051       }
13052       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
13053       if (lastComparison != 0) {
13054         return lastComparison;
13055       }
13056       return 0;
13057     }
13058 
13059     public void read(TProtocol iprot) throws TException {
13060       TField field;
13061       iprot.readStructBegin();
13062       while (true)
13063       {
13064         field = iprot.readFieldBegin();
13065         if (field.type == TType.STOP) {
13066           break;
13067         }
13068         _Fields fieldId = _Fields.findByThriftId(field.id);
13069         if (fieldId == null) {
13070           TProtocolUtil.skip(iprot, field.type);
13071         } else {
13072           switch (fieldId) {
13073             case TABLE_NAME:
13074               if (field.type == TType.STRING) {
13075                 this.tableName = iprot.readBinary();
13076               } else {
13077                 TProtocolUtil.skip(iprot, field.type);
13078               }
13079               break;
13080             case ROW:
13081               if (field.type == TType.STRING) {
13082                 this.row = iprot.readBinary();
13083               } else {
13084                 TProtocolUtil.skip(iprot, field.type);
13085               }
13086               break;
13087           }
13088           iprot.readFieldEnd();
13089         }
13090       }
13091       iprot.readStructEnd();
13092 
13093       // check for required fields of primitive type, which can't be checked in the validate method
13094       validate();
13095     }
13096 
13097     public void write(TProtocol oprot) throws TException {
13098       validate();
13099 
13100       oprot.writeStructBegin(STRUCT_DESC);
13101       if (this.tableName != null) {
13102         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
13103         oprot.writeBinary(this.tableName);
13104         oprot.writeFieldEnd();
13105       }
13106       if (this.row != null) {
13107         oprot.writeFieldBegin(ROW_FIELD_DESC);
13108         oprot.writeBinary(this.row);
13109         oprot.writeFieldEnd();
13110       }
13111       oprot.writeFieldStop();
13112       oprot.writeStructEnd();
13113     }
13114 
13115     @Override
13116     public String toString() {
13117       StringBuilder sb = new StringBuilder("getRow_args(");
13118       boolean first = true;
13119 
13120       sb.append("tableName:");
13121       if (this.tableName == null) {
13122         sb.append("null");
13123       } else {
13124         sb.append(this.tableName);
13125       }
13126       first = false;
13127       if (!first) sb.append(", ");
13128       sb.append("row:");
13129       if (this.row == null) {
13130         sb.append("null");
13131       } else {
13132         sb.append(this.row);
13133       }
13134       first = false;
13135       sb.append(")");
13136       return sb.toString();
13137     }
13138 
13139     public void validate() throws TException {
13140       // check for required fields
13141     }
13142 
13143   }
13144 
13145   public static class getRow_result implements TBase<getRow_result._Fields>, java.io.Serializable, Cloneable   {
13146     private static final TStruct STRUCT_DESC = new TStruct("getRow_result");
13147 
13148     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
13149     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
13150 
13151     public List<TRowResult> success;
13152     public IOError io;
13153 
13154     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
13155     public enum _Fields implements TFieldIdEnum {
13156       SUCCESS((short)0, "success"),
13157       IO((short)1, "io");
13158 
13159       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
13160       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13161 
13162       static {
13163         for (_Fields field : EnumSet.allOf(_Fields.class)) {
13164           byId.put((int)field._thriftId, field);
13165           byName.put(field.getFieldName(), field);
13166         }
13167       }
13168 
13169       /**
13170        * Find the _Fields constant that matches fieldId, or null if its not found.
13171        */
13172       public static _Fields findByThriftId(int fieldId) {
13173         return byId.get(fieldId);
13174       }
13175 
13176       /**
13177        * Find the _Fields constant that matches fieldId, throwing an exception
13178        * if it is not found.
13179        */
13180       public static _Fields findByThriftIdOrThrow(int fieldId) {
13181         _Fields fields = findByThriftId(fieldId);
13182         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13183         return fields;
13184       }
13185 
13186       /**
13187        * Find the _Fields constant that matches name, or null if its not found.
13188        */
13189       public static _Fields findByName(String name) {
13190         return byName.get(name);
13191       }
13192 
13193       private final short _thriftId;
13194       private final String _fieldName;
13195 
13196       _Fields(short thriftId, String fieldName) {
13197         _thriftId = thriftId;
13198         _fieldName = fieldName;
13199       }
13200 
13201       public short getThriftFieldId() {
13202         return _thriftId;
13203       }
13204 
13205       public String getFieldName() {
13206         return _fieldName;
13207       }
13208     }
13209 
13210     // isset id assignments
13211 
13212     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
13213       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
13214           new ListMetaData(TType.LIST,
13215               new StructMetaData(TType.STRUCT, TRowResult.class))));
13216       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
13217           new FieldValueMetaData(TType.STRUCT)));
13218     }});
13219 
13220     static {
13221       FieldMetaData.addStructMetaDataMap(getRow_result.class, metaDataMap);
13222     }
13223 
13224     public getRow_result() {
13225     }
13226 
13227     public getRow_result(
13228       List<TRowResult> success,
13229       IOError io)
13230     {
13231       this();
13232       this.success = success;
13233       this.io = io;
13234     }
13235 
13236     /**
13237      * Performs a deep copy on <i>other</i>.
13238      */
13239     public getRow_result(getRow_result other) {
13240       if (other.isSetSuccess()) {
13241         List<TRowResult> __this__success = new ArrayList<TRowResult>();
13242         for (TRowResult other_element : other.success) {
13243           __this__success.add(new TRowResult(other_element));
13244         }
13245         this.success = __this__success;
13246       }
13247       if (other.isSetIo()) {
13248         this.io = new IOError(other.io);
13249       }
13250     }
13251 
13252     public getRow_result deepCopy() {
13253       return new getRow_result(this);
13254     }
13255 
13256     @Deprecated
13257     public getRow_result clone() {
13258       return new getRow_result(this);
13259     }
13260 
13261     public int getSuccessSize() {
13262       return (this.success == null) ? 0 : this.success.size();
13263     }
13264 
13265     public java.util.Iterator<TRowResult> getSuccessIterator() {
13266       return (this.success == null) ? null : this.success.iterator();
13267     }
13268 
13269     public void addToSuccess(TRowResult elem) {
13270       if (this.success == null) {
13271         this.success = new ArrayList<TRowResult>();
13272       }
13273       this.success.add(elem);
13274     }
13275 
13276     public List<TRowResult> getSuccess() {
13277       return this.success;
13278     }
13279 
13280     public getRow_result setSuccess(List<TRowResult> success) {
13281       this.success = success;
13282       return this;
13283     }
13284 
13285     public void unsetSuccess() {
13286       this.success = null;
13287     }
13288 
13289     /** Returns true if field success is set (has been asigned a value) and false otherwise */
13290     public boolean isSetSuccess() {
13291       return this.success != null;
13292     }
13293 
13294     public void setSuccessIsSet(boolean value) {
13295       if (!value) {
13296         this.success = null;
13297       }
13298     }
13299 
13300     public IOError getIo() {
13301       return this.io;
13302     }
13303 
13304     public getRow_result setIo(IOError io) {
13305       this.io = io;
13306       return this;
13307     }
13308 
13309     public void unsetIo() {
13310       this.io = null;
13311     }
13312 
13313     /** Returns true if field io is set (has been asigned a value) and false otherwise */
13314     public boolean isSetIo() {
13315       return this.io != null;
13316     }
13317 
13318     public void setIoIsSet(boolean value) {
13319       if (!value) {
13320         this.io = null;
13321       }
13322     }
13323 
13324     public void setFieldValue(_Fields field, Object value) {
13325       switch (field) {
13326       case SUCCESS:
13327         if (value == null) {
13328           unsetSuccess();
13329         } else {
13330           setSuccess((List<TRowResult>)value);
13331         }
13332         break;
13333 
13334       case IO:
13335         if (value == null) {
13336           unsetIo();
13337         } else {
13338           setIo((IOError)value);
13339         }
13340         break;
13341 
13342       }
13343     }
13344 
13345     public void setFieldValue(int fieldID, Object value) {
13346       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13347     }
13348 
13349     public Object getFieldValue(_Fields field) {
13350       switch (field) {
13351       case SUCCESS:
13352         return getSuccess();
13353 
13354       case IO:
13355         return getIo();
13356 
13357       }
13358       throw new IllegalStateException();
13359     }
13360 
13361     public Object getFieldValue(int fieldId) {
13362       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13363     }
13364 
13365     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
13366     public boolean isSet(_Fields field) {
13367       switch (field) {
13368       case SUCCESS:
13369         return isSetSuccess();
13370       case IO:
13371         return isSetIo();
13372       }
13373       throw new IllegalStateException();
13374     }
13375 
13376     public boolean isSet(int fieldID) {
13377       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13378     }
13379 
13380     @Override
13381     public boolean equals(Object that) {
13382       if (that == null)
13383         return false;
13384       if (that instanceof getRow_result)
13385         return this.equals((getRow_result)that);
13386       return false;
13387     }
13388 
13389     public boolean equals(getRow_result that) {
13390       if (that == null)
13391         return false;
13392 
13393       boolean this_present_success = true && this.isSetSuccess();
13394       boolean that_present_success = true && that.isSetSuccess();
13395       if (this_present_success || that_present_success) {
13396         if (!(this_present_success && that_present_success))
13397           return false;
13398         if (!this.success.equals(that.success))
13399           return false;
13400       }
13401 
13402       boolean this_present_io = true && this.isSetIo();
13403       boolean that_present_io = true && that.isSetIo();
13404       if (this_present_io || that_present_io) {
13405         if (!(this_present_io && that_present_io))
13406           return false;
13407         if (!this.io.equals(that.io))
13408           return false;
13409       }
13410 
13411       return true;
13412     }
13413 
13414     @Override
13415     public int hashCode() {
13416       HashCodeBuilder builder = new HashCodeBuilder();
13417 
13418       boolean present_success = true && (isSetSuccess());
13419       builder.append(present_success);
13420       if (present_success)
13421         builder.append(success);
13422 
13423       boolean present_io = true && (isSetIo());
13424       builder.append(present_io);
13425       if (present_io)
13426         builder.append(io);
13427 
13428       return builder.toHashCode();
13429     }
13430 
13431     public void read(TProtocol iprot) throws TException {
13432       TField field;
13433       iprot.readStructBegin();
13434       while (true)
13435       {
13436         field = iprot.readFieldBegin();
13437         if (field.type == TType.STOP) {
13438           break;
13439         }
13440         _Fields fieldId = _Fields.findByThriftId(field.id);
13441         if (fieldId == null) {
13442           TProtocolUtil.skip(iprot, field.type);
13443         } else {
13444           switch (fieldId) {
13445             case SUCCESS:
13446               if (field.type == TType.LIST) {
13447                 {
13448                   TList _list38 = iprot.readListBegin();
13449                   this.success = new ArrayList<TRowResult>(_list38.size);
13450                   for (int _i39 = 0; _i39 < _list38.size; ++_i39)
13451                   {
13452                     TRowResult _elem40;
13453                     _elem40 = new TRowResult();
13454                     _elem40.read(iprot);
13455                     this.success.add(_elem40);
13456                   }
13457                   iprot.readListEnd();
13458                 }
13459               } else {
13460                 TProtocolUtil.skip(iprot, field.type);
13461               }
13462               break;
13463             case IO:
13464               if (field.type == TType.STRUCT) {
13465                 this.io = new IOError();
13466                 this.io.read(iprot);
13467               } else {
13468                 TProtocolUtil.skip(iprot, field.type);
13469               }
13470               break;
13471           }
13472           iprot.readFieldEnd();
13473         }
13474       }
13475       iprot.readStructEnd();
13476 
13477       // check for required fields of primitive type, which can't be checked in the validate method
13478       validate();
13479     }
13480 
13481     public void write(TProtocol oprot) throws TException {
13482       oprot.writeStructBegin(STRUCT_DESC);
13483 
13484       if (this.isSetSuccess()) {
13485         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13486         {
13487           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
13488           for (TRowResult _iter41 : this.success)
13489           {
13490             _iter41.write(oprot);
13491           }
13492           oprot.writeListEnd();
13493         }
13494         oprot.writeFieldEnd();
13495       } else if (this.isSetIo()) {
13496         oprot.writeFieldBegin(IO_FIELD_DESC);
13497         this.io.write(oprot);
13498         oprot.writeFieldEnd();
13499       }
13500       oprot.writeFieldStop();
13501       oprot.writeStructEnd();
13502     }
13503 
13504     @Override
13505     public String toString() {
13506       StringBuilder sb = new StringBuilder("getRow_result(");
13507       boolean first = true;
13508 
13509       sb.append("success:");
13510       if (this.success == null) {
13511         sb.append("null");
13512       } else {
13513         sb.append(this.success);
13514       }
13515       first = false;
13516       if (!first) sb.append(", ");
13517       sb.append("io:");
13518       if (this.io == null) {
13519         sb.append("null");
13520       } else {
13521         sb.append(this.io);
13522       }
13523       first = false;
13524       sb.append(")");
13525       return sb.toString();
13526     }
13527 
13528     public void validate() throws TException {
13529       // check for required fields
13530     }
13531 
13532   }
13533 
13534   public static class getRowWithColumns_args implements TBase<getRowWithColumns_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumns_args>   {
13535     private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_args");
13536 
13537     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
13538     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
13539     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
13540 
13541     /**
13542      * name of table
13543      */
13544     public byte[] tableName;
13545     /**
13546      * row key
13547      */
13548     public byte[] row;
13549     /**
13550      * List of columns to return, null for all columns
13551      */
13552     public List<byte[]> columns;
13553 
13554     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
13555     public enum _Fields implements TFieldIdEnum {
13556       /**
13557        * name of table
13558        */
13559       TABLE_NAME((short)1, "tableName"),
13560       /**
13561        * row key
13562        */
13563       ROW((short)2, "row"),
13564       /**
13565        * List of columns to return, null for all columns
13566        */
13567       COLUMNS((short)3, "columns");
13568 
13569       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
13570       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13571 
13572       static {
13573         for (_Fields field : EnumSet.allOf(_Fields.class)) {
13574           byId.put((int)field._thriftId, field);
13575           byName.put(field.getFieldName(), field);
13576         }
13577       }
13578 
13579       /**
13580        * Find the _Fields constant that matches fieldId, or null if its not found.
13581        */
13582       public static _Fields findByThriftId(int fieldId) {
13583         return byId.get(fieldId);
13584       }
13585 
13586       /**
13587        * Find the _Fields constant that matches fieldId, throwing an exception
13588        * if it is not found.
13589        */
13590       public static _Fields findByThriftIdOrThrow(int fieldId) {
13591         _Fields fields = findByThriftId(fieldId);
13592         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13593         return fields;
13594       }
13595 
13596       /**
13597        * Find the _Fields constant that matches name, or null if its not found.
13598        */
13599       public static _Fields findByName(String name) {
13600         return byName.get(name);
13601       }
13602 
13603       private final short _thriftId;
13604       private final String _fieldName;
13605 
13606       _Fields(short thriftId, String fieldName) {
13607         _thriftId = thriftId;
13608         _fieldName = fieldName;
13609       }
13610 
13611       public short getThriftFieldId() {
13612         return _thriftId;
13613       }
13614 
13615       public String getFieldName() {
13616         return _fieldName;
13617       }
13618     }
13619 
13620     // isset id assignments
13621 
13622     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
13623       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
13624           new FieldValueMetaData(TType.STRING)));
13625       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
13626           new FieldValueMetaData(TType.STRING)));
13627       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
13628           new ListMetaData(TType.LIST,
13629               new FieldValueMetaData(TType.STRING))));
13630     }});
13631 
13632     static {
13633       FieldMetaData.addStructMetaDataMap(getRowWithColumns_args.class, metaDataMap);
13634     }
13635 
13636     public getRowWithColumns_args() {
13637     }
13638 
13639     public getRowWithColumns_args(
13640       byte[] tableName,
13641       byte[] row,
13642       List<byte[]> columns)
13643     {
13644       this();
13645       this.tableName = tableName;
13646       this.row = row;
13647       this.columns = columns;
13648     }
13649 
13650     /**
13651      * Performs a deep copy on <i>other</i>.
13652      */
13653     public getRowWithColumns_args(getRowWithColumns_args other) {
13654       if (other.isSetTableName()) {
13655         this.tableName = other.tableName;
13656       }
13657       if (other.isSetRow()) {
13658         this.row = other.row;
13659       }
13660       if (other.isSetColumns()) {
13661         List<byte[]> __this__columns = new ArrayList<byte[]>();
13662         for (byte[] other_element : other.columns) {
13663           __this__columns.add(other_element);
13664         }
13665         this.columns = __this__columns;
13666       }
13667     }
13668 
13669     public getRowWithColumns_args deepCopy() {
13670       return new getRowWithColumns_args(this);
13671     }
13672 
13673     @Deprecated
13674     public getRowWithColumns_args clone() {
13675       return new getRowWithColumns_args(this);
13676     }
13677 
13678     /**
13679      * name of table
13680      */
13681     public byte[] getTableName() {
13682       return this.tableName;
13683     }
13684 
13685     /**
13686      * name of table
13687      */
13688     public getRowWithColumns_args setTableName(byte[] tableName) {
13689       this.tableName = tableName;
13690       return this;
13691     }
13692 
13693     public void unsetTableName() {
13694       this.tableName = null;
13695     }
13696 
13697     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
13698     public boolean isSetTableName() {
13699       return this.tableName != null;
13700     }
13701 
13702     public void setTableNameIsSet(boolean value) {
13703       if (!value) {
13704         this.tableName = null;
13705       }
13706     }
13707 
13708     /**
13709      * row key
13710      */
13711     public byte[] getRow() {
13712       return this.row;
13713     }
13714 
13715     /**
13716      * row key
13717      */
13718     public getRowWithColumns_args setRow(byte[] row) {
13719       this.row = row;
13720       return this;
13721     }
13722 
13723     public void unsetRow() {
13724       this.row = null;
13725     }
13726 
13727     /** Returns true if field row is set (has been asigned a value) and false otherwise */
13728     public boolean isSetRow() {
13729       return this.row != null;
13730     }
13731 
13732     public void setRowIsSet(boolean value) {
13733       if (!value) {
13734         this.row = null;
13735       }
13736     }
13737 
13738     public int getColumnsSize() {
13739       return (this.columns == null) ? 0 : this.columns.size();
13740     }
13741 
13742     public java.util.Iterator<byte[]> getColumnsIterator() {
13743       return (this.columns == null) ? null : this.columns.iterator();
13744     }
13745 
13746     public void addToColumns(byte[] elem) {
13747       if (this.columns == null) {
13748         this.columns = new ArrayList<byte[]>();
13749       }
13750       this.columns.add(elem);
13751     }
13752 
13753     /**
13754      * List of columns to return, null for all columns
13755      */
13756     public List<byte[]> getColumns() {
13757       return this.columns;
13758     }
13759 
13760     /**
13761      * List of columns to return, null for all columns
13762      */
13763     public getRowWithColumns_args setColumns(List<byte[]> columns) {
13764       this.columns = columns;
13765       return this;
13766     }
13767 
13768     public void unsetColumns() {
13769       this.columns = null;
13770     }
13771 
13772     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
13773     public boolean isSetColumns() {
13774       return this.columns != null;
13775     }
13776 
13777     public void setColumnsIsSet(boolean value) {
13778       if (!value) {
13779         this.columns = null;
13780       }
13781     }
13782 
13783     public void setFieldValue(_Fields field, Object value) {
13784       switch (field) {
13785       case TABLE_NAME:
13786         if (value == null) {
13787           unsetTableName();
13788         } else {
13789           setTableName((byte[])value);
13790         }
13791         break;
13792 
13793       case ROW:
13794         if (value == null) {
13795           unsetRow();
13796         } else {
13797           setRow((byte[])value);
13798         }
13799         break;
13800 
13801       case COLUMNS:
13802         if (value == null) {
13803           unsetColumns();
13804         } else {
13805           setColumns((List<byte[]>)value);
13806         }
13807         break;
13808 
13809       }
13810     }
13811 
13812     public void setFieldValue(int fieldID, Object value) {
13813       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13814     }
13815 
13816     public Object getFieldValue(_Fields field) {
13817       switch (field) {
13818       case TABLE_NAME:
13819         return getTableName();
13820 
13821       case ROW:
13822         return getRow();
13823 
13824       case COLUMNS:
13825         return getColumns();
13826 
13827       }
13828       throw new IllegalStateException();
13829     }
13830 
13831     public Object getFieldValue(int fieldId) {
13832       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13833     }
13834 
13835     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
13836     public boolean isSet(_Fields field) {
13837       switch (field) {
13838       case TABLE_NAME:
13839         return isSetTableName();
13840       case ROW:
13841         return isSetRow();
13842       case COLUMNS:
13843         return isSetColumns();
13844       }
13845       throw new IllegalStateException();
13846     }
13847 
13848     public boolean isSet(int fieldID) {
13849       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13850     }
13851 
13852     @Override
13853     public boolean equals(Object that) {
13854       if (that == null)
13855         return false;
13856       if (that instanceof getRowWithColumns_args)
13857         return this.equals((getRowWithColumns_args)that);
13858       return false;
13859     }
13860 
13861     public boolean equals(getRowWithColumns_args that) {
13862       if (that == null)
13863         return false;
13864 
13865       boolean this_present_tableName = true && this.isSetTableName();
13866       boolean that_present_tableName = true && that.isSetTableName();
13867       if (this_present_tableName || that_present_tableName) {
13868         if (!(this_present_tableName && that_present_tableName))
13869           return false;
13870         if (!java.util.Arrays.equals(this.tableName, that.tableName))
13871           return false;
13872       }
13873 
13874       boolean this_present_row = true && this.isSetRow();
13875       boolean that_present_row = true && that.isSetRow();
13876       if (this_present_row || that_present_row) {
13877         if (!(this_present_row && that_present_row))
13878           return false;
13879         if (!java.util.Arrays.equals(this.row, that.row))
13880           return false;
13881       }
13882 
13883       boolean this_present_columns = true && this.isSetColumns();
13884       boolean that_present_columns = true && that.isSetColumns();
13885       if (this_present_columns || that_present_columns) {
13886         if (!(this_present_columns && that_present_columns))
13887           return false;
13888         if (!this.columns.equals(that.columns))
13889           return false;
13890       }
13891 
13892       return true;
13893     }
13894 
13895     @Override
13896     public int hashCode() {
13897       HashCodeBuilder builder = new HashCodeBuilder();
13898 
13899       boolean present_tableName = true && (isSetTableName());
13900       builder.append(present_tableName);
13901       if (present_tableName)
13902         builder.append(tableName);
13903 
13904       boolean present_row = true && (isSetRow());
13905       builder.append(present_row);
13906       if (present_row)
13907         builder.append(row);
13908 
13909       boolean present_columns = true && (isSetColumns());
13910       builder.append(present_columns);
13911       if (present_columns)
13912         builder.append(columns);
13913 
13914       return builder.toHashCode();
13915     }
13916 
13917     public int compareTo(getRowWithColumns_args other) {
13918       if (!getClass().equals(other.getClass())) {
13919         return getClass().getName().compareTo(other.getClass().getName());
13920       }
13921 
13922       int lastComparison = 0;
13923       getRowWithColumns_args typedOther = (getRowWithColumns_args)other;
13924 
13925       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
13926       if (lastComparison != 0) {
13927         return lastComparison;
13928       }
13929       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
13930       if (lastComparison != 0) {
13931         return lastComparison;
13932       }
13933       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
13934       if (lastComparison != 0) {
13935         return lastComparison;
13936       }
13937       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
13938       if (lastComparison != 0) {
13939         return lastComparison;
13940       }
13941       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
13942       if (lastComparison != 0) {
13943         return lastComparison;
13944       }
13945       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
13946       if (lastComparison != 0) {
13947         return lastComparison;
13948       }
13949       return 0;
13950     }
13951 
13952     public void read(TProtocol iprot) throws TException {
13953       TField field;
13954       iprot.readStructBegin();
13955       while (true)
13956       {
13957         field = iprot.readFieldBegin();
13958         if (field.type == TType.STOP) {
13959           break;
13960         }
13961         _Fields fieldId = _Fields.findByThriftId(field.id);
13962         if (fieldId == null) {
13963           TProtocolUtil.skip(iprot, field.type);
13964         } else {
13965           switch (fieldId) {
13966             case TABLE_NAME:
13967               if (field.type == TType.STRING) {
13968                 this.tableName = iprot.readBinary();
13969               } else {
13970                 TProtocolUtil.skip(iprot, field.type);
13971               }
13972               break;
13973             case ROW:
13974               if (field.type == TType.STRING) {
13975                 this.row = iprot.readBinary();
13976               } else {
13977                 TProtocolUtil.skip(iprot, field.type);
13978               }
13979               break;
13980             case COLUMNS:
13981               if (field.type == TType.LIST) {
13982                 {
13983                   TList _list42 = iprot.readListBegin();
13984                   this.columns = new ArrayList<byte[]>(_list42.size);
13985                   for (int _i43 = 0; _i43 < _list42.size; ++_i43)
13986                   {
13987                     byte[] _elem44;
13988                     _elem44 = iprot.readBinary();
13989                     this.columns.add(_elem44);
13990                   }
13991                   iprot.readListEnd();
13992                 }
13993               } else {
13994                 TProtocolUtil.skip(iprot, field.type);
13995               }
13996               break;
13997           }
13998           iprot.readFieldEnd();
13999         }
14000       }
14001       iprot.readStructEnd();
14002 
14003       // check for required fields of primitive type, which can't be checked in the validate method
14004       validate();
14005     }
14006 
14007     public void write(TProtocol oprot) throws TException {
14008       validate();
14009 
14010       oprot.writeStructBegin(STRUCT_DESC);
14011       if (this.tableName != null) {
14012         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
14013         oprot.writeBinary(this.tableName);
14014         oprot.writeFieldEnd();
14015       }
14016       if (this.row != null) {
14017         oprot.writeFieldBegin(ROW_FIELD_DESC);
14018         oprot.writeBinary(this.row);
14019         oprot.writeFieldEnd();
14020       }
14021       if (this.columns != null) {
14022         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
14023         {
14024           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
14025           for (byte[] _iter45 : this.columns)
14026           {
14027             oprot.writeBinary(_iter45);
14028           }
14029           oprot.writeListEnd();
14030         }
14031         oprot.writeFieldEnd();
14032       }
14033       oprot.writeFieldStop();
14034       oprot.writeStructEnd();
14035     }
14036 
14037     @Override
14038     public String toString() {
14039       StringBuilder sb = new StringBuilder("getRowWithColumns_args(");
14040       boolean first = true;
14041 
14042       sb.append("tableName:");
14043       if (this.tableName == null) {
14044         sb.append("null");
14045       } else {
14046         sb.append(this.tableName);
14047       }
14048       first = false;
14049       if (!first) sb.append(", ");
14050       sb.append("row:");
14051       if (this.row == null) {
14052         sb.append("null");
14053       } else {
14054         sb.append(this.row);
14055       }
14056       first = false;
14057       if (!first) sb.append(", ");
14058       sb.append("columns:");
14059       if (this.columns == null) {
14060         sb.append("null");
14061       } else {
14062         sb.append(this.columns);
14063       }
14064       first = false;
14065       sb.append(")");
14066       return sb.toString();
14067     }
14068 
14069     public void validate() throws TException {
14070       // check for required fields
14071     }
14072 
14073   }
14074 
14075   public static class getRowWithColumns_result implements TBase<getRowWithColumns_result._Fields>, java.io.Serializable, Cloneable   {
14076     private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_result");
14077 
14078     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
14079     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
14080 
14081     public List<TRowResult> success;
14082     public IOError io;
14083 
14084     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
14085     public enum _Fields implements TFieldIdEnum {
14086       SUCCESS((short)0, "success"),
14087       IO((short)1, "io");
14088 
14089       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14090       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14091 
14092       static {
14093         for (_Fields field : EnumSet.allOf(_Fields.class)) {
14094           byId.put((int)field._thriftId, field);
14095           byName.put(field.getFieldName(), field);
14096         }
14097       }
14098 
14099       /**
14100        * Find the _Fields constant that matches fieldId, or null if its not found.
14101        */
14102       public static _Fields findByThriftId(int fieldId) {
14103         return byId.get(fieldId);
14104       }
14105 
14106       /**
14107        * Find the _Fields constant that matches fieldId, throwing an exception
14108        * if it is not found.
14109        */
14110       public static _Fields findByThriftIdOrThrow(int fieldId) {
14111         _Fields fields = findByThriftId(fieldId);
14112         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14113         return fields;
14114       }
14115 
14116       /**
14117        * Find the _Fields constant that matches name, or null if its not found.
14118        */
14119       public static _Fields findByName(String name) {
14120         return byName.get(name);
14121       }
14122 
14123       private final short _thriftId;
14124       private final String _fieldName;
14125 
14126       _Fields(short thriftId, String fieldName) {
14127         _thriftId = thriftId;
14128         _fieldName = fieldName;
14129       }
14130 
14131       public short getThriftFieldId() {
14132         return _thriftId;
14133       }
14134 
14135       public String getFieldName() {
14136         return _fieldName;
14137       }
14138     }
14139 
14140     // isset id assignments
14141 
14142     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
14143       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
14144           new ListMetaData(TType.LIST,
14145               new StructMetaData(TType.STRUCT, TRowResult.class))));
14146       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
14147           new FieldValueMetaData(TType.STRUCT)));
14148     }});
14149 
14150     static {
14151       FieldMetaData.addStructMetaDataMap(getRowWithColumns_result.class, metaDataMap);
14152     }
14153 
14154     public getRowWithColumns_result() {
14155     }
14156 
14157     public getRowWithColumns_result(
14158       List<TRowResult> success,
14159       IOError io)
14160     {
14161       this();
14162       this.success = success;
14163       this.io = io;
14164     }
14165 
14166     /**
14167      * Performs a deep copy on <i>other</i>.
14168      */
14169     public getRowWithColumns_result(getRowWithColumns_result other) {
14170       if (other.isSetSuccess()) {
14171         List<TRowResult> __this__success = new ArrayList<TRowResult>();
14172         for (TRowResult other_element : other.success) {
14173           __this__success.add(new TRowResult(other_element));
14174         }
14175         this.success = __this__success;
14176       }
14177       if (other.isSetIo()) {
14178         this.io = new IOError(other.io);
14179       }
14180     }
14181 
14182     public getRowWithColumns_result deepCopy() {
14183       return new getRowWithColumns_result(this);
14184     }
14185 
14186     @Deprecated
14187     public getRowWithColumns_result clone() {
14188       return new getRowWithColumns_result(this);
14189     }
14190 
14191     public int getSuccessSize() {
14192       return (this.success == null) ? 0 : this.success.size();
14193     }
14194 
14195     public java.util.Iterator<TRowResult> getSuccessIterator() {
14196       return (this.success == null) ? null : this.success.iterator();
14197     }
14198 
14199     public void addToSuccess(TRowResult elem) {
14200       if (this.success == null) {
14201         this.success = new ArrayList<TRowResult>();
14202       }
14203       this.success.add(elem);
14204     }
14205 
14206     public List<TRowResult> getSuccess() {
14207       return this.success;
14208     }
14209 
14210     public getRowWithColumns_result setSuccess(List<TRowResult> success) {
14211       this.success = success;
14212       return this;
14213     }
14214 
14215     public void unsetSuccess() {
14216       this.success = null;
14217     }
14218 
14219     /** Returns true if field success is set (has been asigned a value) and false otherwise */
14220     public boolean isSetSuccess() {
14221       return this.success != null;
14222     }
14223 
14224     public void setSuccessIsSet(boolean value) {
14225       if (!value) {
14226         this.success = null;
14227       }
14228     }
14229 
14230     public IOError getIo() {
14231       return this.io;
14232     }
14233 
14234     public getRowWithColumns_result setIo(IOError io) {
14235       this.io = io;
14236       return this;
14237     }
14238 
14239     public void unsetIo() {
14240       this.io = null;
14241     }
14242 
14243     /** Returns true if field io is set (has been asigned a value) and false otherwise */
14244     public boolean isSetIo() {
14245       return this.io != null;
14246     }
14247 
14248     public void setIoIsSet(boolean value) {
14249       if (!value) {
14250         this.io = null;
14251       }
14252     }
14253 
14254     public void setFieldValue(_Fields field, Object value) {
14255       switch (field) {
14256       case SUCCESS:
14257         if (value == null) {
14258           unsetSuccess();
14259         } else {
14260           setSuccess((List<TRowResult>)value);
14261         }
14262         break;
14263 
14264       case IO:
14265         if (value == null) {
14266           unsetIo();
14267         } else {
14268           setIo((IOError)value);
14269         }
14270         break;
14271 
14272       }
14273     }
14274 
14275     public void setFieldValue(int fieldID, Object value) {
14276       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
14277     }
14278 
14279     public Object getFieldValue(_Fields field) {
14280       switch (field) {
14281       case SUCCESS:
14282         return getSuccess();
14283 
14284       case IO:
14285         return getIo();
14286 
14287       }
14288       throw new IllegalStateException();
14289     }
14290 
14291     public Object getFieldValue(int fieldId) {
14292       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
14293     }
14294 
14295     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
14296     public boolean isSet(_Fields field) {
14297       switch (field) {
14298       case SUCCESS:
14299         return isSetSuccess();
14300       case IO:
14301         return isSetIo();
14302       }
14303       throw new IllegalStateException();
14304     }
14305 
14306     public boolean isSet(int fieldID) {
14307       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
14308     }
14309 
14310     @Override
14311     public boolean equals(Object that) {
14312       if (that == null)
14313         return false;
14314       if (that instanceof getRowWithColumns_result)
14315         return this.equals((getRowWithColumns_result)that);
14316       return false;
14317     }
14318 
14319     public boolean equals(getRowWithColumns_result that) {
14320       if (that == null)
14321         return false;
14322 
14323       boolean this_present_success = true && this.isSetSuccess();
14324       boolean that_present_success = true && that.isSetSuccess();
14325       if (this_present_success || that_present_success) {
14326         if (!(this_present_success && that_present_success))
14327           return false;
14328         if (!this.success.equals(that.success))
14329           return false;
14330       }
14331 
14332       boolean this_present_io = true && this.isSetIo();
14333       boolean that_present_io = true && that.isSetIo();
14334       if (this_present_io || that_present_io) {
14335         if (!(this_present_io && that_present_io))
14336           return false;
14337         if (!this.io.equals(that.io))
14338           return false;
14339       }
14340 
14341       return true;
14342     }
14343 
14344     @Override
14345     public int hashCode() {
14346       HashCodeBuilder builder = new HashCodeBuilder();
14347 
14348       boolean present_success = true && (isSetSuccess());
14349       builder.append(present_success);
14350       if (present_success)
14351         builder.append(success);
14352 
14353       boolean present_io = true && (isSetIo());
14354       builder.append(present_io);
14355       if (present_io)
14356         builder.append(io);
14357 
14358       return builder.toHashCode();
14359     }
14360 
14361     public void read(TProtocol iprot) throws TException {
14362       TField field;
14363       iprot.readStructBegin();
14364       while (true)
14365       {
14366         field = iprot.readFieldBegin();
14367         if (field.type == TType.STOP) {
14368           break;
14369         }
14370         _Fields fieldId = _Fields.findByThriftId(field.id);
14371         if (fieldId == null) {
14372           TProtocolUtil.skip(iprot, field.type);
14373         } else {
14374           switch (fieldId) {
14375             case SUCCESS:
14376               if (field.type == TType.LIST) {
14377                 {
14378                   TList _list46 = iprot.readListBegin();
14379                   this.success = new ArrayList<TRowResult>(_list46.size);
14380                   for (int _i47 = 0; _i47 < _list46.size; ++_i47)
14381                   {
14382                     TRowResult _elem48;
14383                     _elem48 = new TRowResult();
14384                     _elem48.read(iprot);
14385                     this.success.add(_elem48);
14386                   }
14387                   iprot.readListEnd();
14388                 }
14389               } else {
14390                 TProtocolUtil.skip(iprot, field.type);
14391               }
14392               break;
14393             case IO:
14394               if (field.type == TType.STRUCT) {
14395                 this.io = new IOError();
14396                 this.io.read(iprot);
14397               } else {
14398                 TProtocolUtil.skip(iprot, field.type);
14399               }
14400               break;
14401           }
14402           iprot.readFieldEnd();
14403         }
14404       }
14405       iprot.readStructEnd();
14406 
14407       // check for required fields of primitive type, which can't be checked in the validate method
14408       validate();
14409     }
14410 
14411     public void write(TProtocol oprot) throws TException {
14412       oprot.writeStructBegin(STRUCT_DESC);
14413 
14414       if (this.isSetSuccess()) {
14415         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
14416         {
14417           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
14418           for (TRowResult _iter49 : this.success)
14419           {
14420             _iter49.write(oprot);
14421           }
14422           oprot.writeListEnd();
14423         }
14424         oprot.writeFieldEnd();
14425       } else if (this.isSetIo()) {
14426         oprot.writeFieldBegin(IO_FIELD_DESC);
14427         this.io.write(oprot);
14428         oprot.writeFieldEnd();
14429       }
14430       oprot.writeFieldStop();
14431       oprot.writeStructEnd();
14432     }
14433 
14434     @Override
14435     public String toString() {
14436       StringBuilder sb = new StringBuilder("getRowWithColumns_result(");
14437       boolean first = true;
14438 
14439       sb.append("success:");
14440       if (this.success == null) {
14441         sb.append("null");
14442       } else {
14443         sb.append(this.success);
14444       }
14445       first = false;
14446       if (!first) sb.append(", ");
14447       sb.append("io:");
14448       if (this.io == null) {
14449         sb.append("null");
14450       } else {
14451         sb.append(this.io);
14452       }
14453       first = false;
14454       sb.append(")");
14455       return sb.toString();
14456     }
14457 
14458     public void validate() throws TException {
14459       // check for required fields
14460     }
14461 
14462   }
14463 
14464   public static class getRowTs_args implements TBase<getRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowTs_args>   {
14465     private static final TStruct STRUCT_DESC = new TStruct("getRowTs_args");
14466 
14467     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
14468     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
14469     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
14470 
14471     /**
14472      * name of the table
14473      */
14474     public byte[] tableName;
14475     /**
14476      * row key
14477      */
14478     public byte[] row;
14479     /**
14480      * timestamp
14481      */
14482     public long timestamp;
14483 
14484     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
14485     public enum _Fields implements TFieldIdEnum {
14486       /**
14487        * name of the table
14488        */
14489       TABLE_NAME((short)1, "tableName"),
14490       /**
14491        * row key
14492        */
14493       ROW((short)2, "row"),
14494       /**
14495        * timestamp
14496        */
14497       TIMESTAMP((short)3, "timestamp");
14498 
14499       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14500       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14501 
14502       static {
14503         for (_Fields field : EnumSet.allOf(_Fields.class)) {
14504           byId.put((int)field._thriftId, field);
14505           byName.put(field.getFieldName(), field);
14506         }
14507       }
14508 
14509       /**
14510        * Find the _Fields constant that matches fieldId, or null if its not found.
14511        */
14512       public static _Fields findByThriftId(int fieldId) {
14513         return byId.get(fieldId);
14514       }
14515 
14516       /**
14517        * Find the _Fields constant that matches fieldId, throwing an exception
14518        * if it is not found.
14519        */
14520       public static _Fields findByThriftIdOrThrow(int fieldId) {
14521         _Fields fields = findByThriftId(fieldId);
14522         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14523         return fields;
14524       }
14525 
14526       /**
14527        * Find the _Fields constant that matches name, or null if its not found.
14528        */
14529       public static _Fields findByName(String name) {
14530         return byName.get(name);
14531       }
14532 
14533       private final short _thriftId;
14534       private final String _fieldName;
14535 
14536       _Fields(short thriftId, String fieldName) {
14537         _thriftId = thriftId;
14538         _fieldName = fieldName;
14539       }
14540 
14541       public short getThriftFieldId() {
14542         return _thriftId;
14543       }
14544 
14545       public String getFieldName() {
14546         return _fieldName;
14547       }
14548     }
14549 
14550     // isset id assignments
14551     private static final int __TIMESTAMP_ISSET_ID = 0;
14552     private BitSet __isset_bit_vector = new BitSet(1);
14553 
14554     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
14555       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
14556           new FieldValueMetaData(TType.STRING)));
14557       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
14558           new FieldValueMetaData(TType.STRING)));
14559       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
14560           new FieldValueMetaData(TType.I64)));
14561     }});
14562 
14563     static {
14564       FieldMetaData.addStructMetaDataMap(getRowTs_args.class, metaDataMap);
14565     }
14566 
14567     public getRowTs_args() {
14568     }
14569 
14570     public getRowTs_args(
14571       byte[] tableName,
14572       byte[] row,
14573       long timestamp)
14574     {
14575       this();
14576       this.tableName = tableName;
14577       this.row = row;
14578       this.timestamp = timestamp;
14579       setTimestampIsSet(true);
14580     }
14581 
14582     /**
14583      * Performs a deep copy on <i>other</i>.
14584      */
14585     public getRowTs_args(getRowTs_args other) {
14586       __isset_bit_vector.clear();
14587       __isset_bit_vector.or(other.__isset_bit_vector);
14588       if (other.isSetTableName()) {
14589         this.tableName = other.tableName;
14590       }
14591       if (other.isSetRow()) {
14592         this.row = other.row;
14593       }
14594       this.timestamp = other.timestamp;
14595     }
14596 
14597     public getRowTs_args deepCopy() {
14598       return new getRowTs_args(this);
14599     }
14600 
14601     @Deprecated
14602     public getRowTs_args clone() {
14603       return new getRowTs_args(this);
14604     }
14605 
14606     /**
14607      * name of the table
14608      */
14609     public byte[] getTableName() {
14610       return this.tableName;
14611     }
14612 
14613     /**
14614      * name of the table
14615      */
14616     public getRowTs_args setTableName(byte[] tableName) {
14617       this.tableName = tableName;
14618       return this;
14619     }
14620 
14621     public void unsetTableName() {
14622       this.tableName = null;
14623     }
14624 
14625     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
14626     public boolean isSetTableName() {
14627       return this.tableName != null;
14628     }
14629 
14630     public void setTableNameIsSet(boolean value) {
14631       if (!value) {
14632         this.tableName = null;
14633       }
14634     }
14635 
14636     /**
14637      * row key
14638      */
14639     public byte[] getRow() {
14640       return this.row;
14641     }
14642 
14643     /**
14644      * row key
14645      */
14646     public getRowTs_args setRow(byte[] row) {
14647       this.row = row;
14648       return this;
14649     }
14650 
14651     public void unsetRow() {
14652       this.row = null;
14653     }
14654 
14655     /** Returns true if field row is set (has been asigned a value) and false otherwise */
14656     public boolean isSetRow() {
14657       return this.row != null;
14658     }
14659 
14660     public void setRowIsSet(boolean value) {
14661       if (!value) {
14662         this.row = null;
14663       }
14664     }
14665 
14666     /**
14667      * timestamp
14668      */
14669     public long getTimestamp() {
14670       return this.timestamp;
14671     }
14672 
14673     /**
14674      * timestamp
14675      */
14676     public getRowTs_args setTimestamp(long timestamp) {
14677       this.timestamp = timestamp;
14678       setTimestampIsSet(true);
14679       return this;
14680     }
14681 
14682     public void unsetTimestamp() {
14683       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
14684     }
14685 
14686     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
14687     public boolean isSetTimestamp() {
14688       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
14689     }
14690 
14691     public void setTimestampIsSet(boolean value) {
14692       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
14693     }
14694 
14695     public void setFieldValue(_Fields field, Object value) {
14696       switch (field) {
14697       case TABLE_NAME:
14698         if (value == null) {
14699           unsetTableName();
14700         } else {
14701           setTableName((byte[])value);
14702         }
14703         break;
14704 
14705       case ROW:
14706         if (value == null) {
14707           unsetRow();
14708         } else {
14709           setRow((byte[])value);
14710         }
14711         break;
14712 
14713       case TIMESTAMP:
14714         if (value == null) {
14715           unsetTimestamp();
14716         } else {
14717           setTimestamp((Long)value);
14718         }
14719         break;
14720 
14721       }
14722     }
14723 
14724     public void setFieldValue(int fieldID, Object value) {
14725       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
14726     }
14727 
14728     public Object getFieldValue(_Fields field) {
14729       switch (field) {
14730       case TABLE_NAME:
14731         return getTableName();
14732 
14733       case ROW:
14734         return getRow();
14735 
14736       case TIMESTAMP:
14737         return new Long(getTimestamp());
14738 
14739       }
14740       throw new IllegalStateException();
14741     }
14742 
14743     public Object getFieldValue(int fieldId) {
14744       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
14745     }
14746 
14747     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
14748     public boolean isSet(_Fields field) {
14749       switch (field) {
14750       case TABLE_NAME:
14751         return isSetTableName();
14752       case ROW:
14753         return isSetRow();
14754       case TIMESTAMP:
14755         return isSetTimestamp();
14756       }
14757       throw new IllegalStateException();
14758     }
14759 
14760     public boolean isSet(int fieldID) {
14761       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
14762     }
14763 
14764     @Override
14765     public boolean equals(Object that) {
14766       if (that == null)
14767         return false;
14768       if (that instanceof getRowTs_args)
14769         return this.equals((getRowTs_args)that);
14770       return false;
14771     }
14772 
14773     public boolean equals(getRowTs_args that) {
14774       if (that == null)
14775         return false;
14776 
14777       boolean this_present_tableName = true && this.isSetTableName();
14778       boolean that_present_tableName = true && that.isSetTableName();
14779       if (this_present_tableName || that_present_tableName) {
14780         if (!(this_present_tableName && that_present_tableName))
14781           return false;
14782         if (!java.util.Arrays.equals(this.tableName, that.tableName))
14783           return false;
14784       }
14785 
14786       boolean this_present_row = true && this.isSetRow();
14787       boolean that_present_row = true && that.isSetRow();
14788       if (this_present_row || that_present_row) {
14789         if (!(this_present_row && that_present_row))
14790           return false;
14791         if (!java.util.Arrays.equals(this.row, that.row))
14792           return false;
14793       }
14794 
14795       boolean this_present_timestamp = true;
14796       boolean that_present_timestamp = true;
14797       if (this_present_timestamp || that_present_timestamp) {
14798         if (!(this_present_timestamp && that_present_timestamp))
14799           return false;
14800         if (this.timestamp != that.timestamp)
14801           return false;
14802       }
14803 
14804       return true;
14805     }
14806 
14807     @Override
14808     public int hashCode() {
14809       HashCodeBuilder builder = new HashCodeBuilder();
14810 
14811       boolean present_tableName = true && (isSetTableName());
14812       builder.append(present_tableName);
14813       if (present_tableName)
14814         builder.append(tableName);
14815 
14816       boolean present_row = true && (isSetRow());
14817       builder.append(present_row);
14818       if (present_row)
14819         builder.append(row);
14820 
14821       boolean present_timestamp = true;
14822       builder.append(present_timestamp);
14823       if (present_timestamp)
14824         builder.append(timestamp);
14825 
14826       return builder.toHashCode();
14827     }
14828 
14829     public int compareTo(getRowTs_args other) {
14830       if (!getClass().equals(other.getClass())) {
14831         return getClass().getName().compareTo(other.getClass().getName());
14832       }
14833 
14834       int lastComparison = 0;
14835       getRowTs_args typedOther = (getRowTs_args)other;
14836 
14837       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
14838       if (lastComparison != 0) {
14839         return lastComparison;
14840       }
14841       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
14842       if (lastComparison != 0) {
14843         return lastComparison;
14844       }
14845       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
14846       if (lastComparison != 0) {
14847         return lastComparison;
14848       }
14849       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
14850       if (lastComparison != 0) {
14851         return lastComparison;
14852       }
14853       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
14854       if (lastComparison != 0) {
14855         return lastComparison;
14856       }
14857       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
14858       if (lastComparison != 0) {
14859         return lastComparison;
14860       }
14861       return 0;
14862     }
14863 
14864     public void read(TProtocol iprot) throws TException {
14865       TField field;
14866       iprot.readStructBegin();
14867       while (true)
14868       {
14869         field = iprot.readFieldBegin();
14870         if (field.type == TType.STOP) {
14871           break;
14872         }
14873         _Fields fieldId = _Fields.findByThriftId(field.id);
14874         if (fieldId == null) {
14875           TProtocolUtil.skip(iprot, field.type);
14876         } else {
14877           switch (fieldId) {
14878             case TABLE_NAME:
14879               if (field.type == TType.STRING) {
14880                 this.tableName = iprot.readBinary();
14881               } else {
14882                 TProtocolUtil.skip(iprot, field.type);
14883               }
14884               break;
14885             case ROW:
14886               if (field.type == TType.STRING) {
14887                 this.row = iprot.readBinary();
14888               } else {
14889                 TProtocolUtil.skip(iprot, field.type);
14890               }
14891               break;
14892             case TIMESTAMP:
14893               if (field.type == TType.I64) {
14894                 this.timestamp = iprot.readI64();
14895                 setTimestampIsSet(true);
14896               } else {
14897                 TProtocolUtil.skip(iprot, field.type);
14898               }
14899               break;
14900           }
14901           iprot.readFieldEnd();
14902         }
14903       }
14904       iprot.readStructEnd();
14905 
14906       // check for required fields of primitive type, which can't be checked in the validate method
14907       validate();
14908     }
14909 
14910     public void write(TProtocol oprot) throws TException {
14911       validate();
14912 
14913       oprot.writeStructBegin(STRUCT_DESC);
14914       if (this.tableName != null) {
14915         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
14916         oprot.writeBinary(this.tableName);
14917         oprot.writeFieldEnd();
14918       }
14919       if (this.row != null) {
14920         oprot.writeFieldBegin(ROW_FIELD_DESC);
14921         oprot.writeBinary(this.row);
14922         oprot.writeFieldEnd();
14923       }
14924       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
14925       oprot.writeI64(this.timestamp);
14926       oprot.writeFieldEnd();
14927       oprot.writeFieldStop();
14928       oprot.writeStructEnd();
14929     }
14930 
14931     @Override
14932     public String toString() {
14933       StringBuilder sb = new StringBuilder("getRowTs_args(");
14934       boolean first = true;
14935 
14936       sb.append("tableName:");
14937       if (this.tableName == null) {
14938         sb.append("null");
14939       } else {
14940         sb.append(this.tableName);
14941       }
14942       first = false;
14943       if (!first) sb.append(", ");
14944       sb.append("row:");
14945       if (this.row == null) {
14946         sb.append("null");
14947       } else {
14948         sb.append(this.row);
14949       }
14950       first = false;
14951       if (!first) sb.append(", ");
14952       sb.append("timestamp:");
14953       sb.append(this.timestamp);
14954       first = false;
14955       sb.append(")");
14956       return sb.toString();
14957     }
14958 
14959     public void validate() throws TException {
14960       // check for required fields
14961     }
14962 
14963   }
14964 
14965   public static class getRowTs_result implements TBase<getRowTs_result._Fields>, java.io.Serializable, Cloneable   {
14966     private static final TStruct STRUCT_DESC = new TStruct("getRowTs_result");
14967 
14968     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
14969     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
14970 
14971     public List<TRowResult> success;
14972     public IOError io;
14973 
14974     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
14975     public enum _Fields implements TFieldIdEnum {
14976       SUCCESS((short)0, "success"),
14977       IO((short)1, "io");
14978 
14979       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14980       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14981 
14982       static {
14983         for (_Fields field : EnumSet.allOf(_Fields.class)) {
14984           byId.put((int)field._thriftId, field);
14985           byName.put(field.getFieldName(), field);
14986         }
14987       }
14988 
14989       /**
14990        * Find the _Fields constant that matches fieldId, or null if its not found.
14991        */
14992       public static _Fields findByThriftId(int fieldId) {
14993         return byId.get(fieldId);
14994       }
14995 
14996       /**
14997        * Find the _Fields constant that matches fieldId, throwing an exception
14998        * if it is not found.
14999        */
15000       public static _Fields findByThriftIdOrThrow(int fieldId) {
15001         _Fields fields = findByThriftId(fieldId);
15002         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15003         return fields;
15004       }
15005 
15006       /**
15007        * Find the _Fields constant that matches name, or null if its not found.
15008        */
15009       public static _Fields findByName(String name) {
15010         return byName.get(name);
15011       }
15012 
15013       private final short _thriftId;
15014       private final String _fieldName;
15015 
15016       _Fields(short thriftId, String fieldName) {
15017         _thriftId = thriftId;
15018         _fieldName = fieldName;
15019       }
15020 
15021       public short getThriftFieldId() {
15022         return _thriftId;
15023       }
15024 
15025       public String getFieldName() {
15026         return _fieldName;
15027       }
15028     }
15029 
15030     // isset id assignments
15031 
15032     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
15033       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
15034           new ListMetaData(TType.LIST,
15035               new StructMetaData(TType.STRUCT, TRowResult.class))));
15036       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
15037           new FieldValueMetaData(TType.STRUCT)));
15038     }});
15039 
15040     static {
15041       FieldMetaData.addStructMetaDataMap(getRowTs_result.class, metaDataMap);
15042     }
15043 
15044     public getRowTs_result() {
15045     }
15046 
15047     public getRowTs_result(
15048       List<TRowResult> success,
15049       IOError io)
15050     {
15051       this();
15052       this.success = success;
15053       this.io = io;
15054     }
15055 
15056     /**
15057      * Performs a deep copy on <i>other</i>.
15058      */
15059     public getRowTs_result(getRowTs_result other) {
15060       if (other.isSetSuccess()) {
15061         List<TRowResult> __this__success = new ArrayList<TRowResult>();
15062         for (TRowResult other_element : other.success) {
15063           __this__success.add(new TRowResult(other_element));
15064         }
15065         this.success = __this__success;
15066       }
15067       if (other.isSetIo()) {
15068         this.io = new IOError(other.io);
15069       }
15070     }
15071 
15072     public getRowTs_result deepCopy() {
15073       return new getRowTs_result(this);
15074     }
15075 
15076     @Deprecated
15077     public getRowTs_result clone() {
15078       return new getRowTs_result(this);
15079     }
15080 
15081     public int getSuccessSize() {
15082       return (this.success == null) ? 0 : this.success.size();
15083     }
15084 
15085     public java.util.Iterator<TRowResult> getSuccessIterator() {
15086       return (this.success == null) ? null : this.success.iterator();
15087     }
15088 
15089     public void addToSuccess(TRowResult elem) {
15090       if (this.success == null) {
15091         this.success = new ArrayList<TRowResult>();
15092       }
15093       this.success.add(elem);
15094     }
15095 
15096     public List<TRowResult> getSuccess() {
15097       return this.success;
15098     }
15099 
15100     public getRowTs_result setSuccess(List<TRowResult> success) {
15101       this.success = success;
15102       return this;
15103     }
15104 
15105     public void unsetSuccess() {
15106       this.success = null;
15107     }
15108 
15109     /** Returns true if field success is set (has been asigned a value) and false otherwise */
15110     public boolean isSetSuccess() {
15111       return this.success != null;
15112     }
15113 
15114     public void setSuccessIsSet(boolean value) {
15115       if (!value) {
15116         this.success = null;
15117       }
15118     }
15119 
15120     public IOError getIo() {
15121       return this.io;
15122     }
15123 
15124     public getRowTs_result setIo(IOError io) {
15125       this.io = io;
15126       return this;
15127     }
15128 
15129     public void unsetIo() {
15130       this.io = null;
15131     }
15132 
15133     /** Returns true if field io is set (has been asigned a value) and false otherwise */
15134     public boolean isSetIo() {
15135       return this.io != null;
15136     }
15137 
15138     public void setIoIsSet(boolean value) {
15139       if (!value) {
15140         this.io = null;
15141       }
15142     }
15143 
15144     public void setFieldValue(_Fields field, Object value) {
15145       switch (field) {
15146       case SUCCESS:
15147         if (value == null) {
15148           unsetSuccess();
15149         } else {
15150           setSuccess((List<TRowResult>)value);
15151         }
15152         break;
15153 
15154       case IO:
15155         if (value == null) {
15156           unsetIo();
15157         } else {
15158           setIo((IOError)value);
15159         }
15160         break;
15161 
15162       }
15163     }
15164 
15165     public void setFieldValue(int fieldID, Object value) {
15166       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
15167     }
15168 
15169     public Object getFieldValue(_Fields field) {
15170       switch (field) {
15171       case SUCCESS:
15172         return getSuccess();
15173 
15174       case IO:
15175         return getIo();
15176 
15177       }
15178       throw new IllegalStateException();
15179     }
15180 
15181     public Object getFieldValue(int fieldId) {
15182       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
15183     }
15184 
15185     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
15186     public boolean isSet(_Fields field) {
15187       switch (field) {
15188       case SUCCESS:
15189         return isSetSuccess();
15190       case IO:
15191         return isSetIo();
15192       }
15193       throw new IllegalStateException();
15194     }
15195 
15196     public boolean isSet(int fieldID) {
15197       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
15198     }
15199 
15200     @Override
15201     public boolean equals(Object that) {
15202       if (that == null)
15203         return false;
15204       if (that instanceof getRowTs_result)
15205         return this.equals((getRowTs_result)that);
15206       return false;
15207     }
15208 
15209     public boolean equals(getRowTs_result that) {
15210       if (that == null)
15211         return false;
15212 
15213       boolean this_present_success = true && this.isSetSuccess();
15214       boolean that_present_success = true && that.isSetSuccess();
15215       if (this_present_success || that_present_success) {
15216         if (!(this_present_success && that_present_success))
15217           return false;
15218         if (!this.success.equals(that.success))
15219           return false;
15220       }
15221 
15222       boolean this_present_io = true && this.isSetIo();
15223       boolean that_present_io = true && that.isSetIo();
15224       if (this_present_io || that_present_io) {
15225         if (!(this_present_io && that_present_io))
15226           return false;
15227         if (!this.io.equals(that.io))
15228           return false;
15229       }
15230 
15231       return true;
15232     }
15233 
15234     @Override
15235     public int hashCode() {
15236       HashCodeBuilder builder = new HashCodeBuilder();
15237 
15238       boolean present_success = true && (isSetSuccess());
15239       builder.append(present_success);
15240       if (present_success)
15241         builder.append(success);
15242 
15243       boolean present_io = true && (isSetIo());
15244       builder.append(present_io);
15245       if (present_io)
15246         builder.append(io);
15247 
15248       return builder.toHashCode();
15249     }
15250 
15251     public void read(TProtocol iprot) throws TException {
15252       TField field;
15253       iprot.readStructBegin();
15254       while (true)
15255       {
15256         field = iprot.readFieldBegin();
15257         if (field.type == TType.STOP) {
15258           break;
15259         }
15260         _Fields fieldId = _Fields.findByThriftId(field.id);
15261         if (fieldId == null) {
15262           TProtocolUtil.skip(iprot, field.type);
15263         } else {
15264           switch (fieldId) {
15265             case SUCCESS:
15266               if (field.type == TType.LIST) {
15267                 {
15268                   TList _list50 = iprot.readListBegin();
15269                   this.success = new ArrayList<TRowResult>(_list50.size);
15270                   for (int _i51 = 0; _i51 < _list50.size; ++_i51)
15271                   {
15272                     TRowResult _elem52;
15273                     _elem52 = new TRowResult();
15274                     _elem52.read(iprot);
15275                     this.success.add(_elem52);
15276                   }
15277                   iprot.readListEnd();
15278                 }
15279               } else {
15280                 TProtocolUtil.skip(iprot, field.type);
15281               }
15282               break;
15283             case IO:
15284               if (field.type == TType.STRUCT) {
15285                 this.io = new IOError();
15286                 this.io.read(iprot);
15287               } else {
15288                 TProtocolUtil.skip(iprot, field.type);
15289               }
15290               break;
15291           }
15292           iprot.readFieldEnd();
15293         }
15294       }
15295       iprot.readStructEnd();
15296 
15297       // check for required fields of primitive type, which can't be checked in the validate method
15298       validate();
15299     }
15300 
15301     public void write(TProtocol oprot) throws TException {
15302       oprot.writeStructBegin(STRUCT_DESC);
15303 
15304       if (this.isSetSuccess()) {
15305         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
15306         {
15307           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
15308           for (TRowResult _iter53 : this.success)
15309           {
15310             _iter53.write(oprot);
15311           }
15312           oprot.writeListEnd();
15313         }
15314         oprot.writeFieldEnd();
15315       } else if (this.isSetIo()) {
15316         oprot.writeFieldBegin(IO_FIELD_DESC);
15317         this.io.write(oprot);
15318         oprot.writeFieldEnd();
15319       }
15320       oprot.writeFieldStop();
15321       oprot.writeStructEnd();
15322     }
15323 
15324     @Override
15325     public String toString() {
15326       StringBuilder sb = new StringBuilder("getRowTs_result(");
15327       boolean first = true;
15328 
15329       sb.append("success:");
15330       if (this.success == null) {
15331         sb.append("null");
15332       } else {
15333         sb.append(this.success);
15334       }
15335       first = false;
15336       if (!first) sb.append(", ");
15337       sb.append("io:");
15338       if (this.io == null) {
15339         sb.append("null");
15340       } else {
15341         sb.append(this.io);
15342       }
15343       first = false;
15344       sb.append(")");
15345       return sb.toString();
15346     }
15347 
15348     public void validate() throws TException {
15349       // check for required fields
15350     }
15351 
15352   }
15353 
15354   public static class getRowWithColumnsTs_args implements TBase<getRowWithColumnsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumnsTs_args>   {
15355     private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_args");
15356 
15357     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
15358     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
15359     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
15360     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
15361 
15362     /**
15363      * name of table
15364      */
15365     public byte[] tableName;
15366     /**
15367      * row key
15368      */
15369     public byte[] row;
15370     /**
15371      * List of columns to return, null for all columns
15372      */
15373     public List<byte[]> columns;
15374     public long timestamp;
15375 
15376     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
15377     public enum _Fields implements TFieldIdEnum {
15378       /**
15379        * name of table
15380        */
15381       TABLE_NAME((short)1, "tableName"),
15382       /**
15383        * row key
15384        */
15385       ROW((short)2, "row"),
15386       /**
15387        * List of columns to return, null for all columns
15388        */
15389       COLUMNS((short)3, "columns"),
15390       TIMESTAMP((short)4, "timestamp");
15391 
15392       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
15393       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15394 
15395       static {
15396         for (_Fields field : EnumSet.allOf(_Fields.class)) {
15397           byId.put((int)field._thriftId, field);
15398           byName.put(field.getFieldName(), field);
15399         }
15400       }
15401 
15402       /**
15403        * Find the _Fields constant that matches fieldId, or null if its not found.
15404        */
15405       public static _Fields findByThriftId(int fieldId) {
15406         return byId.get(fieldId);
15407       }
15408 
15409       /**
15410        * Find the _Fields constant that matches fieldId, throwing an exception
15411        * if it is not found.
15412        */
15413       public static _Fields findByThriftIdOrThrow(int fieldId) {
15414         _Fields fields = findByThriftId(fieldId);
15415         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15416         return fields;
15417       }
15418 
15419       /**
15420        * Find the _Fields constant that matches name, or null if its not found.
15421        */
15422       public static _Fields findByName(String name) {
15423         return byName.get(name);
15424       }
15425 
15426       private final short _thriftId;
15427       private final String _fieldName;
15428 
15429       _Fields(short thriftId, String fieldName) {
15430         _thriftId = thriftId;
15431         _fieldName = fieldName;
15432       }
15433 
15434       public short getThriftFieldId() {
15435         return _thriftId;
15436       }
15437 
15438       public String getFieldName() {
15439         return _fieldName;
15440       }
15441     }
15442 
15443     // isset id assignments
15444     private static final int __TIMESTAMP_ISSET_ID = 0;
15445     private BitSet __isset_bit_vector = new BitSet(1);
15446 
15447     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
15448       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
15449           new FieldValueMetaData(TType.STRING)));
15450       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
15451           new FieldValueMetaData(TType.STRING)));
15452       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
15453           new ListMetaData(TType.LIST,
15454               new FieldValueMetaData(TType.STRING))));
15455       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
15456           new FieldValueMetaData(TType.I64)));
15457     }});
15458 
15459     static {
15460       FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_args.class, metaDataMap);
15461     }
15462 
15463     public getRowWithColumnsTs_args() {
15464     }
15465 
15466     public getRowWithColumnsTs_args(
15467       byte[] tableName,
15468       byte[] row,
15469       List<byte[]> columns,
15470       long timestamp)
15471     {
15472       this();
15473       this.tableName = tableName;
15474       this.row = row;
15475       this.columns = columns;
15476       this.timestamp = timestamp;
15477       setTimestampIsSet(true);
15478     }
15479 
15480     /**
15481      * Performs a deep copy on <i>other</i>.
15482      */
15483     public getRowWithColumnsTs_args(getRowWithColumnsTs_args other) {
15484       __isset_bit_vector.clear();
15485       __isset_bit_vector.or(other.__isset_bit_vector);
15486       if (other.isSetTableName()) {
15487         this.tableName = other.tableName;
15488       }
15489       if (other.isSetRow()) {
15490         this.row = other.row;
15491       }
15492       if (other.isSetColumns()) {
15493         List<byte[]> __this__columns = new ArrayList<byte[]>();
15494         for (byte[] other_element : other.columns) {
15495           __this__columns.add(other_element);
15496         }
15497         this.columns = __this__columns;
15498       }
15499       this.timestamp = other.timestamp;
15500     }
15501 
15502     public getRowWithColumnsTs_args deepCopy() {
15503       return new getRowWithColumnsTs_args(this);
15504     }
15505 
15506     @Deprecated
15507     public getRowWithColumnsTs_args clone() {
15508       return new getRowWithColumnsTs_args(this);
15509     }
15510 
15511     /**
15512      * name of table
15513      */
15514     public byte[] getTableName() {
15515       return this.tableName;
15516     }
15517 
15518     /**
15519      * name of table
15520      */
15521     public getRowWithColumnsTs_args setTableName(byte[] tableName) {
15522       this.tableName = tableName;
15523       return this;
15524     }
15525 
15526     public void unsetTableName() {
15527       this.tableName = null;
15528     }
15529 
15530     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
15531     public boolean isSetTableName() {
15532       return this.tableName != null;
15533     }
15534 
15535     public void setTableNameIsSet(boolean value) {
15536       if (!value) {
15537         this.tableName = null;
15538       }
15539     }
15540 
15541     /**
15542      * row key
15543      */
15544     public byte[] getRow() {
15545       return this.row;
15546     }
15547 
15548     /**
15549      * row key
15550      */
15551     public getRowWithColumnsTs_args setRow(byte[] row) {
15552       this.row = row;
15553       return this;
15554     }
15555 
15556     public void unsetRow() {
15557       this.row = null;
15558     }
15559 
15560     /** Returns true if field row is set (has been asigned a value) and false otherwise */
15561     public boolean isSetRow() {
15562       return this.row != null;
15563     }
15564 
15565     public void setRowIsSet(boolean value) {
15566       if (!value) {
15567         this.row = null;
15568       }
15569     }
15570 
15571     public int getColumnsSize() {
15572       return (this.columns == null) ? 0 : this.columns.size();
15573     }
15574 
15575     public java.util.Iterator<byte[]> getColumnsIterator() {
15576       return (this.columns == null) ? null : this.columns.iterator();
15577     }
15578 
15579     public void addToColumns(byte[] elem) {
15580       if (this.columns == null) {
15581         this.columns = new ArrayList<byte[]>();
15582       }
15583       this.columns.add(elem);
15584     }
15585 
15586     /**
15587      * List of columns to return, null for all columns
15588      */
15589     public List<byte[]> getColumns() {
15590       return this.columns;
15591     }
15592 
15593     /**
15594      * List of columns to return, null for all columns
15595      */
15596     public getRowWithColumnsTs_args setColumns(List<byte[]> columns) {
15597       this.columns = columns;
15598       return this;
15599     }
15600 
15601     public void unsetColumns() {
15602       this.columns = null;
15603     }
15604 
15605     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
15606     public boolean isSetColumns() {
15607       return this.columns != null;
15608     }
15609 
15610     public void setColumnsIsSet(boolean value) {
15611       if (!value) {
15612         this.columns = null;
15613       }
15614     }
15615 
15616     public long getTimestamp() {
15617       return this.timestamp;
15618     }
15619 
15620     public getRowWithColumnsTs_args setTimestamp(long timestamp) {
15621       this.timestamp = timestamp;
15622       setTimestampIsSet(true);
15623       return this;
15624     }
15625 
15626     public void unsetTimestamp() {
15627       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
15628     }
15629 
15630     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
15631     public boolean isSetTimestamp() {
15632       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
15633     }
15634 
15635     public void setTimestampIsSet(boolean value) {
15636       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
15637     }
15638 
15639     public void setFieldValue(_Fields field, Object value) {
15640       switch (field) {
15641       case TABLE_NAME:
15642         if (value == null) {
15643           unsetTableName();
15644         } else {
15645           setTableName((byte[])value);
15646         }
15647         break;
15648 
15649       case ROW:
15650         if (value == null) {
15651           unsetRow();
15652         } else {
15653           setRow((byte[])value);
15654         }
15655         break;
15656 
15657       case COLUMNS:
15658         if (value == null) {
15659           unsetColumns();
15660         } else {
15661           setColumns((List<byte[]>)value);
15662         }
15663         break;
15664 
15665       case TIMESTAMP:
15666         if (value == null) {
15667           unsetTimestamp();
15668         } else {
15669           setTimestamp((Long)value);
15670         }
15671         break;
15672 
15673       }
15674     }
15675 
15676     public void setFieldValue(int fieldID, Object value) {
15677       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
15678     }
15679 
15680     public Object getFieldValue(_Fields field) {
15681       switch (field) {
15682       case TABLE_NAME:
15683         return getTableName();
15684 
15685       case ROW:
15686         return getRow();
15687 
15688       case COLUMNS:
15689         return getColumns();
15690 
15691       case TIMESTAMP:
15692         return new Long(getTimestamp());
15693 
15694       }
15695       throw new IllegalStateException();
15696     }
15697 
15698     public Object getFieldValue(int fieldId) {
15699       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
15700     }
15701 
15702     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
15703     public boolean isSet(_Fields field) {
15704       switch (field) {
15705       case TABLE_NAME:
15706         return isSetTableName();
15707       case ROW:
15708         return isSetRow();
15709       case COLUMNS:
15710         return isSetColumns();
15711       case TIMESTAMP:
15712         return isSetTimestamp();
15713       }
15714       throw new IllegalStateException();
15715     }
15716 
15717     public boolean isSet(int fieldID) {
15718       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
15719     }
15720 
15721     @Override
15722     public boolean equals(Object that) {
15723       if (that == null)
15724         return false;
15725       if (that instanceof getRowWithColumnsTs_args)
15726         return this.equals((getRowWithColumnsTs_args)that);
15727       return false;
15728     }
15729 
15730     public boolean equals(getRowWithColumnsTs_args that) {
15731       if (that == null)
15732         return false;
15733 
15734       boolean this_present_tableName = true && this.isSetTableName();
15735       boolean that_present_tableName = true && that.isSetTableName();
15736       if (this_present_tableName || that_present_tableName) {
15737         if (!(this_present_tableName && that_present_tableName))
15738           return false;
15739         if (!java.util.Arrays.equals(this.tableName, that.tableName))
15740           return false;
15741       }
15742 
15743       boolean this_present_row = true && this.isSetRow();
15744       boolean that_present_row = true && that.isSetRow();
15745       if (this_present_row || that_present_row) {
15746         if (!(this_present_row && that_present_row))
15747           return false;
15748         if (!java.util.Arrays.equals(this.row, that.row))
15749           return false;
15750       }
15751 
15752       boolean this_present_columns = true && this.isSetColumns();
15753       boolean that_present_columns = true && that.isSetColumns();
15754       if (this_present_columns || that_present_columns) {
15755         if (!(this_present_columns && that_present_columns))
15756           return false;
15757         if (!this.columns.equals(that.columns))
15758           return false;
15759       }
15760 
15761       boolean this_present_timestamp = true;
15762       boolean that_present_timestamp = true;
15763       if (this_present_timestamp || that_present_timestamp) {
15764         if (!(this_present_timestamp && that_present_timestamp))
15765           return false;
15766         if (this.timestamp != that.timestamp)
15767           return false;
15768       }
15769 
15770       return true;
15771     }
15772 
15773     @Override
15774     public int hashCode() {
15775       HashCodeBuilder builder = new HashCodeBuilder();
15776 
15777       boolean present_tableName = true && (isSetTableName());
15778       builder.append(present_tableName);
15779       if (present_tableName)
15780         builder.append(tableName);
15781 
15782       boolean present_row = true && (isSetRow());
15783       builder.append(present_row);
15784       if (present_row)
15785         builder.append(row);
15786 
15787       boolean present_columns = true && (isSetColumns());
15788       builder.append(present_columns);
15789       if (present_columns)
15790         builder.append(columns);
15791 
15792       boolean present_timestamp = true;
15793       builder.append(present_timestamp);
15794       if (present_timestamp)
15795         builder.append(timestamp);
15796 
15797       return builder.toHashCode();
15798     }
15799 
15800     public int compareTo(getRowWithColumnsTs_args other) {
15801       if (!getClass().equals(other.getClass())) {
15802         return getClass().getName().compareTo(other.getClass().getName());
15803       }
15804 
15805       int lastComparison = 0;
15806       getRowWithColumnsTs_args typedOther = (getRowWithColumnsTs_args)other;
15807 
15808       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
15809       if (lastComparison != 0) {
15810         return lastComparison;
15811       }
15812       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
15813       if (lastComparison != 0) {
15814         return lastComparison;
15815       }
15816       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
15817       if (lastComparison != 0) {
15818         return lastComparison;
15819       }
15820       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
15821       if (lastComparison != 0) {
15822         return lastComparison;
15823       }
15824       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
15825       if (lastComparison != 0) {
15826         return lastComparison;
15827       }
15828       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
15829       if (lastComparison != 0) {
15830         return lastComparison;
15831       }
15832       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
15833       if (lastComparison != 0) {
15834         return lastComparison;
15835       }
15836       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
15837       if (lastComparison != 0) {
15838         return lastComparison;
15839       }
15840       return 0;
15841     }
15842 
15843     public void read(TProtocol iprot) throws TException {
15844       TField field;
15845       iprot.readStructBegin();
15846       while (true)
15847       {
15848         field = iprot.readFieldBegin();
15849         if (field.type == TType.STOP) {
15850           break;
15851         }
15852         _Fields fieldId = _Fields.findByThriftId(field.id);
15853         if (fieldId == null) {
15854           TProtocolUtil.skip(iprot, field.type);
15855         } else {
15856           switch (fieldId) {
15857             case TABLE_NAME:
15858               if (field.type == TType.STRING) {
15859                 this.tableName = iprot.readBinary();
15860               } else {
15861                 TProtocolUtil.skip(iprot, field.type);
15862               }
15863               break;
15864             case ROW:
15865               if (field.type == TType.STRING) {
15866                 this.row = iprot.readBinary();
15867               } else {
15868                 TProtocolUtil.skip(iprot, field.type);
15869               }
15870               break;
15871             case COLUMNS:
15872               if (field.type == TType.LIST) {
15873                 {
15874                   TList _list54 = iprot.readListBegin();
15875                   this.columns = new ArrayList<byte[]>(_list54.size);
15876                   for (int _i55 = 0; _i55 < _list54.size; ++_i55)
15877                   {
15878                     byte[] _elem56;
15879                     _elem56 = iprot.readBinary();
15880                     this.columns.add(_elem56);
15881                   }
15882                   iprot.readListEnd();
15883                 }
15884               } else {
15885                 TProtocolUtil.skip(iprot, field.type);
15886               }
15887               break;
15888             case TIMESTAMP:
15889               if (field.type == TType.I64) {
15890                 this.timestamp = iprot.readI64();
15891                 setTimestampIsSet(true);
15892               } else {
15893                 TProtocolUtil.skip(iprot, field.type);
15894               }
15895               break;
15896           }
15897           iprot.readFieldEnd();
15898         }
15899       }
15900       iprot.readStructEnd();
15901 
15902       // check for required fields of primitive type, which can't be checked in the validate method
15903       validate();
15904     }
15905 
15906     public void write(TProtocol oprot) throws TException {
15907       validate();
15908 
15909       oprot.writeStructBegin(STRUCT_DESC);
15910       if (this.tableName != null) {
15911         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
15912         oprot.writeBinary(this.tableName);
15913         oprot.writeFieldEnd();
15914       }
15915       if (this.row != null) {
15916         oprot.writeFieldBegin(ROW_FIELD_DESC);
15917         oprot.writeBinary(this.row);
15918         oprot.writeFieldEnd();
15919       }
15920       if (this.columns != null) {
15921         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
15922         {
15923           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
15924           for (byte[] _iter57 : this.columns)
15925           {
15926             oprot.writeBinary(_iter57);
15927           }
15928           oprot.writeListEnd();
15929         }
15930         oprot.writeFieldEnd();
15931       }
15932       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
15933       oprot.writeI64(this.timestamp);
15934       oprot.writeFieldEnd();
15935       oprot.writeFieldStop();
15936       oprot.writeStructEnd();
15937     }
15938 
15939     @Override
15940     public String toString() {
15941       StringBuilder sb = new StringBuilder("getRowWithColumnsTs_args(");
15942       boolean first = true;
15943 
15944       sb.append("tableName:");
15945       if (this.tableName == null) {
15946         sb.append("null");
15947       } else {
15948         sb.append(this.tableName);
15949       }
15950       first = false;
15951       if (!first) sb.append(", ");
15952       sb.append("row:");
15953       if (this.row == null) {
15954         sb.append("null");
15955       } else {
15956         sb.append(this.row);
15957       }
15958       first = false;
15959       if (!first) sb.append(", ");
15960       sb.append("columns:");
15961       if (this.columns == null) {
15962         sb.append("null");
15963       } else {
15964         sb.append(this.columns);
15965       }
15966       first = false;
15967       if (!first) sb.append(", ");
15968       sb.append("timestamp:");
15969       sb.append(this.timestamp);
15970       first = false;
15971       sb.append(")");
15972       return sb.toString();
15973     }
15974 
15975     public void validate() throws TException {
15976       // check for required fields
15977     }
15978 
15979   }
15980 
15981   public static class getRowWithColumnsTs_result implements TBase<getRowWithColumnsTs_result._Fields>, java.io.Serializable, Cloneable   {
15982     private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_result");
15983 
15984     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
15985     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
15986 
15987     public List<TRowResult> success;
15988     public IOError io;
15989 
15990     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
15991     public enum _Fields implements TFieldIdEnum {
15992       SUCCESS((short)0, "success"),
15993       IO((short)1, "io");
15994 
15995       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
15996       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15997 
15998       static {
15999         for (_Fields field : EnumSet.allOf(_Fields.class)) {
16000           byId.put((int)field._thriftId, field);
16001           byName.put(field.getFieldName(), field);
16002         }
16003       }
16004 
16005       /**
16006        * Find the _Fields constant that matches fieldId, or null if its not found.
16007        */
16008       public static _Fields findByThriftId(int fieldId) {
16009         return byId.get(fieldId);
16010       }
16011 
16012       /**
16013        * Find the _Fields constant that matches fieldId, throwing an exception
16014        * if it is not found.
16015        */
16016       public static _Fields findByThriftIdOrThrow(int fieldId) {
16017         _Fields fields = findByThriftId(fieldId);
16018         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16019         return fields;
16020       }
16021 
16022       /**
16023        * Find the _Fields constant that matches name, or null if its not found.
16024        */
16025       public static _Fields findByName(String name) {
16026         return byName.get(name);
16027       }
16028 
16029       private final short _thriftId;
16030       private final String _fieldName;
16031 
16032       _Fields(short thriftId, String fieldName) {
16033         _thriftId = thriftId;
16034         _fieldName = fieldName;
16035       }
16036 
16037       public short getThriftFieldId() {
16038         return _thriftId;
16039       }
16040 
16041       public String getFieldName() {
16042         return _fieldName;
16043       }
16044     }
16045 
16046     // isset id assignments
16047 
16048     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16049       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
16050           new ListMetaData(TType.LIST,
16051               new StructMetaData(TType.STRUCT, TRowResult.class))));
16052       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
16053           new FieldValueMetaData(TType.STRUCT)));
16054     }});
16055 
16056     static {
16057       FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_result.class, metaDataMap);
16058     }
16059 
16060     public getRowWithColumnsTs_result() {
16061     }
16062 
16063     public getRowWithColumnsTs_result(
16064       List<TRowResult> success,
16065       IOError io)
16066     {
16067       this();
16068       this.success = success;
16069       this.io = io;
16070     }
16071 
16072     /**
16073      * Performs a deep copy on <i>other</i>.
16074      */
16075     public getRowWithColumnsTs_result(getRowWithColumnsTs_result other) {
16076       if (other.isSetSuccess()) {
16077         List<TRowResult> __this__success = new ArrayList<TRowResult>();
16078         for (TRowResult other_element : other.success) {
16079           __this__success.add(new TRowResult(other_element));
16080         }
16081         this.success = __this__success;
16082       }
16083       if (other.isSetIo()) {
16084         this.io = new IOError(other.io);
16085       }
16086     }
16087 
16088     public getRowWithColumnsTs_result deepCopy() {
16089       return new getRowWithColumnsTs_result(this);
16090     }
16091 
16092     @Deprecated
16093     public getRowWithColumnsTs_result clone() {
16094       return new getRowWithColumnsTs_result(this);
16095     }
16096 
16097     public int getSuccessSize() {
16098       return (this.success == null) ? 0 : this.success.size();
16099     }
16100 
16101     public java.util.Iterator<TRowResult> getSuccessIterator() {
16102       return (this.success == null) ? null : this.success.iterator();
16103     }
16104 
16105     public void addToSuccess(TRowResult elem) {
16106       if (this.success == null) {
16107         this.success = new ArrayList<TRowResult>();
16108       }
16109       this.success.add(elem);
16110     }
16111 
16112     public List<TRowResult> getSuccess() {
16113       return this.success;
16114     }
16115 
16116     public getRowWithColumnsTs_result setSuccess(List<TRowResult> success) {
16117       this.success = success;
16118       return this;
16119     }
16120 
16121     public void unsetSuccess() {
16122       this.success = null;
16123     }
16124 
16125     /** Returns true if field success is set (has been asigned a value) and false otherwise */
16126     public boolean isSetSuccess() {
16127       return this.success != null;
16128     }
16129 
16130     public void setSuccessIsSet(boolean value) {
16131       if (!value) {
16132         this.success = null;
16133       }
16134     }
16135 
16136     public IOError getIo() {
16137       return this.io;
16138     }
16139 
16140     public getRowWithColumnsTs_result setIo(IOError io) {
16141       this.io = io;
16142       return this;
16143     }
16144 
16145     public void unsetIo() {
16146       this.io = null;
16147     }
16148 
16149     /** Returns true if field io is set (has been asigned a value) and false otherwise */
16150     public boolean isSetIo() {
16151       return this.io != null;
16152     }
16153 
16154     public void setIoIsSet(boolean value) {
16155       if (!value) {
16156         this.io = null;
16157       }
16158     }
16159 
16160     public void setFieldValue(_Fields field, Object value) {
16161       switch (field) {
16162       case SUCCESS:
16163         if (value == null) {
16164           unsetSuccess();
16165         } else {
16166           setSuccess((List<TRowResult>)value);
16167         }
16168         break;
16169 
16170       case IO:
16171         if (value == null) {
16172           unsetIo();
16173         } else {
16174           setIo((IOError)value);
16175         }
16176         break;
16177 
16178       }
16179     }
16180 
16181     public void setFieldValue(int fieldID, Object value) {
16182       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
16183     }
16184 
16185     public Object getFieldValue(_Fields field) {
16186       switch (field) {
16187       case SUCCESS:
16188         return getSuccess();
16189 
16190       case IO:
16191         return getIo();
16192 
16193       }
16194       throw new IllegalStateException();
16195     }
16196 
16197     public Object getFieldValue(int fieldId) {
16198       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
16199     }
16200 
16201     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
16202     public boolean isSet(_Fields field) {
16203       switch (field) {
16204       case SUCCESS:
16205         return isSetSuccess();
16206       case IO:
16207         return isSetIo();
16208       }
16209       throw new IllegalStateException();
16210     }
16211 
16212     public boolean isSet(int fieldID) {
16213       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
16214     }
16215 
16216     @Override
16217     public boolean equals(Object that) {
16218       if (that == null)
16219         return false;
16220       if (that instanceof getRowWithColumnsTs_result)
16221         return this.equals((getRowWithColumnsTs_result)that);
16222       return false;
16223     }
16224 
16225     public boolean equals(getRowWithColumnsTs_result that) {
16226       if (that == null)
16227         return false;
16228 
16229       boolean this_present_success = true && this.isSetSuccess();
16230       boolean that_present_success = true && that.isSetSuccess();
16231       if (this_present_success || that_present_success) {
16232         if (!(this_present_success && that_present_success))
16233           return false;
16234         if (!this.success.equals(that.success))
16235           return false;
16236       }
16237 
16238       boolean this_present_io = true && this.isSetIo();
16239       boolean that_present_io = true && that.isSetIo();
16240       if (this_present_io || that_present_io) {
16241         if (!(this_present_io && that_present_io))
16242           return false;
16243         if (!this.io.equals(that.io))
16244           return false;
16245       }
16246 
16247       return true;
16248     }
16249 
16250     @Override
16251     public int hashCode() {
16252       HashCodeBuilder builder = new HashCodeBuilder();
16253 
16254       boolean present_success = true && (isSetSuccess());
16255       builder.append(present_success);
16256       if (present_success)
16257         builder.append(success);
16258 
16259       boolean present_io = true && (isSetIo());
16260       builder.append(present_io);
16261       if (present_io)
16262         builder.append(io);
16263 
16264       return builder.toHashCode();
16265     }
16266 
16267     public void read(TProtocol iprot) throws TException {
16268       TField field;
16269       iprot.readStructBegin();
16270       while (true)
16271       {
16272         field = iprot.readFieldBegin();
16273         if (field.type == TType.STOP) {
16274           break;
16275         }
16276         _Fields fieldId = _Fields.findByThriftId(field.id);
16277         if (fieldId == null) {
16278           TProtocolUtil.skip(iprot, field.type);
16279         } else {
16280           switch (fieldId) {
16281             case SUCCESS:
16282               if (field.type == TType.LIST) {
16283                 {
16284                   TList _list58 = iprot.readListBegin();
16285                   this.success = new ArrayList<TRowResult>(_list58.size);
16286                   for (int _i59 = 0; _i59 < _list58.size; ++_i59)
16287                   {
16288                     TRowResult _elem60;
16289                     _elem60 = new TRowResult();
16290                     _elem60.read(iprot);
16291                     this.success.add(_elem60);
16292                   }
16293                   iprot.readListEnd();
16294                 }
16295               } else {
16296                 TProtocolUtil.skip(iprot, field.type);
16297               }
16298               break;
16299             case IO:
16300               if (field.type == TType.STRUCT) {
16301                 this.io = new IOError();
16302                 this.io.read(iprot);
16303               } else {
16304                 TProtocolUtil.skip(iprot, field.type);
16305               }
16306               break;
16307           }
16308           iprot.readFieldEnd();
16309         }
16310       }
16311       iprot.readStructEnd();
16312 
16313       // check for required fields of primitive type, which can't be checked in the validate method
16314       validate();
16315     }
16316 
16317     public void write(TProtocol oprot) throws TException {
16318       oprot.writeStructBegin(STRUCT_DESC);
16319 
16320       if (this.isSetSuccess()) {
16321         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
16322         {
16323           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
16324           for (TRowResult _iter61 : this.success)
16325           {
16326             _iter61.write(oprot);
16327           }
16328           oprot.writeListEnd();
16329         }
16330         oprot.writeFieldEnd();
16331       } else if (this.isSetIo()) {
16332         oprot.writeFieldBegin(IO_FIELD_DESC);
16333         this.io.write(oprot);
16334         oprot.writeFieldEnd();
16335       }
16336       oprot.writeFieldStop();
16337       oprot.writeStructEnd();
16338     }
16339 
16340     @Override
16341     public String toString() {
16342       StringBuilder sb = new StringBuilder("getRowWithColumnsTs_result(");
16343       boolean first = true;
16344 
16345       sb.append("success:");
16346       if (this.success == null) {
16347         sb.append("null");
16348       } else {
16349         sb.append(this.success);
16350       }
16351       first = false;
16352       if (!first) sb.append(", ");
16353       sb.append("io:");
16354       if (this.io == null) {
16355         sb.append("null");
16356       } else {
16357         sb.append(this.io);
16358       }
16359       first = false;
16360       sb.append(")");
16361       return sb.toString();
16362     }
16363 
16364     public void validate() throws TException {
16365       // check for required fields
16366     }
16367 
16368   }
16369 
16370   public static class getRows_args implements TBase<getRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRows_args>   {
16371     private static final TStruct STRUCT_DESC = new TStruct("getRows_args");
16372 
16373     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
16374     private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
16375 
16376     /**
16377      * name of table
16378      */
16379     public byte[] tableName;
16380     /**
16381      * row keys
16382      */
16383     public List<byte[]> rows;
16384 
16385     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
16386     public enum _Fields implements TFieldIdEnum {
16387       /**
16388        * name of table
16389        */
16390       TABLE_NAME((short)1, "tableName"),
16391       /**
16392        * row keys
16393        */
16394       ROWS((short)2, "rows");
16395 
16396       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
16397       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16398 
16399       static {
16400         for (_Fields field : EnumSet.allOf(_Fields.class)) {
16401           byId.put((int)field._thriftId, field);
16402           byName.put(field.getFieldName(), field);
16403         }
16404       }
16405 
16406       /**
16407        * Find the _Fields constant that matches fieldId, or null if its not found.
16408        */
16409       public static _Fields findByThriftId(int fieldId) {
16410         return byId.get(fieldId);
16411       }
16412 
16413       /**
16414        * Find the _Fields constant that matches fieldId, throwing an exception
16415        * if it is not found.
16416        */
16417       public static _Fields findByThriftIdOrThrow(int fieldId) {
16418         _Fields fields = findByThriftId(fieldId);
16419         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16420         return fields;
16421       }
16422 
16423       /**
16424        * Find the _Fields constant that matches name, or null if its not found.
16425        */
16426       public static _Fields findByName(String name) {
16427         return byName.get(name);
16428       }
16429 
16430       private final short _thriftId;
16431       private final String _fieldName;
16432 
16433       _Fields(short thriftId, String fieldName) {
16434         _thriftId = thriftId;
16435         _fieldName = fieldName;
16436       }
16437 
16438       public short getThriftFieldId() {
16439         return _thriftId;
16440       }
16441 
16442       public String getFieldName() {
16443         return _fieldName;
16444       }
16445     }
16446 
16447     // isset id assignments
16448 
16449     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16450       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
16451           new FieldValueMetaData(TType.STRING)));
16452       put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
16453           new ListMetaData(TType.LIST,
16454               new FieldValueMetaData(TType.STRING))));
16455     }});
16456 
16457     static {
16458       FieldMetaData.addStructMetaDataMap(getRows_args.class, metaDataMap);
16459     }
16460 
16461     public getRows_args() {
16462     }
16463 
16464     public getRows_args(
16465       byte[] tableName,
16466       List<byte[]> rows)
16467     {
16468       this();
16469       this.tableName = tableName;
16470       this.rows = rows;
16471     }
16472 
16473     /**
16474      * Performs a deep copy on <i>other</i>.
16475      */
16476     public getRows_args(getRows_args other) {
16477       if (other.isSetTableName()) {
16478         this.tableName = other.tableName;
16479       }
16480       if (other.isSetRows()) {
16481         List<byte[]> __this__rows = new ArrayList<byte[]>();
16482         for (byte[] other_element : other.rows) {
16483           __this__rows.add(other_element);
16484         }
16485         this.rows = __this__rows;
16486       }
16487     }
16488 
16489     public getRows_args deepCopy() {
16490       return new getRows_args(this);
16491     }
16492 
16493     @Deprecated
16494     public getRows_args clone() {
16495       return new getRows_args(this);
16496     }
16497 
16498     /**
16499      * name of table
16500      */
16501     public byte[] getTableName() {
16502       return this.tableName;
16503     }
16504 
16505     /**
16506      * name of table
16507      */
16508     public getRows_args setTableName(byte[] tableName) {
16509       this.tableName = tableName;
16510       return this;
16511     }
16512 
16513     public void unsetTableName() {
16514       this.tableName = null;
16515     }
16516 
16517     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
16518     public boolean isSetTableName() {
16519       return this.tableName != null;
16520     }
16521 
16522     public void setTableNameIsSet(boolean value) {
16523       if (!value) {
16524         this.tableName = null;
16525       }
16526     }
16527 
16528     public int getRowsSize() {
16529       return (this.rows == null) ? 0 : this.rows.size();
16530     }
16531 
16532     public java.util.Iterator<byte[]> getRowsIterator() {
16533       return (this.rows == null) ? null : this.rows.iterator();
16534     }
16535 
16536     public void addToRows(byte[] elem) {
16537       if (this.rows == null) {
16538         this.rows = new ArrayList<byte[]>();
16539       }
16540       this.rows.add(elem);
16541     }
16542 
16543     /**
16544      * row keys
16545      */
16546     public List<byte[]> getRows() {
16547       return this.rows;
16548     }
16549 
16550     /**
16551      * row keys
16552      */
16553     public getRows_args setRows(List<byte[]> rows) {
16554       this.rows = rows;
16555       return this;
16556     }
16557 
16558     public void unsetRows() {
16559       this.rows = null;
16560     }
16561 
16562     /** Returns true if field rows is set (has been asigned a value) and false otherwise */
16563     public boolean isSetRows() {
16564       return this.rows != null;
16565     }
16566 
16567     public void setRowsIsSet(boolean value) {
16568       if (!value) {
16569         this.rows = null;
16570       }
16571     }
16572 
16573     public void setFieldValue(_Fields field, Object value) {
16574       switch (field) {
16575       case TABLE_NAME:
16576         if (value == null) {
16577           unsetTableName();
16578         } else {
16579           setTableName((byte[])value);
16580         }
16581         break;
16582 
16583       case ROWS:
16584         if (value == null) {
16585           unsetRows();
16586         } else {
16587           setRows((List<byte[]>)value);
16588         }
16589         break;
16590 
16591       }
16592     }
16593 
16594     public void setFieldValue(int fieldID, Object value) {
16595       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
16596     }
16597 
16598     public Object getFieldValue(_Fields field) {
16599       switch (field) {
16600       case TABLE_NAME:
16601         return getTableName();
16602 
16603       case ROWS:
16604         return getRows();
16605 
16606       }
16607       throw new IllegalStateException();
16608     }
16609 
16610     public Object getFieldValue(int fieldId) {
16611       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
16612     }
16613 
16614     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
16615     public boolean isSet(_Fields field) {
16616       switch (field) {
16617       case TABLE_NAME:
16618         return isSetTableName();
16619       case ROWS:
16620         return isSetRows();
16621       }
16622       throw new IllegalStateException();
16623     }
16624 
16625     public boolean isSet(int fieldID) {
16626       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
16627     }
16628 
16629     @Override
16630     public boolean equals(Object that) {
16631       if (that == null)
16632         return false;
16633       if (that instanceof getRows_args)
16634         return this.equals((getRows_args)that);
16635       return false;
16636     }
16637 
16638     public boolean equals(getRows_args that) {
16639       if (that == null)
16640         return false;
16641 
16642       boolean this_present_tableName = true && this.isSetTableName();
16643       boolean that_present_tableName = true && that.isSetTableName();
16644       if (this_present_tableName || that_present_tableName) {
16645         if (!(this_present_tableName && that_present_tableName))
16646           return false;
16647         if (!java.util.Arrays.equals(this.tableName, that.tableName))
16648           return false;
16649       }
16650 
16651       boolean this_present_rows = true && this.isSetRows();
16652       boolean that_present_rows = true && that.isSetRows();
16653       if (this_present_rows || that_present_rows) {
16654         if (!(this_present_rows && that_present_rows))
16655           return false;
16656         if (!this.rows.equals(that.rows))
16657           return false;
16658       }
16659 
16660       return true;
16661     }
16662 
16663     @Override
16664     public int hashCode() {
16665       HashCodeBuilder builder = new HashCodeBuilder();
16666 
16667       boolean present_tableName = true && (isSetTableName());
16668       builder.append(present_tableName);
16669       if (present_tableName)
16670         builder.append(tableName);
16671 
16672       boolean present_rows = true && (isSetRows());
16673       builder.append(present_rows);
16674       if (present_rows)
16675         builder.append(rows);
16676 
16677       return builder.toHashCode();
16678     }
16679 
16680     public int compareTo(getRows_args other) {
16681       if (!getClass().equals(other.getClass())) {
16682         return getClass().getName().compareTo(other.getClass().getName());
16683       }
16684 
16685       int lastComparison = 0;
16686       getRows_args typedOther = (getRows_args)other;
16687 
16688       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
16689       if (lastComparison != 0) {
16690         return lastComparison;
16691       }
16692       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
16693       if (lastComparison != 0) {
16694         return lastComparison;
16695       }
16696       lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
16697       if (lastComparison != 0) {
16698         return lastComparison;
16699       }
16700       lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
16701       if (lastComparison != 0) {
16702         return lastComparison;
16703       }
16704       return 0;
16705     }
16706 
16707     public void read(TProtocol iprot) throws TException {
16708       TField field;
16709       iprot.readStructBegin();
16710       while (true)
16711       {
16712         field = iprot.readFieldBegin();
16713         if (field.type == TType.STOP) {
16714           break;
16715         }
16716         _Fields fieldId = _Fields.findByThriftId(field.id);
16717         if (fieldId == null) {
16718           TProtocolUtil.skip(iprot, field.type);
16719         } else {
16720           switch (fieldId) {
16721             case TABLE_NAME:
16722               if (field.type == TType.STRING) {
16723                 this.tableName = iprot.readBinary();
16724               } else {
16725                 TProtocolUtil.skip(iprot, field.type);
16726               }
16727               break;
16728             case ROWS:
16729               if (field.type == TType.LIST) {
16730                 {
16731                   TList _list62 = iprot.readListBegin();
16732                   this.rows = new ArrayList<byte[]>(_list62.size);
16733                   for (int _i63 = 0; _i63 < _list62.size; ++_i63)
16734                   {
16735                     byte[] _elem64;
16736                     _elem64 = iprot.readBinary();
16737                     this.rows.add(_elem64);
16738                   }
16739                   iprot.readListEnd();
16740                 }
16741               } else {
16742                 TProtocolUtil.skip(iprot, field.type);
16743               }
16744               break;
16745           }
16746           iprot.readFieldEnd();
16747         }
16748       }
16749       iprot.readStructEnd();
16750 
16751       // check for required fields of primitive type, which can't be checked in the validate method
16752       validate();
16753     }
16754 
16755     public void write(TProtocol oprot) throws TException {
16756       validate();
16757 
16758       oprot.writeStructBegin(STRUCT_DESC);
16759       if (this.tableName != null) {
16760         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
16761         oprot.writeBinary(this.tableName);
16762         oprot.writeFieldEnd();
16763       }
16764       if (this.rows != null) {
16765         oprot.writeFieldBegin(ROWS_FIELD_DESC);
16766         {
16767           oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
16768           for (byte[] _iter65 : this.rows)
16769           {
16770             oprot.writeBinary(_iter65);
16771           }
16772           oprot.writeListEnd();
16773         }
16774         oprot.writeFieldEnd();
16775       }
16776       oprot.writeFieldStop();
16777       oprot.writeStructEnd();
16778     }
16779 
16780     @Override
16781     public String toString() {
16782       StringBuilder sb = new StringBuilder("getRows_args(");
16783       boolean first = true;
16784 
16785       sb.append("tableName:");
16786       if (this.tableName == null) {
16787         sb.append("null");
16788       } else {
16789         sb.append(this.tableName);
16790       }
16791       first = false;
16792       if (!first) sb.append(", ");
16793       sb.append("rows:");
16794       if (this.rows == null) {
16795         sb.append("null");
16796       } else {
16797         sb.append(this.rows);
16798       }
16799       first = false;
16800       sb.append(")");
16801       return sb.toString();
16802     }
16803 
16804     public void validate() throws TException {
16805       // check for required fields
16806     }
16807 
16808   }
16809 
16810   public static class getRows_result implements TBase<getRows_result._Fields>, java.io.Serializable, Cloneable   {
16811     private static final TStruct STRUCT_DESC = new TStruct("getRows_result");
16812 
16813     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
16814     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
16815 
16816     public List<TRowResult> success;
16817     public IOError io;
16818 
16819     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
16820     public enum _Fields implements TFieldIdEnum {
16821       SUCCESS((short)0, "success"),
16822       IO((short)1, "io");
16823 
16824       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
16825       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16826 
16827       static {
16828         for (_Fields field : EnumSet.allOf(_Fields.class)) {
16829           byId.put((int)field._thriftId, field);
16830           byName.put(field.getFieldName(), field);
16831         }
16832       }
16833 
16834       /**
16835        * Find the _Fields constant that matches fieldId, or null if its not found.
16836        */
16837       public static _Fields findByThriftId(int fieldId) {
16838         return byId.get(fieldId);
16839       }
16840 
16841       /**
16842        * Find the _Fields constant that matches fieldId, throwing an exception
16843        * if it is not found.
16844        */
16845       public static _Fields findByThriftIdOrThrow(int fieldId) {
16846         _Fields fields = findByThriftId(fieldId);
16847         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16848         return fields;
16849       }
16850 
16851       /**
16852        * Find the _Fields constant that matches name, or null if its not found.
16853        */
16854       public static _Fields findByName(String name) {
16855         return byName.get(name);
16856       }
16857 
16858       private final short _thriftId;
16859       private final String _fieldName;
16860 
16861       _Fields(short thriftId, String fieldName) {
16862         _thriftId = thriftId;
16863         _fieldName = fieldName;
16864       }
16865 
16866       public short getThriftFieldId() {
16867         return _thriftId;
16868       }
16869 
16870       public String getFieldName() {
16871         return _fieldName;
16872       }
16873     }
16874 
16875     // isset id assignments
16876 
16877     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16878       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
16879           new ListMetaData(TType.LIST,
16880               new StructMetaData(TType.STRUCT, TRowResult.class))));
16881       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
16882           new FieldValueMetaData(TType.STRUCT)));
16883     }});
16884 
16885     static {
16886       FieldMetaData.addStructMetaDataMap(getRows_result.class, metaDataMap);
16887     }
16888 
16889     public getRows_result() {
16890     }
16891 
16892     public getRows_result(
16893       List<TRowResult> success,
16894       IOError io)
16895     {
16896       this();
16897       this.success = success;
16898       this.io = io;
16899     }
16900 
16901     /**
16902      * Performs a deep copy on <i>other</i>.
16903      */
16904     public getRows_result(getRows_result other) {
16905       if (other.isSetSuccess()) {
16906         List<TRowResult> __this__success = new ArrayList<TRowResult>();
16907         for (TRowResult other_element : other.success) {
16908           __this__success.add(new TRowResult(other_element));
16909         }
16910         this.success = __this__success;
16911       }
16912       if (other.isSetIo()) {
16913         this.io = new IOError(other.io);
16914       }
16915     }
16916 
16917     public getRows_result deepCopy() {
16918       return new getRows_result(this);
16919     }
16920 
16921     @Deprecated
16922     public getRows_result clone() {
16923       return new getRows_result(this);
16924     }
16925 
16926     public int getSuccessSize() {
16927       return (this.success == null) ? 0 : this.success.size();
16928     }
16929 
16930     public java.util.Iterator<TRowResult> getSuccessIterator() {
16931       return (this.success == null) ? null : this.success.iterator();
16932     }
16933 
16934     public void addToSuccess(TRowResult elem) {
16935       if (this.success == null) {
16936         this.success = new ArrayList<TRowResult>();
16937       }
16938       this.success.add(elem);
16939     }
16940 
16941     public List<TRowResult> getSuccess() {
16942       return this.success;
16943     }
16944 
16945     public getRows_result setSuccess(List<TRowResult> success) {
16946       this.success = success;
16947       return this;
16948     }
16949 
16950     public void unsetSuccess() {
16951       this.success = null;
16952     }
16953 
16954     /** Returns true if field success is set (has been asigned a value) and false otherwise */
16955     public boolean isSetSuccess() {
16956       return this.success != null;
16957     }
16958 
16959     public void setSuccessIsSet(boolean value) {
16960       if (!value) {
16961         this.success = null;
16962       }
16963     }
16964 
16965     public IOError getIo() {
16966       return this.io;
16967     }
16968 
16969     public getRows_result setIo(IOError io) {
16970       this.io = io;
16971       return this;
16972     }
16973 
16974     public void unsetIo() {
16975       this.io = null;
16976     }
16977 
16978     /** Returns true if field io is set (has been asigned a value) and false otherwise */
16979     public boolean isSetIo() {
16980       return this.io != null;
16981     }
16982 
16983     public void setIoIsSet(boolean value) {
16984       if (!value) {
16985         this.io = null;
16986       }
16987     }
16988 
16989     public void setFieldValue(_Fields field, Object value) {
16990       switch (field) {
16991       case SUCCESS:
16992         if (value == null) {
16993           unsetSuccess();
16994         } else {
16995           setSuccess((List<TRowResult>)value);
16996         }
16997         break;
16998 
16999       case IO:
17000         if (value == null) {
17001           unsetIo();
17002         } else {
17003           setIo((IOError)value);
17004         }
17005         break;
17006 
17007       }
17008     }
17009 
17010     public void setFieldValue(int fieldID, Object value) {
17011       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17012     }
17013 
17014     public Object getFieldValue(_Fields field) {
17015       switch (field) {
17016       case SUCCESS:
17017         return getSuccess();
17018 
17019       case IO:
17020         return getIo();
17021 
17022       }
17023       throw new IllegalStateException();
17024     }
17025 
17026     public Object getFieldValue(int fieldId) {
17027       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17028     }
17029 
17030     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
17031     public boolean isSet(_Fields field) {
17032       switch (field) {
17033       case SUCCESS:
17034         return isSetSuccess();
17035       case IO:
17036         return isSetIo();
17037       }
17038       throw new IllegalStateException();
17039     }
17040 
17041     public boolean isSet(int fieldID) {
17042       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
17043     }
17044 
17045     @Override
17046     public boolean equals(Object that) {
17047       if (that == null)
17048         return false;
17049       if (that instanceof getRows_result)
17050         return this.equals((getRows_result)that);
17051       return false;
17052     }
17053 
17054     public boolean equals(getRows_result that) {
17055       if (that == null)
17056         return false;
17057 
17058       boolean this_present_success = true && this.isSetSuccess();
17059       boolean that_present_success = true && that.isSetSuccess();
17060       if (this_present_success || that_present_success) {
17061         if (!(this_present_success && that_present_success))
17062           return false;
17063         if (!this.success.equals(that.success))
17064           return false;
17065       }
17066 
17067       boolean this_present_io = true && this.isSetIo();
17068       boolean that_present_io = true && that.isSetIo();
17069       if (this_present_io || that_present_io) {
17070         if (!(this_present_io && that_present_io))
17071           return false;
17072         if (!this.io.equals(that.io))
17073           return false;
17074       }
17075 
17076       return true;
17077     }
17078 
17079     @Override
17080     public int hashCode() {
17081       HashCodeBuilder builder = new HashCodeBuilder();
17082 
17083       boolean present_success = true && (isSetSuccess());
17084       builder.append(present_success);
17085       if (present_success)
17086         builder.append(success);
17087 
17088       boolean present_io = true && (isSetIo());
17089       builder.append(present_io);
17090       if (present_io)
17091         builder.append(io);
17092 
17093       return builder.toHashCode();
17094     }
17095 
17096     public void read(TProtocol iprot) throws TException {
17097       TField field;
17098       iprot.readStructBegin();
17099       while (true)
17100       {
17101         field = iprot.readFieldBegin();
17102         if (field.type == TType.STOP) {
17103           break;
17104         }
17105         _Fields fieldId = _Fields.findByThriftId(field.id);
17106         if (fieldId == null) {
17107           TProtocolUtil.skip(iprot, field.type);
17108         } else {
17109           switch (fieldId) {
17110             case SUCCESS:
17111               if (field.type == TType.LIST) {
17112                 {
17113                   TList _list66 = iprot.readListBegin();
17114                   this.success = new ArrayList<TRowResult>(_list66.size);
17115                   for (int _i67 = 0; _i67 < _list66.size; ++_i67)
17116                   {
17117                     TRowResult _elem68;
17118                     _elem68 = new TRowResult();
17119                     _elem68.read(iprot);
17120                     this.success.add(_elem68);
17121                   }
17122                   iprot.readListEnd();
17123                 }
17124               } else {
17125                 TProtocolUtil.skip(iprot, field.type);
17126               }
17127               break;
17128             case IO:
17129               if (field.type == TType.STRUCT) {
17130                 this.io = new IOError();
17131                 this.io.read(iprot);
17132               } else {
17133                 TProtocolUtil.skip(iprot, field.type);
17134               }
17135               break;
17136           }
17137           iprot.readFieldEnd();
17138         }
17139       }
17140       iprot.readStructEnd();
17141 
17142       // check for required fields of primitive type, which can't be checked in the validate method
17143       validate();
17144     }
17145 
17146     public void write(TProtocol oprot) throws TException {
17147       oprot.writeStructBegin(STRUCT_DESC);
17148 
17149       if (this.isSetSuccess()) {
17150         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
17151         {
17152           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
17153           for (TRowResult _iter69 : this.success)
17154           {
17155             _iter69.write(oprot);
17156           }
17157           oprot.writeListEnd();
17158         }
17159         oprot.writeFieldEnd();
17160       } else if (this.isSetIo()) {
17161         oprot.writeFieldBegin(IO_FIELD_DESC);
17162         this.io.write(oprot);
17163         oprot.writeFieldEnd();
17164       }
17165       oprot.writeFieldStop();
17166       oprot.writeStructEnd();
17167     }
17168 
17169     @Override
17170     public String toString() {
17171       StringBuilder sb = new StringBuilder("getRows_result(");
17172       boolean first = true;
17173 
17174       sb.append("success:");
17175       if (this.success == null) {
17176         sb.append("null");
17177       } else {
17178         sb.append(this.success);
17179       }
17180       first = false;
17181       if (!first) sb.append(", ");
17182       sb.append("io:");
17183       if (this.io == null) {
17184         sb.append("null");
17185       } else {
17186         sb.append(this.io);
17187       }
17188       first = false;
17189       sb.append(")");
17190       return sb.toString();
17191     }
17192 
17193     public void validate() throws TException {
17194       // check for required fields
17195     }
17196 
17197   }
17198 
17199   public static class getRowsWithColumns_args implements TBase<getRowsWithColumns_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsWithColumns_args>   {
17200     private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumns_args");
17201 
17202     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
17203     private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
17204     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
17205 
17206     /**
17207      * name of table
17208      */
17209     public byte[] tableName;
17210     /**
17211      * row keys
17212      */
17213     public List<byte[]> rows;
17214     /**
17215      * List of columns to return, null for all columns
17216      */
17217     public List<byte[]> columns;
17218 
17219     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
17220     public enum _Fields implements TFieldIdEnum {
17221       /**
17222        * name of table
17223        */
17224       TABLE_NAME((short)1, "tableName"),
17225       /**
17226        * row keys
17227        */
17228       ROWS((short)2, "rows"),
17229       /**
17230        * List of columns to return, null for all columns
17231        */
17232       COLUMNS((short)3, "columns");
17233 
17234       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
17235       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
17236 
17237       static {
17238         for (_Fields field : EnumSet.allOf(_Fields.class)) {
17239           byId.put((int)field._thriftId, field);
17240           byName.put(field.getFieldName(), field);
17241         }
17242       }
17243 
17244       /**
17245        * Find the _Fields constant that matches fieldId, or null if its not found.
17246        */
17247       public static _Fields findByThriftId(int fieldId) {
17248         return byId.get(fieldId);
17249       }
17250 
17251       /**
17252        * Find the _Fields constant that matches fieldId, throwing an exception
17253        * if it is not found.
17254        */
17255       public static _Fields findByThriftIdOrThrow(int fieldId) {
17256         _Fields fields = findByThriftId(fieldId);
17257         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
17258         return fields;
17259       }
17260 
17261       /**
17262        * Find the _Fields constant that matches name, or null if its not found.
17263        */
17264       public static _Fields findByName(String name) {
17265         return byName.get(name);
17266       }
17267 
17268       private final short _thriftId;
17269       private final String _fieldName;
17270 
17271       _Fields(short thriftId, String fieldName) {
17272         _thriftId = thriftId;
17273         _fieldName = fieldName;
17274       }
17275 
17276       public short getThriftFieldId() {
17277         return _thriftId;
17278       }
17279 
17280       public String getFieldName() {
17281         return _fieldName;
17282       }
17283     }
17284 
17285     // isset id assignments
17286 
17287     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
17288       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
17289           new FieldValueMetaData(TType.STRING)));
17290       put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
17291           new ListMetaData(TType.LIST,
17292               new FieldValueMetaData(TType.STRING))));
17293       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
17294           new ListMetaData(TType.LIST,
17295               new FieldValueMetaData(TType.STRING))));
17296     }});
17297 
17298     static {
17299       FieldMetaData.addStructMetaDataMap(getRowsWithColumns_args.class, metaDataMap);
17300     }
17301 
17302     public getRowsWithColumns_args() {
17303     }
17304 
17305     public getRowsWithColumns_args(
17306       byte[] tableName,
17307       List<byte[]> rows,
17308       List<byte[]> columns)
17309     {
17310       this();
17311       this.tableName = tableName;
17312       this.rows = rows;
17313       this.columns = columns;
17314     }
17315 
17316     /**
17317      * Performs a deep copy on <i>other</i>.
17318      */
17319     public getRowsWithColumns_args(getRowsWithColumns_args other) {
17320       if (other.isSetTableName()) {
17321         this.tableName = other.tableName;
17322       }
17323       if (other.isSetRows()) {
17324         List<byte[]> __this__rows = new ArrayList<byte[]>();
17325         for (byte[] other_element : other.rows) {
17326           __this__rows.add(other_element);
17327         }
17328         this.rows = __this__rows;
17329       }
17330       if (other.isSetColumns()) {
17331         List<byte[]> __this__columns = new ArrayList<byte[]>();
17332         for (byte[] other_element : other.columns) {
17333           __this__columns.add(other_element);
17334         }
17335         this.columns = __this__columns;
17336       }
17337     }
17338 
17339     public getRowsWithColumns_args deepCopy() {
17340       return new getRowsWithColumns_args(this);
17341     }
17342 
17343     @Deprecated
17344     public getRowsWithColumns_args clone() {
17345       return new getRowsWithColumns_args(this);
17346     }
17347 
17348     /**
17349      * name of table
17350      */
17351     public byte[] getTableName() {
17352       return this.tableName;
17353     }
17354 
17355     /**
17356      * name of table
17357      */
17358     public getRowsWithColumns_args setTableName(byte[] tableName) {
17359       this.tableName = tableName;
17360       return this;
17361     }
17362 
17363     public void unsetTableName() {
17364       this.tableName = null;
17365     }
17366 
17367     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
17368     public boolean isSetTableName() {
17369       return this.tableName != null;
17370     }
17371 
17372     public void setTableNameIsSet(boolean value) {
17373       if (!value) {
17374         this.tableName = null;
17375       }
17376     }
17377 
17378     public int getRowsSize() {
17379       return (this.rows == null) ? 0 : this.rows.size();
17380     }
17381 
17382     public java.util.Iterator<byte[]> getRowsIterator() {
17383       return (this.rows == null) ? null : this.rows.iterator();
17384     }
17385 
17386     public void addToRows(byte[] elem) {
17387       if (this.rows == null) {
17388         this.rows = new ArrayList<byte[]>();
17389       }
17390       this.rows.add(elem);
17391     }
17392 
17393     /**
17394      * row keys
17395      */
17396     public List<byte[]> getRows() {
17397       return this.rows;
17398     }
17399 
17400     /**
17401      * row keys
17402      */
17403     public getRowsWithColumns_args setRows(List<byte[]> rows) {
17404       this.rows = rows;
17405       return this;
17406     }
17407 
17408     public void unsetRows() {
17409       this.rows = null;
17410     }
17411 
17412     /** Returns true if field rows is set (has been asigned a value) and false otherwise */
17413     public boolean isSetRows() {
17414       return this.rows != null;
17415     }
17416 
17417     public void setRowsIsSet(boolean value) {
17418       if (!value) {
17419         this.rows = null;
17420       }
17421     }
17422 
17423     public int getColumnsSize() {
17424       return (this.columns == null) ? 0 : this.columns.size();
17425     }
17426 
17427     public java.util.Iterator<byte[]> getColumnsIterator() {
17428       return (this.columns == null) ? null : this.columns.iterator();
17429     }
17430 
17431     public void addToColumns(byte[] elem) {
17432       if (this.columns == null) {
17433         this.columns = new ArrayList<byte[]>();
17434       }
17435       this.columns.add(elem);
17436     }
17437 
17438     /**
17439      * List of columns to return, null for all columns
17440      */
17441     public List<byte[]> getColumns() {
17442       return this.columns;
17443     }
17444 
17445     /**
17446      * List of columns to return, null for all columns
17447      */
17448     public getRowsWithColumns_args setColumns(List<byte[]> columns) {
17449       this.columns = columns;
17450       return this;
17451     }
17452 
17453     public void unsetColumns() {
17454       this.columns = null;
17455     }
17456 
17457     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
17458     public boolean isSetColumns() {
17459       return this.columns != null;
17460     }
17461 
17462     public void setColumnsIsSet(boolean value) {
17463       if (!value) {
17464         this.columns = null;
17465       }
17466     }
17467 
17468     public void setFieldValue(_Fields field, Object value) {
17469       switch (field) {
17470       case TABLE_NAME:
17471         if (value == null) {
17472           unsetTableName();
17473         } else {
17474           setTableName((byte[])value);
17475         }
17476         break;
17477 
17478       case ROWS:
17479         if (value == null) {
17480           unsetRows();
17481         } else {
17482           setRows((List<byte[]>)value);
17483         }
17484         break;
17485 
17486       case COLUMNS:
17487         if (value == null) {
17488           unsetColumns();
17489         } else {
17490           setColumns((List<byte[]>)value);
17491         }
17492         break;
17493 
17494       }
17495     }
17496 
17497     public void setFieldValue(int fieldID, Object value) {
17498       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17499     }
17500 
17501     public Object getFieldValue(_Fields field) {
17502       switch (field) {
17503       case TABLE_NAME:
17504         return getTableName();
17505 
17506       case ROWS:
17507         return getRows();
17508 
17509       case COLUMNS:
17510         return getColumns();
17511 
17512       }
17513       throw new IllegalStateException();
17514     }
17515 
17516     public Object getFieldValue(int fieldId) {
17517       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17518     }
17519 
17520     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
17521     public boolean isSet(_Fields field) {
17522       switch (field) {
17523       case TABLE_NAME:
17524         return isSetTableName();
17525       case ROWS:
17526         return isSetRows();
17527       case COLUMNS:
17528         return isSetColumns();
17529       }
17530       throw new IllegalStateException();
17531     }
17532 
17533     public boolean isSet(int fieldID) {
17534       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
17535     }
17536 
17537     @Override
17538     public boolean equals(Object that) {
17539       if (that == null)
17540         return false;
17541       if (that instanceof getRowsWithColumns_args)
17542         return this.equals((getRowsWithColumns_args)that);
17543       return false;
17544     }
17545 
17546     public boolean equals(getRowsWithColumns_args that) {
17547       if (that == null)
17548         return false;
17549 
17550       boolean this_present_tableName = true && this.isSetTableName();
17551       boolean that_present_tableName = true && that.isSetTableName();
17552       if (this_present_tableName || that_present_tableName) {
17553         if (!(this_present_tableName && that_present_tableName))
17554           return false;
17555         if (!java.util.Arrays.equals(this.tableName, that.tableName))
17556           return false;
17557       }
17558 
17559       boolean this_present_rows = true && this.isSetRows();
17560       boolean that_present_rows = true && that.isSetRows();
17561       if (this_present_rows || that_present_rows) {
17562         if (!(this_present_rows && that_present_rows))
17563           return false;
17564         if (!this.rows.equals(that.rows))
17565           return false;
17566       }
17567 
17568       boolean this_present_columns = true && this.isSetColumns();
17569       boolean that_present_columns = true && that.isSetColumns();
17570       if (this_present_columns || that_present_columns) {
17571         if (!(this_present_columns && that_present_columns))
17572           return false;
17573         if (!this.columns.equals(that.columns))
17574           return false;
17575       }
17576 
17577       return true;
17578     }
17579 
17580     @Override
17581     public int hashCode() {
17582       HashCodeBuilder builder = new HashCodeBuilder();
17583 
17584       boolean present_tableName = true && (isSetTableName());
17585       builder.append(present_tableName);
17586       if (present_tableName)
17587         builder.append(tableName);
17588 
17589       boolean present_rows = true && (isSetRows());
17590       builder.append(present_rows);
17591       if (present_rows)
17592         builder.append(rows);
17593 
17594       boolean present_columns = true && (isSetColumns());
17595       builder.append(present_columns);
17596       if (present_columns)
17597         builder.append(columns);
17598 
17599       return builder.toHashCode();
17600     }
17601 
17602     public int compareTo(getRowsWithColumns_args other) {
17603       if (!getClass().equals(other.getClass())) {
17604         return getClass().getName().compareTo(other.getClass().getName());
17605       }
17606 
17607       int lastComparison = 0;
17608       getRowsWithColumns_args typedOther = (getRowsWithColumns_args)other;
17609 
17610       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
17611       if (lastComparison != 0) {
17612         return lastComparison;
17613       }
17614       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
17615       if (lastComparison != 0) {
17616         return lastComparison;
17617       }
17618       lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
17619       if (lastComparison != 0) {
17620         return lastComparison;
17621       }
17622       lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
17623       if (lastComparison != 0) {
17624         return lastComparison;
17625       }
17626       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
17627       if (lastComparison != 0) {
17628         return lastComparison;
17629       }
17630       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
17631       if (lastComparison != 0) {
17632         return lastComparison;
17633       }
17634       return 0;
17635     }
17636 
17637     public void read(TProtocol iprot) throws TException {
17638       TField field;
17639       iprot.readStructBegin();
17640       while (true)
17641       {
17642         field = iprot.readFieldBegin();
17643         if (field.type == TType.STOP) {
17644           break;
17645         }
17646         _Fields fieldId = _Fields.findByThriftId(field.id);
17647         if (fieldId == null) {
17648           TProtocolUtil.skip(iprot, field.type);
17649         } else {
17650           switch (fieldId) {
17651             case TABLE_NAME:
17652               if (field.type == TType.STRING) {
17653                 this.tableName = iprot.readBinary();
17654               } else {
17655                 TProtocolUtil.skip(iprot, field.type);
17656               }
17657               break;
17658             case ROWS:
17659               if (field.type == TType.LIST) {
17660                 {
17661                   TList _list70 = iprot.readListBegin();
17662                   this.rows = new ArrayList<byte[]>(_list70.size);
17663                   for (int _i71 = 0; _i71 < _list70.size; ++_i71)
17664                   {
17665                     byte[] _elem72;
17666                     _elem72 = iprot.readBinary();
17667                     this.rows.add(_elem72);
17668                   }
17669                   iprot.readListEnd();
17670                 }
17671               } else {
17672                 TProtocolUtil.skip(iprot, field.type);
17673               }
17674               break;
17675             case COLUMNS:
17676               if (field.type == TType.LIST) {
17677                 {
17678                   TList _list73 = iprot.readListBegin();
17679                   this.columns = new ArrayList<byte[]>(_list73.size);
17680                   for (int _i74 = 0; _i74 < _list73.size; ++_i74)
17681                   {
17682                     byte[] _elem75;
17683                     _elem75 = iprot.readBinary();
17684                     this.columns.add(_elem75);
17685                   }
17686                   iprot.readListEnd();
17687                 }
17688               } else {
17689                 TProtocolUtil.skip(iprot, field.type);
17690               }
17691               break;
17692           }
17693           iprot.readFieldEnd();
17694         }
17695       }
17696       iprot.readStructEnd();
17697 
17698       // check for required fields of primitive type, which can't be checked in the validate method
17699       validate();
17700     }
17701 
17702     public void write(TProtocol oprot) throws TException {
17703       validate();
17704 
17705       oprot.writeStructBegin(STRUCT_DESC);
17706       if (this.tableName != null) {
17707         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
17708         oprot.writeBinary(this.tableName);
17709         oprot.writeFieldEnd();
17710       }
17711       if (this.rows != null) {
17712         oprot.writeFieldBegin(ROWS_FIELD_DESC);
17713         {
17714           oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
17715           for (byte[] _iter76 : this.rows)
17716           {
17717             oprot.writeBinary(_iter76);
17718           }
17719           oprot.writeListEnd();
17720         }
17721         oprot.writeFieldEnd();
17722       }
17723       if (this.columns != null) {
17724         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
17725         {
17726           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
17727           for (byte[] _iter77 : this.columns)
17728           {
17729             oprot.writeBinary(_iter77);
17730           }
17731           oprot.writeListEnd();
17732         }
17733         oprot.writeFieldEnd();
17734       }
17735       oprot.writeFieldStop();
17736       oprot.writeStructEnd();
17737     }
17738 
17739     @Override
17740     public String toString() {
17741       StringBuilder sb = new StringBuilder("getRowsWithColumns_args(");
17742       boolean first = true;
17743 
17744       sb.append("tableName:");
17745       if (this.tableName == null) {
17746         sb.append("null");
17747       } else {
17748         sb.append(this.tableName);
17749       }
17750       first = false;
17751       if (!first) sb.append(", ");
17752       sb.append("rows:");
17753       if (this.rows == null) {
17754         sb.append("null");
17755       } else {
17756         sb.append(this.rows);
17757       }
17758       first = false;
17759       if (!first) sb.append(", ");
17760       sb.append("columns:");
17761       if (this.columns == null) {
17762         sb.append("null");
17763       } else {
17764         sb.append(this.columns);
17765       }
17766       first = false;
17767       sb.append(")");
17768       return sb.toString();
17769     }
17770 
17771     public void validate() throws TException {
17772       // check for required fields
17773     }
17774 
17775   }
17776 
17777   public static class getRowsWithColumns_result implements TBase<getRowsWithColumns_result._Fields>, java.io.Serializable, Cloneable   {
17778     private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumns_result");
17779 
17780     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
17781     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
17782 
17783     public List<TRowResult> success;
17784     public IOError io;
17785 
17786     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
17787     public enum _Fields implements TFieldIdEnum {
17788       SUCCESS((short)0, "success"),
17789       IO((short)1, "io");
17790 
17791       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
17792       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
17793 
17794       static {
17795         for (_Fields field : EnumSet.allOf(_Fields.class)) {
17796           byId.put((int)field._thriftId, field);
17797           byName.put(field.getFieldName(), field);
17798         }
17799       }
17800 
17801       /**
17802        * Find the _Fields constant that matches fieldId, or null if its not found.
17803        */
17804       public static _Fields findByThriftId(int fieldId) {
17805         return byId.get(fieldId);
17806       }
17807 
17808       /**
17809        * Find the _Fields constant that matches fieldId, throwing an exception
17810        * if it is not found.
17811        */
17812       public static _Fields findByThriftIdOrThrow(int fieldId) {
17813         _Fields fields = findByThriftId(fieldId);
17814         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
17815         return fields;
17816       }
17817 
17818       /**
17819        * Find the _Fields constant that matches name, or null if its not found.
17820        */
17821       public static _Fields findByName(String name) {
17822         return byName.get(name);
17823       }
17824 
17825       private final short _thriftId;
17826       private final String _fieldName;
17827 
17828       _Fields(short thriftId, String fieldName) {
17829         _thriftId = thriftId;
17830         _fieldName = fieldName;
17831       }
17832 
17833       public short getThriftFieldId() {
17834         return _thriftId;
17835       }
17836 
17837       public String getFieldName() {
17838         return _fieldName;
17839       }
17840     }
17841 
17842     // isset id assignments
17843 
17844     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
17845       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
17846           new ListMetaData(TType.LIST,
17847               new StructMetaData(TType.STRUCT, TRowResult.class))));
17848       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
17849           new FieldValueMetaData(TType.STRUCT)));
17850     }});
17851 
17852     static {
17853       FieldMetaData.addStructMetaDataMap(getRowsWithColumns_result.class, metaDataMap);
17854     }
17855 
17856     public getRowsWithColumns_result() {
17857     }
17858 
17859     public getRowsWithColumns_result(
17860       List<TRowResult> success,
17861       IOError io)
17862     {
17863       this();
17864       this.success = success;
17865       this.io = io;
17866     }
17867 
17868     /**
17869      * Performs a deep copy on <i>other</i>.
17870      */
17871     public getRowsWithColumns_result(getRowsWithColumns_result other) {
17872       if (other.isSetSuccess()) {
17873         List<TRowResult> __this__success = new ArrayList<TRowResult>();
17874         for (TRowResult other_element : other.success) {
17875           __this__success.add(new TRowResult(other_element));
17876         }
17877         this.success = __this__success;
17878       }
17879       if (other.isSetIo()) {
17880         this.io = new IOError(other.io);
17881       }
17882     }
17883 
17884     public getRowsWithColumns_result deepCopy() {
17885       return new getRowsWithColumns_result(this);
17886     }
17887 
17888     @Deprecated
17889     public getRowsWithColumns_result clone() {
17890       return new getRowsWithColumns_result(this);
17891     }
17892 
17893     public int getSuccessSize() {
17894       return (this.success == null) ? 0 : this.success.size();
17895     }
17896 
17897     public java.util.Iterator<TRowResult> getSuccessIterator() {
17898       return (this.success == null) ? null : this.success.iterator();
17899     }
17900 
17901     public void addToSuccess(TRowResult elem) {
17902       if (this.success == null) {
17903         this.success = new ArrayList<TRowResult>();
17904       }
17905       this.success.add(elem);
17906     }
17907 
17908     public List<TRowResult> getSuccess() {
17909       return this.success;
17910     }
17911 
17912     public getRowsWithColumns_result setSuccess(List<TRowResult> success) {
17913       this.success = success;
17914       return this;
17915     }
17916 
17917     public void unsetSuccess() {
17918       this.success = null;
17919     }
17920 
17921     /** Returns true if field success is set (has been asigned a value) and false otherwise */
17922     public boolean isSetSuccess() {
17923       return this.success != null;
17924     }
17925 
17926     public void setSuccessIsSet(boolean value) {
17927       if (!value) {
17928         this.success = null;
17929       }
17930     }
17931 
17932     public IOError getIo() {
17933       return this.io;
17934     }
17935 
17936     public getRowsWithColumns_result setIo(IOError io) {
17937       this.io = io;
17938       return this;
17939     }
17940 
17941     public void unsetIo() {
17942       this.io = null;
17943     }
17944 
17945     /** Returns true if field io is set (has been asigned a value) and false otherwise */
17946     public boolean isSetIo() {
17947       return this.io != null;
17948     }
17949 
17950     public void setIoIsSet(boolean value) {
17951       if (!value) {
17952         this.io = null;
17953       }
17954     }
17955 
17956     public void setFieldValue(_Fields field, Object value) {
17957       switch (field) {
17958       case SUCCESS:
17959         if (value == null) {
17960           unsetSuccess();
17961         } else {
17962           setSuccess((List<TRowResult>)value);
17963         }
17964         break;
17965 
17966       case IO:
17967         if (value == null) {
17968           unsetIo();
17969         } else {
17970           setIo((IOError)value);
17971         }
17972         break;
17973 
17974       }
17975     }
17976 
17977     public void setFieldValue(int fieldID, Object value) {
17978       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17979     }
17980 
17981     public Object getFieldValue(_Fields field) {
17982       switch (field) {
17983       case SUCCESS:
17984         return getSuccess();
17985 
17986       case IO:
17987         return getIo();
17988 
17989       }
17990       throw new IllegalStateException();
17991     }
17992 
17993     public Object getFieldValue(int fieldId) {
17994       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17995     }
17996 
17997     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
17998     public boolean isSet(_Fields field) {
17999       switch (field) {
18000       case SUCCESS:
18001         return isSetSuccess();
18002       case IO:
18003         return isSetIo();
18004       }
18005       throw new IllegalStateException();
18006     }
18007 
18008     public boolean isSet(int fieldID) {
18009       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18010     }
18011 
18012     @Override
18013     public boolean equals(Object that) {
18014       if (that == null)
18015         return false;
18016       if (that instanceof getRowsWithColumns_result)
18017         return this.equals((getRowsWithColumns_result)that);
18018       return false;
18019     }
18020 
18021     public boolean equals(getRowsWithColumns_result that) {
18022       if (that == null)
18023         return false;
18024 
18025       boolean this_present_success = true && this.isSetSuccess();
18026       boolean that_present_success = true && that.isSetSuccess();
18027       if (this_present_success || that_present_success) {
18028         if (!(this_present_success && that_present_success))
18029           return false;
18030         if (!this.success.equals(that.success))
18031           return false;
18032       }
18033 
18034       boolean this_present_io = true && this.isSetIo();
18035       boolean that_present_io = true && that.isSetIo();
18036       if (this_present_io || that_present_io) {
18037         if (!(this_present_io && that_present_io))
18038           return false;
18039         if (!this.io.equals(that.io))
18040           return false;
18041       }
18042 
18043       return true;
18044     }
18045 
18046     @Override
18047     public int hashCode() {
18048       HashCodeBuilder builder = new HashCodeBuilder();
18049 
18050       boolean present_success = true && (isSetSuccess());
18051       builder.append(present_success);
18052       if (present_success)
18053         builder.append(success);
18054 
18055       boolean present_io = true && (isSetIo());
18056       builder.append(present_io);
18057       if (present_io)
18058         builder.append(io);
18059 
18060       return builder.toHashCode();
18061     }
18062 
18063     public void read(TProtocol iprot) throws TException {
18064       TField field;
18065       iprot.readStructBegin();
18066       while (true)
18067       {
18068         field = iprot.readFieldBegin();
18069         if (field.type == TType.STOP) {
18070           break;
18071         }
18072         _Fields fieldId = _Fields.findByThriftId(field.id);
18073         if (fieldId == null) {
18074           TProtocolUtil.skip(iprot, field.type);
18075         } else {
18076           switch (fieldId) {
18077             case SUCCESS:
18078               if (field.type == TType.LIST) {
18079                 {
18080                   TList _list78 = iprot.readListBegin();
18081                   this.success = new ArrayList<TRowResult>(_list78.size);
18082                   for (int _i79 = 0; _i79 < _list78.size; ++_i79)
18083                   {
18084                     TRowResult _elem80;
18085                     _elem80 = new TRowResult();
18086                     _elem80.read(iprot);
18087                     this.success.add(_elem80);
18088                   }
18089                   iprot.readListEnd();
18090                 }
18091               } else {
18092                 TProtocolUtil.skip(iprot, field.type);
18093               }
18094               break;
18095             case IO:
18096               if (field.type == TType.STRUCT) {
18097                 this.io = new IOError();
18098                 this.io.read(iprot);
18099               } else {
18100                 TProtocolUtil.skip(iprot, field.type);
18101               }
18102               break;
18103           }
18104           iprot.readFieldEnd();
18105         }
18106       }
18107       iprot.readStructEnd();
18108 
18109       // check for required fields of primitive type, which can't be checked in the validate method
18110       validate();
18111     }
18112 
18113     public void write(TProtocol oprot) throws TException {
18114       oprot.writeStructBegin(STRUCT_DESC);
18115 
18116       if (this.isSetSuccess()) {
18117         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18118         {
18119           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
18120           for (TRowResult _iter81 : this.success)
18121           {
18122             _iter81.write(oprot);
18123           }
18124           oprot.writeListEnd();
18125         }
18126         oprot.writeFieldEnd();
18127       } else if (this.isSetIo()) {
18128         oprot.writeFieldBegin(IO_FIELD_DESC);
18129         this.io.write(oprot);
18130         oprot.writeFieldEnd();
18131       }
18132       oprot.writeFieldStop();
18133       oprot.writeStructEnd();
18134     }
18135 
18136     @Override
18137     public String toString() {
18138       StringBuilder sb = new StringBuilder("getRowsWithColumns_result(");
18139       boolean first = true;
18140 
18141       sb.append("success:");
18142       if (this.success == null) {
18143         sb.append("null");
18144       } else {
18145         sb.append(this.success);
18146       }
18147       first = false;
18148       if (!first) sb.append(", ");
18149       sb.append("io:");
18150       if (this.io == null) {
18151         sb.append("null");
18152       } else {
18153         sb.append(this.io);
18154       }
18155       first = false;
18156       sb.append(")");
18157       return sb.toString();
18158     }
18159 
18160     public void validate() throws TException {
18161       // check for required fields
18162     }
18163 
18164   }
18165 
18166   public static class getRowsTs_args implements TBase<getRowsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsTs_args>   {
18167     private static final TStruct STRUCT_DESC = new TStruct("getRowsTs_args");
18168 
18169     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
18170     private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
18171     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
18172 
18173     /**
18174      * name of the table
18175      */
18176     public byte[] tableName;
18177     /**
18178      * row keys
18179      */
18180     public List<byte[]> rows;
18181     /**
18182      * timestamp
18183      */
18184     public long timestamp;
18185 
18186     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
18187     public enum _Fields implements TFieldIdEnum {
18188       /**
18189        * name of the table
18190        */
18191       TABLE_NAME((short)1, "tableName"),
18192       /**
18193        * row keys
18194        */
18195       ROWS((short)2, "rows"),
18196       /**
18197        * timestamp
18198        */
18199       TIMESTAMP((short)3, "timestamp");
18200 
18201       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18202       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18203 
18204       static {
18205         for (_Fields field : EnumSet.allOf(_Fields.class)) {
18206           byId.put((int)field._thriftId, field);
18207           byName.put(field.getFieldName(), field);
18208         }
18209       }
18210 
18211       /**
18212        * Find the _Fields constant that matches fieldId, or null if its not found.
18213        */
18214       public static _Fields findByThriftId(int fieldId) {
18215         return byId.get(fieldId);
18216       }
18217 
18218       /**
18219        * Find the _Fields constant that matches fieldId, throwing an exception
18220        * if it is not found.
18221        */
18222       public static _Fields findByThriftIdOrThrow(int fieldId) {
18223         _Fields fields = findByThriftId(fieldId);
18224         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18225         return fields;
18226       }
18227 
18228       /**
18229        * Find the _Fields constant that matches name, or null if its not found.
18230        */
18231       public static _Fields findByName(String name) {
18232         return byName.get(name);
18233       }
18234 
18235       private final short _thriftId;
18236       private final String _fieldName;
18237 
18238       _Fields(short thriftId, String fieldName) {
18239         _thriftId = thriftId;
18240         _fieldName = fieldName;
18241       }
18242 
18243       public short getThriftFieldId() {
18244         return _thriftId;
18245       }
18246 
18247       public String getFieldName() {
18248         return _fieldName;
18249       }
18250     }
18251 
18252     // isset id assignments
18253     private static final int __TIMESTAMP_ISSET_ID = 0;
18254     private BitSet __isset_bit_vector = new BitSet(1);
18255 
18256     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18257       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
18258           new FieldValueMetaData(TType.STRING)));
18259       put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
18260           new ListMetaData(TType.LIST,
18261               new FieldValueMetaData(TType.STRING))));
18262       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
18263           new FieldValueMetaData(TType.I64)));
18264     }});
18265 
18266     static {
18267       FieldMetaData.addStructMetaDataMap(getRowsTs_args.class, metaDataMap);
18268     }
18269 
18270     public getRowsTs_args() {
18271     }
18272 
18273     public getRowsTs_args(
18274       byte[] tableName,
18275       List<byte[]> rows,
18276       long timestamp)
18277     {
18278       this();
18279       this.tableName = tableName;
18280       this.rows = rows;
18281       this.timestamp = timestamp;
18282       setTimestampIsSet(true);
18283     }
18284 
18285     /**
18286      * Performs a deep copy on <i>other</i>.
18287      */
18288     public getRowsTs_args(getRowsTs_args other) {
18289       __isset_bit_vector.clear();
18290       __isset_bit_vector.or(other.__isset_bit_vector);
18291       if (other.isSetTableName()) {
18292         this.tableName = other.tableName;
18293       }
18294       if (other.isSetRows()) {
18295         List<byte[]> __this__rows = new ArrayList<byte[]>();
18296         for (byte[] other_element : other.rows) {
18297           __this__rows.add(other_element);
18298         }
18299         this.rows = __this__rows;
18300       }
18301       this.timestamp = other.timestamp;
18302     }
18303 
18304     public getRowsTs_args deepCopy() {
18305       return new getRowsTs_args(this);
18306     }
18307 
18308     @Deprecated
18309     public getRowsTs_args clone() {
18310       return new getRowsTs_args(this);
18311     }
18312 
18313     /**
18314      * name of the table
18315      */
18316     public byte[] getTableName() {
18317       return this.tableName;
18318     }
18319 
18320     /**
18321      * name of the table
18322      */
18323     public getRowsTs_args setTableName(byte[] tableName) {
18324       this.tableName = tableName;
18325       return this;
18326     }
18327 
18328     public void unsetTableName() {
18329       this.tableName = null;
18330     }
18331 
18332     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
18333     public boolean isSetTableName() {
18334       return this.tableName != null;
18335     }
18336 
18337     public void setTableNameIsSet(boolean value) {
18338       if (!value) {
18339         this.tableName = null;
18340       }
18341     }
18342 
18343     public int getRowsSize() {
18344       return (this.rows == null) ? 0 : this.rows.size();
18345     }
18346 
18347     public java.util.Iterator<byte[]> getRowsIterator() {
18348       return (this.rows == null) ? null : this.rows.iterator();
18349     }
18350 
18351     public void addToRows(byte[] elem) {
18352       if (this.rows == null) {
18353         this.rows = new ArrayList<byte[]>();
18354       }
18355       this.rows.add(elem);
18356     }
18357 
18358     /**
18359      * row keys
18360      */
18361     public List<byte[]> getRows() {
18362       return this.rows;
18363     }
18364 
18365     /**
18366      * row keys
18367      */
18368     public getRowsTs_args setRows(List<byte[]> rows) {
18369       this.rows = rows;
18370       return this;
18371     }
18372 
18373     public void unsetRows() {
18374       this.rows = null;
18375     }
18376 
18377     /** Returns true if field rows is set (has been asigned a value) and false otherwise */
18378     public boolean isSetRows() {
18379       return this.rows != null;
18380     }
18381 
18382     public void setRowsIsSet(boolean value) {
18383       if (!value) {
18384         this.rows = null;
18385       }
18386     }
18387 
18388     /**
18389      * timestamp
18390      */
18391     public long getTimestamp() {
18392       return this.timestamp;
18393     }
18394 
18395     /**
18396      * timestamp
18397      */
18398     public getRowsTs_args setTimestamp(long timestamp) {
18399       this.timestamp = timestamp;
18400       setTimestampIsSet(true);
18401       return this;
18402     }
18403 
18404     public void unsetTimestamp() {
18405       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
18406     }
18407 
18408     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
18409     public boolean isSetTimestamp() {
18410       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
18411     }
18412 
18413     public void setTimestampIsSet(boolean value) {
18414       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
18415     }
18416 
18417     public void setFieldValue(_Fields field, Object value) {
18418       switch (field) {
18419       case TABLE_NAME:
18420         if (value == null) {
18421           unsetTableName();
18422         } else {
18423           setTableName((byte[])value);
18424         }
18425         break;
18426 
18427       case ROWS:
18428         if (value == null) {
18429           unsetRows();
18430         } else {
18431           setRows((List<byte[]>)value);
18432         }
18433         break;
18434 
18435       case TIMESTAMP:
18436         if (value == null) {
18437           unsetTimestamp();
18438         } else {
18439           setTimestamp((Long)value);
18440         }
18441         break;
18442 
18443       }
18444     }
18445 
18446     public void setFieldValue(int fieldID, Object value) {
18447       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
18448     }
18449 
18450     public Object getFieldValue(_Fields field) {
18451       switch (field) {
18452       case TABLE_NAME:
18453         return getTableName();
18454 
18455       case ROWS:
18456         return getRows();
18457 
18458       case TIMESTAMP:
18459         return new Long(getTimestamp());
18460 
18461       }
18462       throw new IllegalStateException();
18463     }
18464 
18465     public Object getFieldValue(int fieldId) {
18466       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
18467     }
18468 
18469     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
18470     public boolean isSet(_Fields field) {
18471       switch (field) {
18472       case TABLE_NAME:
18473         return isSetTableName();
18474       case ROWS:
18475         return isSetRows();
18476       case TIMESTAMP:
18477         return isSetTimestamp();
18478       }
18479       throw new IllegalStateException();
18480     }
18481 
18482     public boolean isSet(int fieldID) {
18483       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18484     }
18485 
18486     @Override
18487     public boolean equals(Object that) {
18488       if (that == null)
18489         return false;
18490       if (that instanceof getRowsTs_args)
18491         return this.equals((getRowsTs_args)that);
18492       return false;
18493     }
18494 
18495     public boolean equals(getRowsTs_args that) {
18496       if (that == null)
18497         return false;
18498 
18499       boolean this_present_tableName = true && this.isSetTableName();
18500       boolean that_present_tableName = true && that.isSetTableName();
18501       if (this_present_tableName || that_present_tableName) {
18502         if (!(this_present_tableName && that_present_tableName))
18503           return false;
18504         if (!java.util.Arrays.equals(this.tableName, that.tableName))
18505           return false;
18506       }
18507 
18508       boolean this_present_rows = true && this.isSetRows();
18509       boolean that_present_rows = true && that.isSetRows();
18510       if (this_present_rows || that_present_rows) {
18511         if (!(this_present_rows && that_present_rows))
18512           return false;
18513         if (!this.rows.equals(that.rows))
18514           return false;
18515       }
18516 
18517       boolean this_present_timestamp = true;
18518       boolean that_present_timestamp = true;
18519       if (this_present_timestamp || that_present_timestamp) {
18520         if (!(this_present_timestamp && that_present_timestamp))
18521           return false;
18522         if (this.timestamp != that.timestamp)
18523           return false;
18524       }
18525 
18526       return true;
18527     }
18528 
18529     @Override
18530     public int hashCode() {
18531       HashCodeBuilder builder = new HashCodeBuilder();
18532 
18533       boolean present_tableName = true && (isSetTableName());
18534       builder.append(present_tableName);
18535       if (present_tableName)
18536         builder.append(tableName);
18537 
18538       boolean present_rows = true && (isSetRows());
18539       builder.append(present_rows);
18540       if (present_rows)
18541         builder.append(rows);
18542 
18543       boolean present_timestamp = true;
18544       builder.append(present_timestamp);
18545       if (present_timestamp)
18546         builder.append(timestamp);
18547 
18548       return builder.toHashCode();
18549     }
18550 
18551     public int compareTo(getRowsTs_args other) {
18552       if (!getClass().equals(other.getClass())) {
18553         return getClass().getName().compareTo(other.getClass().getName());
18554       }
18555 
18556       int lastComparison = 0;
18557       getRowsTs_args typedOther = (getRowsTs_args)other;
18558 
18559       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
18560       if (lastComparison != 0) {
18561         return lastComparison;
18562       }
18563       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
18564       if (lastComparison != 0) {
18565         return lastComparison;
18566       }
18567       lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
18568       if (lastComparison != 0) {
18569         return lastComparison;
18570       }
18571       lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
18572       if (lastComparison != 0) {
18573         return lastComparison;
18574       }
18575       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
18576       if (lastComparison != 0) {
18577         return lastComparison;
18578       }
18579       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
18580       if (lastComparison != 0) {
18581         return lastComparison;
18582       }
18583       return 0;
18584     }
18585 
18586     public void read(TProtocol iprot) throws TException {
18587       TField field;
18588       iprot.readStructBegin();
18589       while (true)
18590       {
18591         field = iprot.readFieldBegin();
18592         if (field.type == TType.STOP) {
18593           break;
18594         }
18595         _Fields fieldId = _Fields.findByThriftId(field.id);
18596         if (fieldId == null) {
18597           TProtocolUtil.skip(iprot, field.type);
18598         } else {
18599           switch (fieldId) {
18600             case TABLE_NAME:
18601               if (field.type == TType.STRING) {
18602                 this.tableName = iprot.readBinary();
18603               } else {
18604                 TProtocolUtil.skip(iprot, field.type);
18605               }
18606               break;
18607             case ROWS:
18608               if (field.type == TType.LIST) {
18609                 {
18610                   TList _list82 = iprot.readListBegin();
18611                   this.rows = new ArrayList<byte[]>(_list82.size);
18612                   for (int _i83 = 0; _i83 < _list82.size; ++_i83)
18613                   {
18614                     byte[] _elem84;
18615                     _elem84 = iprot.readBinary();
18616                     this.rows.add(_elem84);
18617                   }
18618                   iprot.readListEnd();
18619                 }
18620               } else {
18621                 TProtocolUtil.skip(iprot, field.type);
18622               }
18623               break;
18624             case TIMESTAMP:
18625               if (field.type == TType.I64) {
18626                 this.timestamp = iprot.readI64();
18627                 setTimestampIsSet(true);
18628               } else {
18629                 TProtocolUtil.skip(iprot, field.type);
18630               }
18631               break;
18632           }
18633           iprot.readFieldEnd();
18634         }
18635       }
18636       iprot.readStructEnd();
18637 
18638       // check for required fields of primitive type, which can't be checked in the validate method
18639       validate();
18640     }
18641 
18642     public void write(TProtocol oprot) throws TException {
18643       validate();
18644 
18645       oprot.writeStructBegin(STRUCT_DESC);
18646       if (this.tableName != null) {
18647         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
18648         oprot.writeBinary(this.tableName);
18649         oprot.writeFieldEnd();
18650       }
18651       if (this.rows != null) {
18652         oprot.writeFieldBegin(ROWS_FIELD_DESC);
18653         {
18654           oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
18655           for (byte[] _iter85 : this.rows)
18656           {
18657             oprot.writeBinary(_iter85);
18658           }
18659           oprot.writeListEnd();
18660         }
18661         oprot.writeFieldEnd();
18662       }
18663       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
18664       oprot.writeI64(this.timestamp);
18665       oprot.writeFieldEnd();
18666       oprot.writeFieldStop();
18667       oprot.writeStructEnd();
18668     }
18669 
18670     @Override
18671     public String toString() {
18672       StringBuilder sb = new StringBuilder("getRowsTs_args(");
18673       boolean first = true;
18674 
18675       sb.append("tableName:");
18676       if (this.tableName == null) {
18677         sb.append("null");
18678       } else {
18679         sb.append(this.tableName);
18680       }
18681       first = false;
18682       if (!first) sb.append(", ");
18683       sb.append("rows:");
18684       if (this.rows == null) {
18685         sb.append("null");
18686       } else {
18687         sb.append(this.rows);
18688       }
18689       first = false;
18690       if (!first) sb.append(", ");
18691       sb.append("timestamp:");
18692       sb.append(this.timestamp);
18693       first = false;
18694       sb.append(")");
18695       return sb.toString();
18696     }
18697 
18698     public void validate() throws TException {
18699       // check for required fields
18700     }
18701 
18702   }
18703 
18704   public static class getRowsTs_result implements TBase<getRowsTs_result._Fields>, java.io.Serializable, Cloneable   {
18705     private static final TStruct STRUCT_DESC = new TStruct("getRowsTs_result");
18706 
18707     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
18708     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
18709 
18710     public List<TRowResult> success;
18711     public IOError io;
18712 
18713     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
18714     public enum _Fields implements TFieldIdEnum {
18715       SUCCESS((short)0, "success"),
18716       IO((short)1, "io");
18717 
18718       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18719       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18720 
18721       static {
18722         for (_Fields field : EnumSet.allOf(_Fields.class)) {
18723           byId.put((int)field._thriftId, field);
18724           byName.put(field.getFieldName(), field);
18725         }
18726       }
18727 
18728       /**
18729        * Find the _Fields constant that matches fieldId, or null if its not found.
18730        */
18731       public static _Fields findByThriftId(int fieldId) {
18732         return byId.get(fieldId);
18733       }
18734 
18735       /**
18736        * Find the _Fields constant that matches fieldId, throwing an exception
18737        * if it is not found.
18738        */
18739       public static _Fields findByThriftIdOrThrow(int fieldId) {
18740         _Fields fields = findByThriftId(fieldId);
18741         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18742         return fields;
18743       }
18744 
18745       /**
18746        * Find the _Fields constant that matches name, or null if its not found.
18747        */
18748       public static _Fields findByName(String name) {
18749         return byName.get(name);
18750       }
18751 
18752       private final short _thriftId;
18753       private final String _fieldName;
18754 
18755       _Fields(short thriftId, String fieldName) {
18756         _thriftId = thriftId;
18757         _fieldName = fieldName;
18758       }
18759 
18760       public short getThriftFieldId() {
18761         return _thriftId;
18762       }
18763 
18764       public String getFieldName() {
18765         return _fieldName;
18766       }
18767     }
18768 
18769     // isset id assignments
18770 
18771     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18772       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
18773           new ListMetaData(TType.LIST,
18774               new StructMetaData(TType.STRUCT, TRowResult.class))));
18775       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
18776           new FieldValueMetaData(TType.STRUCT)));
18777     }});
18778 
18779     static {
18780       FieldMetaData.addStructMetaDataMap(getRowsTs_result.class, metaDataMap);
18781     }
18782 
18783     public getRowsTs_result() {
18784     }
18785 
18786     public getRowsTs_result(
18787       List<TRowResult> success,
18788       IOError io)
18789     {
18790       this();
18791       this.success = success;
18792       this.io = io;
18793     }
18794 
18795     /**
18796      * Performs a deep copy on <i>other</i>.
18797      */
18798     public getRowsTs_result(getRowsTs_result other) {
18799       if (other.isSetSuccess()) {
18800         List<TRowResult> __this__success = new ArrayList<TRowResult>();
18801         for (TRowResult other_element : other.success) {
18802           __this__success.add(new TRowResult(other_element));
18803         }
18804         this.success = __this__success;
18805       }
18806       if (other.isSetIo()) {
18807         this.io = new IOError(other.io);
18808       }
18809     }
18810 
18811     public getRowsTs_result deepCopy() {
18812       return new getRowsTs_result(this);
18813     }
18814 
18815     @Deprecated
18816     public getRowsTs_result clone() {
18817       return new getRowsTs_result(this);
18818     }
18819 
18820     public int getSuccessSize() {
18821       return (this.success == null) ? 0 : this.success.size();
18822     }
18823 
18824     public java.util.Iterator<TRowResult> getSuccessIterator() {
18825       return (this.success == null) ? null : this.success.iterator();
18826     }
18827 
18828     public void addToSuccess(TRowResult elem) {
18829       if (this.success == null) {
18830         this.success = new ArrayList<TRowResult>();
18831       }
18832       this.success.add(elem);
18833     }
18834 
18835     public List<TRowResult> getSuccess() {
18836       return this.success;
18837     }
18838 
18839     public getRowsTs_result setSuccess(List<TRowResult> success) {
18840       this.success = success;
18841       return this;
18842     }
18843 
18844     public void unsetSuccess() {
18845       this.success = null;
18846     }
18847 
18848     /** Returns true if field success is set (has been asigned a value) and false otherwise */
18849     public boolean isSetSuccess() {
18850       return this.success != null;
18851     }
18852 
18853     public void setSuccessIsSet(boolean value) {
18854       if (!value) {
18855         this.success = null;
18856       }
18857     }
18858 
18859     public IOError getIo() {
18860       return this.io;
18861     }
18862 
18863     public getRowsTs_result setIo(IOError io) {
18864       this.io = io;
18865       return this;
18866     }
18867 
18868     public void unsetIo() {
18869       this.io = null;
18870     }
18871 
18872     /** Returns true if field io is set (has been asigned a value) and false otherwise */
18873     public boolean isSetIo() {
18874       return this.io != null;
18875     }
18876 
18877     public void setIoIsSet(boolean value) {
18878       if (!value) {
18879         this.io = null;
18880       }
18881     }
18882 
18883     public void setFieldValue(_Fields field, Object value) {
18884       switch (field) {
18885       case SUCCESS:
18886         if (value == null) {
18887           unsetSuccess();
18888         } else {
18889           setSuccess((List<TRowResult>)value);
18890         }
18891         break;
18892 
18893       case IO:
18894         if (value == null) {
18895           unsetIo();
18896         } else {
18897           setIo((IOError)value);
18898         }
18899         break;
18900 
18901       }
18902     }
18903 
18904     public void setFieldValue(int fieldID, Object value) {
18905       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
18906     }
18907 
18908     public Object getFieldValue(_Fields field) {
18909       switch (field) {
18910       case SUCCESS:
18911         return getSuccess();
18912 
18913       case IO:
18914         return getIo();
18915 
18916       }
18917       throw new IllegalStateException();
18918     }
18919 
18920     public Object getFieldValue(int fieldId) {
18921       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
18922     }
18923 
18924     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
18925     public boolean isSet(_Fields field) {
18926       switch (field) {
18927       case SUCCESS:
18928         return isSetSuccess();
18929       case IO:
18930         return isSetIo();
18931       }
18932       throw new IllegalStateException();
18933     }
18934 
18935     public boolean isSet(int fieldID) {
18936       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18937     }
18938 
18939     @Override
18940     public boolean equals(Object that) {
18941       if (that == null)
18942         return false;
18943       if (that instanceof getRowsTs_result)
18944         return this.equals((getRowsTs_result)that);
18945       return false;
18946     }
18947 
18948     public boolean equals(getRowsTs_result that) {
18949       if (that == null)
18950         return false;
18951 
18952       boolean this_present_success = true && this.isSetSuccess();
18953       boolean that_present_success = true && that.isSetSuccess();
18954       if (this_present_success || that_present_success) {
18955         if (!(this_present_success && that_present_success))
18956           return false;
18957         if (!this.success.equals(that.success))
18958           return false;
18959       }
18960 
18961       boolean this_present_io = true && this.isSetIo();
18962       boolean that_present_io = true && that.isSetIo();
18963       if (this_present_io || that_present_io) {
18964         if (!(this_present_io && that_present_io))
18965           return false;
18966         if (!this.io.equals(that.io))
18967           return false;
18968       }
18969 
18970       return true;
18971     }
18972 
18973     @Override
18974     public int hashCode() {
18975       HashCodeBuilder builder = new HashCodeBuilder();
18976 
18977       boolean present_success = true && (isSetSuccess());
18978       builder.append(present_success);
18979       if (present_success)
18980         builder.append(success);
18981 
18982       boolean present_io = true && (isSetIo());
18983       builder.append(present_io);
18984       if (present_io)
18985         builder.append(io);
18986 
18987       return builder.toHashCode();
18988     }
18989 
18990     public void read(TProtocol iprot) throws TException {
18991       TField field;
18992       iprot.readStructBegin();
18993       while (true)
18994       {
18995         field = iprot.readFieldBegin();
18996         if (field.type == TType.STOP) {
18997           break;
18998         }
18999         _Fields fieldId = _Fields.findByThriftId(field.id);
19000         if (fieldId == null) {
19001           TProtocolUtil.skip(iprot, field.type);
19002         } else {
19003           switch (fieldId) {
19004             case SUCCESS:
19005               if (field.type == TType.LIST) {
19006                 {
19007                   TList _list86 = iprot.readListBegin();
19008                   this.success = new ArrayList<TRowResult>(_list86.size);
19009                   for (int _i87 = 0; _i87 < _list86.size; ++_i87)
19010                   {
19011                     TRowResult _elem88;
19012                     _elem88 = new TRowResult();
19013                     _elem88.read(iprot);
19014                     this.success.add(_elem88);
19015                   }
19016                   iprot.readListEnd();
19017                 }
19018               } else {
19019                 TProtocolUtil.skip(iprot, field.type);
19020               }
19021               break;
19022             case IO:
19023               if (field.type == TType.STRUCT) {
19024                 this.io = new IOError();
19025                 this.io.read(iprot);
19026               } else {
19027                 TProtocolUtil.skip(iprot, field.type);
19028               }
19029               break;
19030           }
19031           iprot.readFieldEnd();
19032         }
19033       }
19034       iprot.readStructEnd();
19035 
19036       // check for required fields of primitive type, which can't be checked in the validate method
19037       validate();
19038     }
19039 
19040     public void write(TProtocol oprot) throws TException {
19041       oprot.writeStructBegin(STRUCT_DESC);
19042 
19043       if (this.isSetSuccess()) {
19044         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
19045         {
19046           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
19047           for (TRowResult _iter89 : this.success)
19048           {
19049             _iter89.write(oprot);
19050           }
19051           oprot.writeListEnd();
19052         }
19053         oprot.writeFieldEnd();
19054       } else if (this.isSetIo()) {
19055         oprot.writeFieldBegin(IO_FIELD_DESC);
19056         this.io.write(oprot);
19057         oprot.writeFieldEnd();
19058       }
19059       oprot.writeFieldStop();
19060       oprot.writeStructEnd();
19061     }
19062 
19063     @Override
19064     public String toString() {
19065       StringBuilder sb = new StringBuilder("getRowsTs_result(");
19066       boolean first = true;
19067 
19068       sb.append("success:");
19069       if (this.success == null) {
19070         sb.append("null");
19071       } else {
19072         sb.append(this.success);
19073       }
19074       first = false;
19075       if (!first) sb.append(", ");
19076       sb.append("io:");
19077       if (this.io == null) {
19078         sb.append("null");
19079       } else {
19080         sb.append(this.io);
19081       }
19082       first = false;
19083       sb.append(")");
19084       return sb.toString();
19085     }
19086 
19087     public void validate() throws TException {
19088       // check for required fields
19089     }
19090 
19091   }
19092 
19093   public static class getRowsWithColumnsTs_args implements TBase<getRowsWithColumnsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsWithColumnsTs_args>   {
19094     private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumnsTs_args");
19095 
19096     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
19097     private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
19098     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
19099     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
19100 
19101     /**
19102      * name of table
19103      */
19104     public byte[] tableName;
19105     /**
19106      * row keys
19107      */
19108     public List<byte[]> rows;
19109     /**
19110      * List of columns to return, null for all columns
19111      */
19112     public List<byte[]> columns;
19113     public long timestamp;
19114 
19115     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
19116     public enum _Fields implements TFieldIdEnum {
19117       /**
19118        * name of table
19119        */
19120       TABLE_NAME((short)1, "tableName"),
19121       /**
19122        * row keys
19123        */
19124       ROWS((short)2, "rows"),
19125       /**
19126        * List of columns to return, null for all columns
19127        */
19128       COLUMNS((short)3, "columns"),
19129       TIMESTAMP((short)4, "timestamp");
19130 
19131       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
19132       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
19133 
19134       static {
19135         for (_Fields field : EnumSet.allOf(_Fields.class)) {
19136           byId.put((int)field._thriftId, field);
19137           byName.put(field.getFieldName(), field);
19138         }
19139       }
19140 
19141       /**
19142        * Find the _Fields constant that matches fieldId, or null if its not found.
19143        */
19144       public static _Fields findByThriftId(int fieldId) {
19145         return byId.get(fieldId);
19146       }
19147 
19148       /**
19149        * Find the _Fields constant that matches fieldId, throwing an exception
19150        * if it is not found.
19151        */
19152       public static _Fields findByThriftIdOrThrow(int fieldId) {
19153         _Fields fields = findByThriftId(fieldId);
19154         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
19155         return fields;
19156       }
19157 
19158       /**
19159        * Find the _Fields constant that matches name, or null if its not found.
19160        */
19161       public static _Fields findByName(String name) {
19162         return byName.get(name);
19163       }
19164 
19165       private final short _thriftId;
19166       private final String _fieldName;
19167 
19168       _Fields(short thriftId, String fieldName) {
19169         _thriftId = thriftId;
19170         _fieldName = fieldName;
19171       }
19172 
19173       public short getThriftFieldId() {
19174         return _thriftId;
19175       }
19176 
19177       public String getFieldName() {
19178         return _fieldName;
19179       }
19180     }
19181 
19182     // isset id assignments
19183     private static final int __TIMESTAMP_ISSET_ID = 0;
19184     private BitSet __isset_bit_vector = new BitSet(1);
19185 
19186     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
19187       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
19188           new FieldValueMetaData(TType.STRING)));
19189       put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
19190           new ListMetaData(TType.LIST,
19191               new FieldValueMetaData(TType.STRING))));
19192       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
19193           new ListMetaData(TType.LIST,
19194               new FieldValueMetaData(TType.STRING))));
19195       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
19196           new FieldValueMetaData(TType.I64)));
19197     }});
19198 
19199     static {
19200       FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_args.class, metaDataMap);
19201     }
19202 
19203     public getRowsWithColumnsTs_args() {
19204     }
19205 
19206     public getRowsWithColumnsTs_args(
19207       byte[] tableName,
19208       List<byte[]> rows,
19209       List<byte[]> columns,
19210       long timestamp)
19211     {
19212       this();
19213       this.tableName = tableName;
19214       this.rows = rows;
19215       this.columns = columns;
19216       this.timestamp = timestamp;
19217       setTimestampIsSet(true);
19218     }
19219 
19220     /**
19221      * Performs a deep copy on <i>other</i>.
19222      */
19223     public getRowsWithColumnsTs_args(getRowsWithColumnsTs_args other) {
19224       __isset_bit_vector.clear();
19225       __isset_bit_vector.or(other.__isset_bit_vector);
19226       if (other.isSetTableName()) {
19227         this.tableName = other.tableName;
19228       }
19229       if (other.isSetRows()) {
19230         List<byte[]> __this__rows = new ArrayList<byte[]>();
19231         for (byte[] other_element : other.rows) {
19232           __this__rows.add(other_element);
19233         }
19234         this.rows = __this__rows;
19235       }
19236       if (other.isSetColumns()) {
19237         List<byte[]> __this__columns = new ArrayList<byte[]>();
19238         for (byte[] other_element : other.columns) {
19239           __this__columns.add(other_element);
19240         }
19241         this.columns = __this__columns;
19242       }
19243       this.timestamp = other.timestamp;
19244     }
19245 
19246     public getRowsWithColumnsTs_args deepCopy() {
19247       return new getRowsWithColumnsTs_args(this);
19248     }
19249 
19250     @Deprecated
19251     public getRowsWithColumnsTs_args clone() {
19252       return new getRowsWithColumnsTs_args(this);
19253     }
19254 
19255     /**
19256      * name of table
19257      */
19258     public byte[] getTableName() {
19259       return this.tableName;
19260     }
19261 
19262     /**
19263      * name of table
19264      */
19265     public getRowsWithColumnsTs_args setTableName(byte[] tableName) {
19266       this.tableName = tableName;
19267       return this;
19268     }
19269 
19270     public void unsetTableName() {
19271       this.tableName = null;
19272     }
19273 
19274     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
19275     public boolean isSetTableName() {
19276       return this.tableName != null;
19277     }
19278 
19279     public void setTableNameIsSet(boolean value) {
19280       if (!value) {
19281         this.tableName = null;
19282       }
19283     }
19284 
19285     public int getRowsSize() {
19286       return (this.rows == null) ? 0 : this.rows.size();
19287     }
19288 
19289     public java.util.Iterator<byte[]> getRowsIterator() {
19290       return (this.rows == null) ? null : this.rows.iterator();
19291     }
19292 
19293     public void addToRows(byte[] elem) {
19294       if (this.rows == null) {
19295         this.rows = new ArrayList<byte[]>();
19296       }
19297       this.rows.add(elem);
19298     }
19299 
19300     /**
19301      * row keys
19302      */
19303     public List<byte[]> getRows() {
19304       return this.rows;
19305     }
19306 
19307     /**
19308      * row keys
19309      */
19310     public getRowsWithColumnsTs_args setRows(List<byte[]> rows) {
19311       this.rows = rows;
19312       return this;
19313     }
19314 
19315     public void unsetRows() {
19316       this.rows = null;
19317     }
19318 
19319     /** Returns true if field rows is set (has been asigned a value) and false otherwise */
19320     public boolean isSetRows() {
19321       return this.rows != null;
19322     }
19323 
19324     public void setRowsIsSet(boolean value) {
19325       if (!value) {
19326         this.rows = null;
19327       }
19328     }
19329 
19330     public int getColumnsSize() {
19331       return (this.columns == null) ? 0 : this.columns.size();
19332     }
19333 
19334     public java.util.Iterator<byte[]> getColumnsIterator() {
19335       return (this.columns == null) ? null : this.columns.iterator();
19336     }
19337 
19338     public void addToColumns(byte[] elem) {
19339       if (this.columns == null) {
19340         this.columns = new ArrayList<byte[]>();
19341       }
19342       this.columns.add(elem);
19343     }
19344 
19345     /**
19346      * List of columns to return, null for all columns
19347      */
19348     public List<byte[]> getColumns() {
19349       return this.columns;
19350     }
19351 
19352     /**
19353      * List of columns to return, null for all columns
19354      */
19355     public getRowsWithColumnsTs_args setColumns(List<byte[]> columns) {
19356       this.columns = columns;
19357       return this;
19358     }
19359 
19360     public void unsetColumns() {
19361       this.columns = null;
19362     }
19363 
19364     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
19365     public boolean isSetColumns() {
19366       return this.columns != null;
19367     }
19368 
19369     public void setColumnsIsSet(boolean value) {
19370       if (!value) {
19371         this.columns = null;
19372       }
19373     }
19374 
19375     public long getTimestamp() {
19376       return this.timestamp;
19377     }
19378 
19379     public getRowsWithColumnsTs_args setTimestamp(long timestamp) {
19380       this.timestamp = timestamp;
19381       setTimestampIsSet(true);
19382       return this;
19383     }
19384 
19385     public void unsetTimestamp() {
19386       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
19387     }
19388 
19389     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
19390     public boolean isSetTimestamp() {
19391       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
19392     }
19393 
19394     public void setTimestampIsSet(boolean value) {
19395       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
19396     }
19397 
19398     public void setFieldValue(_Fields field, Object value) {
19399       switch (field) {
19400       case TABLE_NAME:
19401         if (value == null) {
19402           unsetTableName();
19403         } else {
19404           setTableName((byte[])value);
19405         }
19406         break;
19407 
19408       case ROWS:
19409         if (value == null) {
19410           unsetRows();
19411         } else {
19412           setRows((List<byte[]>)value);
19413         }
19414         break;
19415 
19416       case COLUMNS:
19417         if (value == null) {
19418           unsetColumns();
19419         } else {
19420           setColumns((List<byte[]>)value);
19421         }
19422         break;
19423 
19424       case TIMESTAMP:
19425         if (value == null) {
19426           unsetTimestamp();
19427         } else {
19428           setTimestamp((Long)value);
19429         }
19430         break;
19431 
19432       }
19433     }
19434 
19435     public void setFieldValue(int fieldID, Object value) {
19436       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
19437     }
19438 
19439     public Object getFieldValue(_Fields field) {
19440       switch (field) {
19441       case TABLE_NAME:
19442         return getTableName();
19443 
19444       case ROWS:
19445         return getRows();
19446 
19447       case COLUMNS:
19448         return getColumns();
19449 
19450       case TIMESTAMP:
19451         return new Long(getTimestamp());
19452 
19453       }
19454       throw new IllegalStateException();
19455     }
19456 
19457     public Object getFieldValue(int fieldId) {
19458       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
19459     }
19460 
19461     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
19462     public boolean isSet(_Fields field) {
19463       switch (field) {
19464       case TABLE_NAME:
19465         return isSetTableName();
19466       case ROWS:
19467         return isSetRows();
19468       case COLUMNS:
19469         return isSetColumns();
19470       case TIMESTAMP:
19471         return isSetTimestamp();
19472       }
19473       throw new IllegalStateException();
19474     }
19475 
19476     public boolean isSet(int fieldID) {
19477       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
19478     }
19479 
19480     @Override
19481     public boolean equals(Object that) {
19482       if (that == null)
19483         return false;
19484       if (that instanceof getRowsWithColumnsTs_args)
19485         return this.equals((getRowsWithColumnsTs_args)that);
19486       return false;
19487     }
19488 
19489     public boolean equals(getRowsWithColumnsTs_args that) {
19490       if (that == null)
19491         return false;
19492 
19493       boolean this_present_tableName = true && this.isSetTableName();
19494       boolean that_present_tableName = true && that.isSetTableName();
19495       if (this_present_tableName || that_present_tableName) {
19496         if (!(this_present_tableName && that_present_tableName))
19497           return false;
19498         if (!java.util.Arrays.equals(this.tableName, that.tableName))
19499           return false;
19500       }
19501 
19502       boolean this_present_rows = true && this.isSetRows();
19503       boolean that_present_rows = true && that.isSetRows();
19504       if (this_present_rows || that_present_rows) {
19505         if (!(this_present_rows && that_present_rows))
19506           return false;
19507         if (!this.rows.equals(that.rows))
19508           return false;
19509       }
19510 
19511       boolean this_present_columns = true && this.isSetColumns();
19512       boolean that_present_columns = true && that.isSetColumns();
19513       if (this_present_columns || that_present_columns) {
19514         if (!(this_present_columns && that_present_columns))
19515           return false;
19516         if (!this.columns.equals(that.columns))
19517           return false;
19518       }
19519 
19520       boolean this_present_timestamp = true;
19521       boolean that_present_timestamp = true;
19522       if (this_present_timestamp || that_present_timestamp) {
19523         if (!(this_present_timestamp && that_present_timestamp))
19524           return false;
19525         if (this.timestamp != that.timestamp)
19526           return false;
19527       }
19528 
19529       return true;
19530     }
19531 
19532     @Override
19533     public int hashCode() {
19534       HashCodeBuilder builder = new HashCodeBuilder();
19535 
19536       boolean present_tableName = true && (isSetTableName());
19537       builder.append(present_tableName);
19538       if (present_tableName)
19539         builder.append(tableName);
19540 
19541       boolean present_rows = true && (isSetRows());
19542       builder.append(present_rows);
19543       if (present_rows)
19544         builder.append(rows);
19545 
19546       boolean present_columns = true && (isSetColumns());
19547       builder.append(present_columns);
19548       if (present_columns)
19549         builder.append(columns);
19550 
19551       boolean present_timestamp = true;
19552       builder.append(present_timestamp);
19553       if (present_timestamp)
19554         builder.append(timestamp);
19555 
19556       return builder.toHashCode();
19557     }
19558 
19559     public int compareTo(getRowsWithColumnsTs_args other) {
19560       if (!getClass().equals(other.getClass())) {
19561         return getClass().getName().compareTo(other.getClass().getName());
19562       }
19563 
19564       int lastComparison = 0;
19565       getRowsWithColumnsTs_args typedOther = (getRowsWithColumnsTs_args)other;
19566 
19567       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
19568       if (lastComparison != 0) {
19569         return lastComparison;
19570       }
19571       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
19572       if (lastComparison != 0) {
19573         return lastComparison;
19574       }
19575       lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
19576       if (lastComparison != 0) {
19577         return lastComparison;
19578       }
19579       lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
19580       if (lastComparison != 0) {
19581         return lastComparison;
19582       }
19583       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
19584       if (lastComparison != 0) {
19585         return lastComparison;
19586       }
19587       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
19588       if (lastComparison != 0) {
19589         return lastComparison;
19590       }
19591       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
19592       if (lastComparison != 0) {
19593         return lastComparison;
19594       }
19595       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
19596       if (lastComparison != 0) {
19597         return lastComparison;
19598       }
19599       return 0;
19600     }
19601 
19602     public void read(TProtocol iprot) throws TException {
19603       TField field;
19604       iprot.readStructBegin();
19605       while (true)
19606       {
19607         field = iprot.readFieldBegin();
19608         if (field.type == TType.STOP) {
19609           break;
19610         }
19611         _Fields fieldId = _Fields.findByThriftId(field.id);
19612         if (fieldId == null) {
19613           TProtocolUtil.skip(iprot, field.type);
19614         } else {
19615           switch (fieldId) {
19616             case TABLE_NAME:
19617               if (field.type == TType.STRING) {
19618                 this.tableName = iprot.readBinary();
19619               } else {
19620                 TProtocolUtil.skip(iprot, field.type);
19621               }
19622               break;
19623             case ROWS:
19624               if (field.type == TType.LIST) {
19625                 {
19626                   TList _list90 = iprot.readListBegin();
19627                   this.rows = new ArrayList<byte[]>(_list90.size);
19628                   for (int _i91 = 0; _i91 < _list90.size; ++_i91)
19629                   {
19630                     byte[] _elem92;
19631                     _elem92 = iprot.readBinary();
19632                     this.rows.add(_elem92);
19633                   }
19634                   iprot.readListEnd();
19635                 }
19636               } else {
19637                 TProtocolUtil.skip(iprot, field.type);
19638               }
19639               break;
19640             case COLUMNS:
19641               if (field.type == TType.LIST) {
19642                 {
19643                   TList _list93 = iprot.readListBegin();
19644                   this.columns = new ArrayList<byte[]>(_list93.size);
19645                   for (int _i94 = 0; _i94 < _list93.size; ++_i94)
19646                   {
19647                     byte[] _elem95;
19648                     _elem95 = iprot.readBinary();
19649                     this.columns.add(_elem95);
19650                   }
19651                   iprot.readListEnd();
19652                 }
19653               } else {
19654                 TProtocolUtil.skip(iprot, field.type);
19655               }
19656               break;
19657             case TIMESTAMP:
19658               if (field.type == TType.I64) {
19659                 this.timestamp = iprot.readI64();
19660                 setTimestampIsSet(true);
19661               } else {
19662                 TProtocolUtil.skip(iprot, field.type);
19663               }
19664               break;
19665           }
19666           iprot.readFieldEnd();
19667         }
19668       }
19669       iprot.readStructEnd();
19670 
19671       // check for required fields of primitive type, which can't be checked in the validate method
19672       validate();
19673     }
19674 
19675     public void write(TProtocol oprot) throws TException {
19676       validate();
19677 
19678       oprot.writeStructBegin(STRUCT_DESC);
19679       if (this.tableName != null) {
19680         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
19681         oprot.writeBinary(this.tableName);
19682         oprot.writeFieldEnd();
19683       }
19684       if (this.rows != null) {
19685         oprot.writeFieldBegin(ROWS_FIELD_DESC);
19686         {
19687           oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
19688           for (byte[] _iter96 : this.rows)
19689           {
19690             oprot.writeBinary(_iter96);
19691           }
19692           oprot.writeListEnd();
19693         }
19694         oprot.writeFieldEnd();
19695       }
19696       if (this.columns != null) {
19697         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
19698         {
19699           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
19700           for (byte[] _iter97 : this.columns)
19701           {
19702             oprot.writeBinary(_iter97);
19703           }
19704           oprot.writeListEnd();
19705         }
19706         oprot.writeFieldEnd();
19707       }
19708       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
19709       oprot.writeI64(this.timestamp);
19710       oprot.writeFieldEnd();
19711       oprot.writeFieldStop();
19712       oprot.writeStructEnd();
19713     }
19714 
19715     @Override
19716     public String toString() {
19717       StringBuilder sb = new StringBuilder("getRowsWithColumnsTs_args(");
19718       boolean first = true;
19719 
19720       sb.append("tableName:");
19721       if (this.tableName == null) {
19722         sb.append("null");
19723       } else {
19724         sb.append(this.tableName);
19725       }
19726       first = false;
19727       if (!first) sb.append(", ");
19728       sb.append("rows:");
19729       if (this.rows == null) {
19730         sb.append("null");
19731       } else {
19732         sb.append(this.rows);
19733       }
19734       first = false;
19735       if (!first) sb.append(", ");
19736       sb.append("columns:");
19737       if (this.columns == null) {
19738         sb.append("null");
19739       } else {
19740         sb.append(this.columns);
19741       }
19742       first = false;
19743       if (!first) sb.append(", ");
19744       sb.append("timestamp:");
19745       sb.append(this.timestamp);
19746       first = false;
19747       sb.append(")");
19748       return sb.toString();
19749     }
19750 
19751     public void validate() throws TException {
19752       // check for required fields
19753     }
19754 
19755   }
19756 
19757   public static class getRowsWithColumnsTs_result implements TBase<getRowsWithColumnsTs_result._Fields>, java.io.Serializable, Cloneable   {
19758     private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumnsTs_result");
19759 
19760     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
19761     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
19762 
19763     public List<TRowResult> success;
19764     public IOError io;
19765 
19766     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
19767     public enum _Fields implements TFieldIdEnum {
19768       SUCCESS((short)0, "success"),
19769       IO((short)1, "io");
19770 
19771       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
19772       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
19773 
19774       static {
19775         for (_Fields field : EnumSet.allOf(_Fields.class)) {
19776           byId.put((int)field._thriftId, field);
19777           byName.put(field.getFieldName(), field);
19778         }
19779       }
19780 
19781       /**
19782        * Find the _Fields constant that matches fieldId, or null if its not found.
19783        */
19784       public static _Fields findByThriftId(int fieldId) {
19785         return byId.get(fieldId);
19786       }
19787 
19788       /**
19789        * Find the _Fields constant that matches fieldId, throwing an exception
19790        * if it is not found.
19791        */
19792       public static _Fields findByThriftIdOrThrow(int fieldId) {
19793         _Fields fields = findByThriftId(fieldId);
19794         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
19795         return fields;
19796       }
19797 
19798       /**
19799        * Find the _Fields constant that matches name, or null if its not found.
19800        */
19801       public static _Fields findByName(String name) {
19802         return byName.get(name);
19803       }
19804 
19805       private final short _thriftId;
19806       private final String _fieldName;
19807 
19808       _Fields(short thriftId, String fieldName) {
19809         _thriftId = thriftId;
19810         _fieldName = fieldName;
19811       }
19812 
19813       public short getThriftFieldId() {
19814         return _thriftId;
19815       }
19816 
19817       public String getFieldName() {
19818         return _fieldName;
19819       }
19820     }
19821 
19822     // isset id assignments
19823 
19824     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
19825       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
19826           new ListMetaData(TType.LIST,
19827               new StructMetaData(TType.STRUCT, TRowResult.class))));
19828       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
19829           new FieldValueMetaData(TType.STRUCT)));
19830     }});
19831 
19832     static {
19833       FieldMetaData.addStructMetaDataMap(getRowsWithColumnsTs_result.class, metaDataMap);
19834     }
19835 
19836     public getRowsWithColumnsTs_result() {
19837     }
19838 
19839     public getRowsWithColumnsTs_result(
19840       List<TRowResult> success,
19841       IOError io)
19842     {
19843       this();
19844       this.success = success;
19845       this.io = io;
19846     }
19847 
19848     /**
19849      * Performs a deep copy on <i>other</i>.
19850      */
19851     public getRowsWithColumnsTs_result(getRowsWithColumnsTs_result other) {
19852       if (other.isSetSuccess()) {
19853         List<TRowResult> __this__success = new ArrayList<TRowResult>();
19854         for (TRowResult other_element : other.success) {
19855           __this__success.add(new TRowResult(other_element));
19856         }
19857         this.success = __this__success;
19858       }
19859       if (other.isSetIo()) {
19860         this.io = new IOError(other.io);
19861       }
19862     }
19863 
19864     public getRowsWithColumnsTs_result deepCopy() {
19865       return new getRowsWithColumnsTs_result(this);
19866     }
19867 
19868     @Deprecated
19869     public getRowsWithColumnsTs_result clone() {
19870       return new getRowsWithColumnsTs_result(this);
19871     }
19872 
19873     public int getSuccessSize() {
19874       return (this.success == null) ? 0 : this.success.size();
19875     }
19876 
19877     public java.util.Iterator<TRowResult> getSuccessIterator() {
19878       return (this.success == null) ? null : this.success.iterator();
19879     }
19880 
19881     public void addToSuccess(TRowResult elem) {
19882       if (this.success == null) {
19883         this.success = new ArrayList<TRowResult>();
19884       }
19885       this.success.add(elem);
19886     }
19887 
19888     public List<TRowResult> getSuccess() {
19889       return this.success;
19890     }
19891 
19892     public getRowsWithColumnsTs_result setSuccess(List<TRowResult> success) {
19893       this.success = success;
19894       return this;
19895     }
19896 
19897     public void unsetSuccess() {
19898       this.success = null;
19899     }
19900 
19901     /** Returns true if field success is set (has been asigned a value) and false otherwise */
19902     public boolean isSetSuccess() {
19903       return this.success != null;
19904     }
19905 
19906     public void setSuccessIsSet(boolean value) {
19907       if (!value) {
19908         this.success = null;
19909       }
19910     }
19911 
19912     public IOError getIo() {
19913       return this.io;
19914     }
19915 
19916     public getRowsWithColumnsTs_result setIo(IOError io) {
19917       this.io = io;
19918       return this;
19919     }
19920 
19921     public void unsetIo() {
19922       this.io = null;
19923     }
19924 
19925     /** Returns true if field io is set (has been asigned a value) and false otherwise */
19926     public boolean isSetIo() {
19927       return this.io != null;
19928     }
19929 
19930     public void setIoIsSet(boolean value) {
19931       if (!value) {
19932         this.io = null;
19933       }
19934     }
19935 
19936     public void setFieldValue(_Fields field, Object value) {
19937       switch (field) {
19938       case SUCCESS:
19939         if (value == null) {
19940           unsetSuccess();
19941         } else {
19942           setSuccess((List<TRowResult>)value);
19943         }
19944         break;
19945 
19946       case IO:
19947         if (value == null) {
19948           unsetIo();
19949         } else {
19950           setIo((IOError)value);
19951         }
19952         break;
19953 
19954       }
19955     }
19956 
19957     public void setFieldValue(int fieldID, Object value) {
19958       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
19959     }
19960 
19961     public Object getFieldValue(_Fields field) {
19962       switch (field) {
19963       case SUCCESS:
19964         return getSuccess();
19965 
19966       case IO:
19967         return getIo();
19968 
19969       }
19970       throw new IllegalStateException();
19971     }
19972 
19973     public Object getFieldValue(int fieldId) {
19974       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
19975     }
19976 
19977     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
19978     public boolean isSet(_Fields field) {
19979       switch (field) {
19980       case SUCCESS:
19981         return isSetSuccess();
19982       case IO:
19983         return isSetIo();
19984       }
19985       throw new IllegalStateException();
19986     }
19987 
19988     public boolean isSet(int fieldID) {
19989       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
19990     }
19991 
19992     @Override
19993     public boolean equals(Object that) {
19994       if (that == null)
19995         return false;
19996       if (that instanceof getRowsWithColumnsTs_result)
19997         return this.equals((getRowsWithColumnsTs_result)that);
19998       return false;
19999     }
20000 
20001     public boolean equals(getRowsWithColumnsTs_result that) {
20002       if (that == null)
20003         return false;
20004 
20005       boolean this_present_success = true && this.isSetSuccess();
20006       boolean that_present_success = true && that.isSetSuccess();
20007       if (this_present_success || that_present_success) {
20008         if (!(this_present_success && that_present_success))
20009           return false;
20010         if (!this.success.equals(that.success))
20011           return false;
20012       }
20013 
20014       boolean this_present_io = true && this.isSetIo();
20015       boolean that_present_io = true && that.isSetIo();
20016       if (this_present_io || that_present_io) {
20017         if (!(this_present_io && that_present_io))
20018           return false;
20019         if (!this.io.equals(that.io))
20020           return false;
20021       }
20022 
20023       return true;
20024     }
20025 
20026     @Override
20027     public int hashCode() {
20028       HashCodeBuilder builder = new HashCodeBuilder();
20029 
20030       boolean present_success = true && (isSetSuccess());
20031       builder.append(present_success);
20032       if (present_success)
20033         builder.append(success);
20034 
20035       boolean present_io = true && (isSetIo());
20036       builder.append(present_io);
20037       if (present_io)
20038         builder.append(io);
20039 
20040       return builder.toHashCode();
20041     }
20042 
20043     public void read(TProtocol iprot) throws TException {
20044       TField field;
20045       iprot.readStructBegin();
20046       while (true)
20047       {
20048         field = iprot.readFieldBegin();
20049         if (field.type == TType.STOP) {
20050           break;
20051         }
20052         _Fields fieldId = _Fields.findByThriftId(field.id);
20053         if (fieldId == null) {
20054           TProtocolUtil.skip(iprot, field.type);
20055         } else {
20056           switch (fieldId) {
20057             case SUCCESS:
20058               if (field.type == TType.LIST) {
20059                 {
20060                   TList _list98 = iprot.readListBegin();
20061                   this.success = new ArrayList<TRowResult>(_list98.size);
20062                   for (int _i99 = 0; _i99 < _list98.size; ++_i99)
20063                   {
20064                     TRowResult _elem100;
20065                     _elem100 = new TRowResult();
20066                     _elem100.read(iprot);
20067                     this.success.add(_elem100);
20068                   }
20069                   iprot.readListEnd();
20070                 }
20071               } else {
20072                 TProtocolUtil.skip(iprot, field.type);
20073               }
20074               break;
20075             case IO:
20076               if (field.type == TType.STRUCT) {
20077                 this.io = new IOError();
20078                 this.io.read(iprot);
20079               } else {
20080                 TProtocolUtil.skip(iprot, field.type);
20081               }
20082               break;
20083           }
20084           iprot.readFieldEnd();
20085         }
20086       }
20087       iprot.readStructEnd();
20088 
20089       // check for required fields of primitive type, which can't be checked in the validate method
20090       validate();
20091     }
20092 
20093     public void write(TProtocol oprot) throws TException {
20094       oprot.writeStructBegin(STRUCT_DESC);
20095 
20096       if (this.isSetSuccess()) {
20097         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20098         {
20099           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
20100           for (TRowResult _iter101 : this.success)
20101           {
20102             _iter101.write(oprot);
20103           }
20104           oprot.writeListEnd();
20105         }
20106         oprot.writeFieldEnd();
20107       } else if (this.isSetIo()) {
20108         oprot.writeFieldBegin(IO_FIELD_DESC);
20109         this.io.write(oprot);
20110         oprot.writeFieldEnd();
20111       }
20112       oprot.writeFieldStop();
20113       oprot.writeStructEnd();
20114     }
20115 
20116     @Override
20117     public String toString() {
20118       StringBuilder sb = new StringBuilder("getRowsWithColumnsTs_result(");
20119       boolean first = true;
20120 
20121       sb.append("success:");
20122       if (this.success == null) {
20123         sb.append("null");
20124       } else {
20125         sb.append(this.success);
20126       }
20127       first = false;
20128       if (!first) sb.append(", ");
20129       sb.append("io:");
20130       if (this.io == null) {
20131         sb.append("null");
20132       } else {
20133         sb.append(this.io);
20134       }
20135       first = false;
20136       sb.append(")");
20137       return sb.toString();
20138     }
20139 
20140     public void validate() throws TException {
20141       // check for required fields
20142     }
20143 
20144   }
20145 
20146   public static class mutateRow_args implements TBase<mutateRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_args>   {
20147     private static final TStruct STRUCT_DESC = new TStruct("mutateRow_args");
20148 
20149     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
20150     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
20151     private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3);
20152 
20153     /**
20154      * name of table
20155      */
20156     public byte[] tableName;
20157     /**
20158      * row key
20159      */
20160     public byte[] row;
20161     /**
20162      * list of mutation commands
20163      */
20164     public List<Mutation> mutations;
20165 
20166     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
20167     public enum _Fields implements TFieldIdEnum {
20168       /**
20169        * name of table
20170        */
20171       TABLE_NAME((short)1, "tableName"),
20172       /**
20173        * row key
20174        */
20175       ROW((short)2, "row"),
20176       /**
20177        * list of mutation commands
20178        */
20179       MUTATIONS((short)3, "mutations");
20180 
20181       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
20182       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
20183 
20184       static {
20185         for (_Fields field : EnumSet.allOf(_Fields.class)) {
20186           byId.put((int)field._thriftId, field);
20187           byName.put(field.getFieldName(), field);
20188         }
20189       }
20190 
20191       /**
20192        * Find the _Fields constant that matches fieldId, or null if its not found.
20193        */
20194       public static _Fields findByThriftId(int fieldId) {
20195         return byId.get(fieldId);
20196       }
20197 
20198       /**
20199        * Find the _Fields constant that matches fieldId, throwing an exception
20200        * if it is not found.
20201        */
20202       public static _Fields findByThriftIdOrThrow(int fieldId) {
20203         _Fields fields = findByThriftId(fieldId);
20204         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
20205         return fields;
20206       }
20207 
20208       /**
20209        * Find the _Fields constant that matches name, or null if its not found.
20210        */
20211       public static _Fields findByName(String name) {
20212         return byName.get(name);
20213       }
20214 
20215       private final short _thriftId;
20216       private final String _fieldName;
20217 
20218       _Fields(short thriftId, String fieldName) {
20219         _thriftId = thriftId;
20220         _fieldName = fieldName;
20221       }
20222 
20223       public short getThriftFieldId() {
20224         return _thriftId;
20225       }
20226 
20227       public String getFieldName() {
20228         return _fieldName;
20229       }
20230     }
20231 
20232     // isset id assignments
20233 
20234     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
20235       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
20236           new FieldValueMetaData(TType.STRING)));
20237       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
20238           new FieldValueMetaData(TType.STRING)));
20239       put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT,
20240           new ListMetaData(TType.LIST,
20241               new StructMetaData(TType.STRUCT, Mutation.class))));
20242     }});
20243 
20244     static {
20245       FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
20246     }
20247 
20248     public mutateRow_args() {
20249     }
20250 
20251     public mutateRow_args(
20252       byte[] tableName,
20253       byte[] row,
20254       List<Mutation> mutations)
20255     {
20256       this();
20257       this.tableName = tableName;
20258       this.row = row;
20259       this.mutations = mutations;
20260     }
20261 
20262     /**
20263      * Performs a deep copy on <i>other</i>.
20264      */
20265     public mutateRow_args(mutateRow_args other) {
20266       if (other.isSetTableName()) {
20267         this.tableName = other.tableName;
20268       }
20269       if (other.isSetRow()) {
20270         this.row = other.row;
20271       }
20272       if (other.isSetMutations()) {
20273         List<Mutation> __this__mutations = new ArrayList<Mutation>();
20274         for (Mutation other_element : other.mutations) {
20275           __this__mutations.add(new Mutation(other_element));
20276         }
20277         this.mutations = __this__mutations;
20278       }
20279     }
20280 
20281     public mutateRow_args deepCopy() {
20282       return new mutateRow_args(this);
20283     }
20284 
20285     @Deprecated
20286     public mutateRow_args clone() {
20287       return new mutateRow_args(this);
20288     }
20289 
20290     /**
20291      * name of table
20292      */
20293     public byte[] getTableName() {
20294       return this.tableName;
20295     }
20296 
20297     /**
20298      * name of table
20299      */
20300     public mutateRow_args setTableName(byte[] tableName) {
20301       this.tableName = tableName;
20302       return this;
20303     }
20304 
20305     public void unsetTableName() {
20306       this.tableName = null;
20307     }
20308 
20309     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
20310     public boolean isSetTableName() {
20311       return this.tableName != null;
20312     }
20313 
20314     public void setTableNameIsSet(boolean value) {
20315       if (!value) {
20316         this.tableName = null;
20317       }
20318     }
20319 
20320     /**
20321      * row key
20322      */
20323     public byte[] getRow() {
20324       return this.row;
20325     }
20326 
20327     /**
20328      * row key
20329      */
20330     public mutateRow_args setRow(byte[] row) {
20331       this.row = row;
20332       return this;
20333     }
20334 
20335     public void unsetRow() {
20336       this.row = null;
20337     }
20338 
20339     /** Returns true if field row is set (has been asigned a value) and false otherwise */
20340     public boolean isSetRow() {
20341       return this.row != null;
20342     }
20343 
20344     public void setRowIsSet(boolean value) {
20345       if (!value) {
20346         this.row = null;
20347       }
20348     }
20349 
20350     public int getMutationsSize() {
20351       return (this.mutations == null) ? 0 : this.mutations.size();
20352     }
20353 
20354     public java.util.Iterator<Mutation> getMutationsIterator() {
20355       return (this.mutations == null) ? null : this.mutations.iterator();
20356     }
20357 
20358     public void addToMutations(Mutation elem) {
20359       if (this.mutations == null) {
20360         this.mutations = new ArrayList<Mutation>();
20361       }
20362       this.mutations.add(elem);
20363     }
20364 
20365     /**
20366      * list of mutation commands
20367      */
20368     public List<Mutation> getMutations() {
20369       return this.mutations;
20370     }
20371 
20372     /**
20373      * list of mutation commands
20374      */
20375     public mutateRow_args setMutations(List<Mutation> mutations) {
20376       this.mutations = mutations;
20377       return this;
20378     }
20379 
20380     public void unsetMutations() {
20381       this.mutations = null;
20382     }
20383 
20384     /** Returns true if field mutations is set (has been asigned a value) and false otherwise */
20385     public boolean isSetMutations() {
20386       return this.mutations != null;
20387     }
20388 
20389     public void setMutationsIsSet(boolean value) {
20390       if (!value) {
20391         this.mutations = null;
20392       }
20393     }
20394 
20395     public void setFieldValue(_Fields field, Object value) {
20396       switch (field) {
20397       case TABLE_NAME:
20398         if (value == null) {
20399           unsetTableName();
20400         } else {
20401           setTableName((byte[])value);
20402         }
20403         break;
20404 
20405       case ROW:
20406         if (value == null) {
20407           unsetRow();
20408         } else {
20409           setRow((byte[])value);
20410         }
20411         break;
20412 
20413       case MUTATIONS:
20414         if (value == null) {
20415           unsetMutations();
20416         } else {
20417           setMutations((List<Mutation>)value);
20418         }
20419         break;
20420 
20421       }
20422     }
20423 
20424     public void setFieldValue(int fieldID, Object value) {
20425       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
20426     }
20427 
20428     public Object getFieldValue(_Fields field) {
20429       switch (field) {
20430       case TABLE_NAME:
20431         return getTableName();
20432 
20433       case ROW:
20434         return getRow();
20435 
20436       case MUTATIONS:
20437         return getMutations();
20438 
20439       }
20440       throw new IllegalStateException();
20441     }
20442 
20443     public Object getFieldValue(int fieldId) {
20444       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
20445     }
20446 
20447     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
20448     public boolean isSet(_Fields field) {
20449       switch (field) {
20450       case TABLE_NAME:
20451         return isSetTableName();
20452       case ROW:
20453         return isSetRow();
20454       case MUTATIONS:
20455         return isSetMutations();
20456       }
20457       throw new IllegalStateException();
20458     }
20459 
20460     public boolean isSet(int fieldID) {
20461       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
20462     }
20463 
20464     @Override
20465     public boolean equals(Object that) {
20466       if (that == null)
20467         return false;
20468       if (that instanceof mutateRow_args)
20469         return this.equals((mutateRow_args)that);
20470       return false;
20471     }
20472 
20473     public boolean equals(mutateRow_args that) {
20474       if (that == null)
20475         return false;
20476 
20477       boolean this_present_tableName = true && this.isSetTableName();
20478       boolean that_present_tableName = true && that.isSetTableName();
20479       if (this_present_tableName || that_present_tableName) {
20480         if (!(this_present_tableName && that_present_tableName))
20481           return false;
20482         if (!java.util.Arrays.equals(this.tableName, that.tableName))
20483           return false;
20484       }
20485 
20486       boolean this_present_row = true && this.isSetRow();
20487       boolean that_present_row = true && that.isSetRow();
20488       if (this_present_row || that_present_row) {
20489         if (!(this_present_row && that_present_row))
20490           return false;
20491         if (!java.util.Arrays.equals(this.row, that.row))
20492           return false;
20493       }
20494 
20495       boolean this_present_mutations = true && this.isSetMutations();
20496       boolean that_present_mutations = true && that.isSetMutations();
20497       if (this_present_mutations || that_present_mutations) {
20498         if (!(this_present_mutations && that_present_mutations))
20499           return false;
20500         if (!this.mutations.equals(that.mutations))
20501           return false;
20502       }
20503 
20504       return true;
20505     }
20506 
20507     @Override
20508     public int hashCode() {
20509       HashCodeBuilder builder = new HashCodeBuilder();
20510 
20511       boolean present_tableName = true && (isSetTableName());
20512       builder.append(present_tableName);
20513       if (present_tableName)
20514         builder.append(tableName);
20515 
20516       boolean present_row = true && (isSetRow());
20517       builder.append(present_row);
20518       if (present_row)
20519         builder.append(row);
20520 
20521       boolean present_mutations = true && (isSetMutations());
20522       builder.append(present_mutations);
20523       if (present_mutations)
20524         builder.append(mutations);
20525 
20526       return builder.toHashCode();
20527     }
20528 
20529     public int compareTo(mutateRow_args other) {
20530       if (!getClass().equals(other.getClass())) {
20531         return getClass().getName().compareTo(other.getClass().getName());
20532       }
20533 
20534       int lastComparison = 0;
20535       mutateRow_args typedOther = (mutateRow_args)other;
20536 
20537       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
20538       if (lastComparison != 0) {
20539         return lastComparison;
20540       }
20541       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
20542       if (lastComparison != 0) {
20543         return lastComparison;
20544       }
20545       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
20546       if (lastComparison != 0) {
20547         return lastComparison;
20548       }
20549       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
20550       if (lastComparison != 0) {
20551         return lastComparison;
20552       }
20553       lastComparison = Boolean.valueOf(isSetMutations()).compareTo(isSetMutations());
20554       if (lastComparison != 0) {
20555         return lastComparison;
20556       }
20557       lastComparison = TBaseHelper.compareTo(mutations, typedOther.mutations);
20558       if (lastComparison != 0) {
20559         return lastComparison;
20560       }
20561       return 0;
20562     }
20563 
20564     public void read(TProtocol iprot) throws TException {
20565       TField field;
20566       iprot.readStructBegin();
20567       while (true)
20568       {
20569         field = iprot.readFieldBegin();
20570         if (field.type == TType.STOP) {
20571           break;
20572         }
20573         _Fields fieldId = _Fields.findByThriftId(field.id);
20574         if (fieldId == null) {
20575           TProtocolUtil.skip(iprot, field.type);
20576         } else {
20577           switch (fieldId) {
20578             case TABLE_NAME:
20579               if (field.type == TType.STRING) {
20580                 this.tableName = iprot.readBinary();
20581               } else {
20582                 TProtocolUtil.skip(iprot, field.type);
20583               }
20584               break;
20585             case ROW:
20586               if (field.type == TType.STRING) {
20587                 this.row = iprot.readBinary();
20588               } else {
20589                 TProtocolUtil.skip(iprot, field.type);
20590               }
20591               break;
20592             case MUTATIONS:
20593               if (field.type == TType.LIST) {
20594                 {
20595                   TList _list102 = iprot.readListBegin();
20596                   this.mutations = new ArrayList<Mutation>(_list102.size);
20597                   for (int _i103 = 0; _i103 < _list102.size; ++_i103)
20598                   {
20599                     Mutation _elem104;
20600                     _elem104 = new Mutation();
20601                     _elem104.read(iprot);
20602                     this.mutations.add(_elem104);
20603                   }
20604                   iprot.readListEnd();
20605                 }
20606               } else {
20607                 TProtocolUtil.skip(iprot, field.type);
20608               }
20609               break;
20610           }
20611           iprot.readFieldEnd();
20612         }
20613       }
20614       iprot.readStructEnd();
20615 
20616       // check for required fields of primitive type, which can't be checked in the validate method
20617       validate();
20618     }
20619 
20620     public void write(TProtocol oprot) throws TException {
20621       validate();
20622 
20623       oprot.writeStructBegin(STRUCT_DESC);
20624       if (this.tableName != null) {
20625         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
20626         oprot.writeBinary(this.tableName);
20627         oprot.writeFieldEnd();
20628       }
20629       if (this.row != null) {
20630         oprot.writeFieldBegin(ROW_FIELD_DESC);
20631         oprot.writeBinary(this.row);
20632         oprot.writeFieldEnd();
20633       }
20634       if (this.mutations != null) {
20635         oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
20636         {
20637           oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size()));
20638           for (Mutation _iter105 : this.mutations)
20639           {
20640             _iter105.write(oprot);
20641           }
20642           oprot.writeListEnd();
20643         }
20644         oprot.writeFieldEnd();
20645       }
20646       oprot.writeFieldStop();
20647       oprot.writeStructEnd();
20648     }
20649 
20650     @Override
20651     public String toString() {
20652       StringBuilder sb = new StringBuilder("mutateRow_args(");
20653       boolean first = true;
20654 
20655       sb.append("tableName:");
20656       if (this.tableName == null) {
20657         sb.append("null");
20658       } else {
20659         sb.append(this.tableName);
20660       }
20661       first = false;
20662       if (!first) sb.append(", ");
20663       sb.append("row:");
20664       if (this.row == null) {
20665         sb.append("null");
20666       } else {
20667         sb.append(this.row);
20668       }
20669       first = false;
20670       if (!first) sb.append(", ");
20671       sb.append("mutations:");
20672       if (this.mutations == null) {
20673         sb.append("null");
20674       } else {
20675         sb.append(this.mutations);
20676       }
20677       first = false;
20678       sb.append(")");
20679       return sb.toString();
20680     }
20681 
20682     public void validate() throws TException {
20683       // check for required fields
20684     }
20685 
20686   }
20687 
20688   public static class mutateRow_result implements TBase<mutateRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_result>   {
20689     private static final TStruct STRUCT_DESC = new TStruct("mutateRow_result");
20690 
20691     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
20692     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
20693 
20694     public IOError io;
20695     public IllegalArgument ia;
20696 
20697     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
20698     public enum _Fields implements TFieldIdEnum {
20699       IO((short)1, "io"),
20700       IA((short)2, "ia");
20701 
20702       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
20703       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
20704 
20705       static {
20706         for (_Fields field : EnumSet.allOf(_Fields.class)) {
20707           byId.put((int)field._thriftId, field);
20708           byName.put(field.getFieldName(), field);
20709         }
20710       }
20711 
20712       /**
20713        * Find the _Fields constant that matches fieldId, or null if its not found.
20714        */
20715       public static _Fields findByThriftId(int fieldId) {
20716         return byId.get(fieldId);
20717       }
20718 
20719       /**
20720        * Find the _Fields constant that matches fieldId, throwing an exception
20721        * if it is not found.
20722        */
20723       public static _Fields findByThriftIdOrThrow(int fieldId) {
20724         _Fields fields = findByThriftId(fieldId);
20725         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
20726         return fields;
20727       }
20728 
20729       /**
20730        * Find the _Fields constant that matches name, or null if its not found.
20731        */
20732       public static _Fields findByName(String name) {
20733         return byName.get(name);
20734       }
20735 
20736       private final short _thriftId;
20737       private final String _fieldName;
20738 
20739       _Fields(short thriftId, String fieldName) {
20740         _thriftId = thriftId;
20741         _fieldName = fieldName;
20742       }
20743 
20744       public short getThriftFieldId() {
20745         return _thriftId;
20746       }
20747 
20748       public String getFieldName() {
20749         return _fieldName;
20750       }
20751     }
20752 
20753     // isset id assignments
20754 
20755     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
20756       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
20757           new FieldValueMetaData(TType.STRUCT)));
20758       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
20759           new FieldValueMetaData(TType.STRUCT)));
20760     }});
20761 
20762     static {
20763       FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap);
20764     }
20765 
20766     public mutateRow_result() {
20767     }
20768 
20769     public mutateRow_result(
20770       IOError io,
20771       IllegalArgument ia)
20772     {
20773       this();
20774       this.io = io;
20775       this.ia = ia;
20776     }
20777 
20778     /**
20779      * Performs a deep copy on <i>other</i>.
20780      */
20781     public mutateRow_result(mutateRow_result other) {
20782       if (other.isSetIo()) {
20783         this.io = new IOError(other.io);
20784       }
20785       if (other.isSetIa()) {
20786         this.ia = new IllegalArgument(other.ia);
20787       }
20788     }
20789 
20790     public mutateRow_result deepCopy() {
20791       return new mutateRow_result(this);
20792     }
20793 
20794     @Deprecated
20795     public mutateRow_result clone() {
20796       return new mutateRow_result(this);
20797     }
20798 
20799     public IOError getIo() {
20800       return this.io;
20801     }
20802 
20803     public mutateRow_result setIo(IOError io) {
20804       this.io = io;
20805       return this;
20806     }
20807 
20808     public void unsetIo() {
20809       this.io = null;
20810     }
20811 
20812     /** Returns true if field io is set (has been asigned a value) and false otherwise */
20813     public boolean isSetIo() {
20814       return this.io != null;
20815     }
20816 
20817     public void setIoIsSet(boolean value) {
20818       if (!value) {
20819         this.io = null;
20820       }
20821     }
20822 
20823     public IllegalArgument getIa() {
20824       return this.ia;
20825     }
20826 
20827     public mutateRow_result setIa(IllegalArgument ia) {
20828       this.ia = ia;
20829       return this;
20830     }
20831 
20832     public void unsetIa() {
20833       this.ia = null;
20834     }
20835 
20836     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
20837     public boolean isSetIa() {
20838       return this.ia != null;
20839     }
20840 
20841     public void setIaIsSet(boolean value) {
20842       if (!value) {
20843         this.ia = null;
20844       }
20845     }
20846 
20847     public void setFieldValue(_Fields field, Object value) {
20848       switch (field) {
20849       case IO:
20850         if (value == null) {
20851           unsetIo();
20852         } else {
20853           setIo((IOError)value);
20854         }
20855         break;
20856 
20857       case IA:
20858         if (value == null) {
20859           unsetIa();
20860         } else {
20861           setIa((IllegalArgument)value);
20862         }
20863         break;
20864 
20865       }
20866     }
20867 
20868     public void setFieldValue(int fieldID, Object value) {
20869       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
20870     }
20871 
20872     public Object getFieldValue(_Fields field) {
20873       switch (field) {
20874       case IO:
20875         return getIo();
20876 
20877       case IA:
20878         return getIa();
20879 
20880       }
20881       throw new IllegalStateException();
20882     }
20883 
20884     public Object getFieldValue(int fieldId) {
20885       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
20886     }
20887 
20888     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
20889     public boolean isSet(_Fields field) {
20890       switch (field) {
20891       case IO:
20892         return isSetIo();
20893       case IA:
20894         return isSetIa();
20895       }
20896       throw new IllegalStateException();
20897     }
20898 
20899     public boolean isSet(int fieldID) {
20900       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
20901     }
20902 
20903     @Override
20904     public boolean equals(Object that) {
20905       if (that == null)
20906         return false;
20907       if (that instanceof mutateRow_result)
20908         return this.equals((mutateRow_result)that);
20909       return false;
20910     }
20911 
20912     public boolean equals(mutateRow_result that) {
20913       if (that == null)
20914         return false;
20915 
20916       boolean this_present_io = true && this.isSetIo();
20917       boolean that_present_io = true && that.isSetIo();
20918       if (this_present_io || that_present_io) {
20919         if (!(this_present_io && that_present_io))
20920           return false;
20921         if (!this.io.equals(that.io))
20922           return false;
20923       }
20924 
20925       boolean this_present_ia = true && this.isSetIa();
20926       boolean that_present_ia = true && that.isSetIa();
20927       if (this_present_ia || that_present_ia) {
20928         if (!(this_present_ia && that_present_ia))
20929           return false;
20930         if (!this.ia.equals(that.ia))
20931           return false;
20932       }
20933 
20934       return true;
20935     }
20936 
20937     @Override
20938     public int hashCode() {
20939       HashCodeBuilder builder = new HashCodeBuilder();
20940 
20941       boolean present_io = true && (isSetIo());
20942       builder.append(present_io);
20943       if (present_io)
20944         builder.append(io);
20945 
20946       boolean present_ia = true && (isSetIa());
20947       builder.append(present_ia);
20948       if (present_ia)
20949         builder.append(ia);
20950 
20951       return builder.toHashCode();
20952     }
20953 
20954     public int compareTo(mutateRow_result other) {
20955       if (!getClass().equals(other.getClass())) {
20956         return getClass().getName().compareTo(other.getClass().getName());
20957       }
20958 
20959       int lastComparison = 0;
20960       mutateRow_result typedOther = (mutateRow_result)other;
20961 
20962       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
20963       if (lastComparison != 0) {
20964         return lastComparison;
20965       }
20966       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
20967       if (lastComparison != 0) {
20968         return lastComparison;
20969       }
20970       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
20971       if (lastComparison != 0) {
20972         return lastComparison;
20973       }
20974       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
20975       if (lastComparison != 0) {
20976         return lastComparison;
20977       }
20978       return 0;
20979     }
20980 
20981     public void read(TProtocol iprot) throws TException {
20982       TField field;
20983       iprot.readStructBegin();
20984       while (true)
20985       {
20986         field = iprot.readFieldBegin();
20987         if (field.type == TType.STOP) {
20988           break;
20989         }
20990         _Fields fieldId = _Fields.findByThriftId(field.id);
20991         if (fieldId == null) {
20992           TProtocolUtil.skip(iprot, field.type);
20993         } else {
20994           switch (fieldId) {
20995             case IO:
20996               if (field.type == TType.STRUCT) {
20997                 this.io = new IOError();
20998                 this.io.read(iprot);
20999               } else {
21000                 TProtocolUtil.skip(iprot, field.type);
21001               }
21002               break;
21003             case IA:
21004               if (field.type == TType.STRUCT) {
21005                 this.ia = new IllegalArgument();
21006                 this.ia.read(iprot);
21007               } else {
21008                 TProtocolUtil.skip(iprot, field.type);
21009               }
21010               break;
21011           }
21012           iprot.readFieldEnd();
21013         }
21014       }
21015       iprot.readStructEnd();
21016 
21017       // check for required fields of primitive type, which can't be checked in the validate method
21018       validate();
21019     }
21020 
21021     public void write(TProtocol oprot) throws TException {
21022       oprot.writeStructBegin(STRUCT_DESC);
21023 
21024       if (this.isSetIo()) {
21025         oprot.writeFieldBegin(IO_FIELD_DESC);
21026         this.io.write(oprot);
21027         oprot.writeFieldEnd();
21028       } else if (this.isSetIa()) {
21029         oprot.writeFieldBegin(IA_FIELD_DESC);
21030         this.ia.write(oprot);
21031         oprot.writeFieldEnd();
21032       }
21033       oprot.writeFieldStop();
21034       oprot.writeStructEnd();
21035     }
21036 
21037     @Override
21038     public String toString() {
21039       StringBuilder sb = new StringBuilder("mutateRow_result(");
21040       boolean first = true;
21041 
21042       sb.append("io:");
21043       if (this.io == null) {
21044         sb.append("null");
21045       } else {
21046         sb.append(this.io);
21047       }
21048       first = false;
21049       if (!first) sb.append(", ");
21050       sb.append("ia:");
21051       if (this.ia == null) {
21052         sb.append("null");
21053       } else {
21054         sb.append(this.ia);
21055       }
21056       first = false;
21057       sb.append(")");
21058       return sb.toString();
21059     }
21060 
21061     public void validate() throws TException {
21062       // check for required fields
21063     }
21064 
21065   }
21066 
21067   public static class mutateRowTs_args implements TBase<mutateRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_args>   {
21068     private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_args");
21069 
21070     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
21071     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
21072     private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3);
21073     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
21074 
21075     /**
21076      * name of table
21077      */
21078     public byte[] tableName;
21079     /**
21080      * row key
21081      */
21082     public byte[] row;
21083     /**
21084      * list of mutation commands
21085      */
21086     public List<Mutation> mutations;
21087     /**
21088      * timestamp
21089      */
21090     public long timestamp;
21091 
21092     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
21093     public enum _Fields implements TFieldIdEnum {
21094       /**
21095        * name of table
21096        */
21097       TABLE_NAME((short)1, "tableName"),
21098       /**
21099        * row key
21100        */
21101       ROW((short)2, "row"),
21102       /**
21103        * list of mutation commands
21104        */
21105       MUTATIONS((short)3, "mutations"),
21106       /**
21107        * timestamp
21108        */
21109       TIMESTAMP((short)4, "timestamp");
21110 
21111       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
21112       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
21113 
21114       static {
21115         for (_Fields field : EnumSet.allOf(_Fields.class)) {
21116           byId.put((int)field._thriftId, field);
21117           byName.put(field.getFieldName(), field);
21118         }
21119       }
21120 
21121       /**
21122        * Find the _Fields constant that matches fieldId, or null if its not found.
21123        */
21124       public static _Fields findByThriftId(int fieldId) {
21125         return byId.get(fieldId);
21126       }
21127 
21128       /**
21129        * Find the _Fields constant that matches fieldId, throwing an exception
21130        * if it is not found.
21131        */
21132       public static _Fields findByThriftIdOrThrow(int fieldId) {
21133         _Fields fields = findByThriftId(fieldId);
21134         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
21135         return fields;
21136       }
21137 
21138       /**
21139        * Find the _Fields constant that matches name, or null if its not found.
21140        */
21141       public static _Fields findByName(String name) {
21142         return byName.get(name);
21143       }
21144 
21145       private final short _thriftId;
21146       private final String _fieldName;
21147 
21148       _Fields(short thriftId, String fieldName) {
21149         _thriftId = thriftId;
21150         _fieldName = fieldName;
21151       }
21152 
21153       public short getThriftFieldId() {
21154         return _thriftId;
21155       }
21156 
21157       public String getFieldName() {
21158         return _fieldName;
21159       }
21160     }
21161 
21162     // isset id assignments
21163     private static final int __TIMESTAMP_ISSET_ID = 0;
21164     private BitSet __isset_bit_vector = new BitSet(1);
21165 
21166     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
21167       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
21168           new FieldValueMetaData(TType.STRING)));
21169       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
21170           new FieldValueMetaData(TType.STRING)));
21171       put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT,
21172           new ListMetaData(TType.LIST,
21173               new StructMetaData(TType.STRUCT, Mutation.class))));
21174       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
21175           new FieldValueMetaData(TType.I64)));
21176     }});
21177 
21178     static {
21179       FieldMetaData.addStructMetaDataMap(mutateRowTs_args.class, metaDataMap);
21180     }
21181 
21182     public mutateRowTs_args() {
21183     }
21184 
21185     public mutateRowTs_args(
21186       byte[] tableName,
21187       byte[] row,
21188       List<Mutation> mutations,
21189       long timestamp)
21190     {
21191       this();
21192       this.tableName = tableName;
21193       this.row = row;
21194       this.mutations = mutations;
21195       this.timestamp = timestamp;
21196       setTimestampIsSet(true);
21197     }
21198 
21199     /**
21200      * Performs a deep copy on <i>other</i>.
21201      */
21202     public mutateRowTs_args(mutateRowTs_args other) {
21203       __isset_bit_vector.clear();
21204       __isset_bit_vector.or(other.__isset_bit_vector);
21205       if (other.isSetTableName()) {
21206         this.tableName = other.tableName;
21207       }
21208       if (other.isSetRow()) {
21209         this.row = other.row;
21210       }
21211       if (other.isSetMutations()) {
21212         List<Mutation> __this__mutations = new ArrayList<Mutation>();
21213         for (Mutation other_element : other.mutations) {
21214           __this__mutations.add(new Mutation(other_element));
21215         }
21216         this.mutations = __this__mutations;
21217       }
21218       this.timestamp = other.timestamp;
21219     }
21220 
21221     public mutateRowTs_args deepCopy() {
21222       return new mutateRowTs_args(this);
21223     }
21224 
21225     @Deprecated
21226     public mutateRowTs_args clone() {
21227       return new mutateRowTs_args(this);
21228     }
21229 
21230     /**
21231      * name of table
21232      */
21233     public byte[] getTableName() {
21234       return this.tableName;
21235     }
21236 
21237     /**
21238      * name of table
21239      */
21240     public mutateRowTs_args setTableName(byte[] tableName) {
21241       this.tableName = tableName;
21242       return this;
21243     }
21244 
21245     public void unsetTableName() {
21246       this.tableName = null;
21247     }
21248 
21249     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
21250     public boolean isSetTableName() {
21251       return this.tableName != null;
21252     }
21253 
21254     public void setTableNameIsSet(boolean value) {
21255       if (!value) {
21256         this.tableName = null;
21257       }
21258     }
21259 
21260     /**
21261      * row key
21262      */
21263     public byte[] getRow() {
21264       return this.row;
21265     }
21266 
21267     /**
21268      * row key
21269      */
21270     public mutateRowTs_args setRow(byte[] row) {
21271       this.row = row;
21272       return this;
21273     }
21274 
21275     public void unsetRow() {
21276       this.row = null;
21277     }
21278 
21279     /** Returns true if field row is set (has been asigned a value) and false otherwise */
21280     public boolean isSetRow() {
21281       return this.row != null;
21282     }
21283 
21284     public void setRowIsSet(boolean value) {
21285       if (!value) {
21286         this.row = null;
21287       }
21288     }
21289 
21290     public int getMutationsSize() {
21291       return (this.mutations == null) ? 0 : this.mutations.size();
21292     }
21293 
21294     public java.util.Iterator<Mutation> getMutationsIterator() {
21295       return (this.mutations == null) ? null : this.mutations.iterator();
21296     }
21297 
21298     public void addToMutations(Mutation elem) {
21299       if (this.mutations == null) {
21300         this.mutations = new ArrayList<Mutation>();
21301       }
21302       this.mutations.add(elem);
21303     }
21304 
21305     /**
21306      * list of mutation commands
21307      */
21308     public List<Mutation> getMutations() {
21309       return this.mutations;
21310     }
21311 
21312     /**
21313      * list of mutation commands
21314      */
21315     public mutateRowTs_args setMutations(List<Mutation> mutations) {
21316       this.mutations = mutations;
21317       return this;
21318     }
21319 
21320     public void unsetMutations() {
21321       this.mutations = null;
21322     }
21323 
21324     /** Returns true if field mutations is set (has been asigned a value) and false otherwise */
21325     public boolean isSetMutations() {
21326       return this.mutations != null;
21327     }
21328 
21329     public void setMutationsIsSet(boolean value) {
21330       if (!value) {
21331         this.mutations = null;
21332       }
21333     }
21334 
21335     /**
21336      * timestamp
21337      */
21338     public long getTimestamp() {
21339       return this.timestamp;
21340     }
21341 
21342     /**
21343      * timestamp
21344      */
21345     public mutateRowTs_args setTimestamp(long timestamp) {
21346       this.timestamp = timestamp;
21347       setTimestampIsSet(true);
21348       return this;
21349     }
21350 
21351     public void unsetTimestamp() {
21352       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
21353     }
21354 
21355     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
21356     public boolean isSetTimestamp() {
21357       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
21358     }
21359 
21360     public void setTimestampIsSet(boolean value) {
21361       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
21362     }
21363 
21364     public void setFieldValue(_Fields field, Object value) {
21365       switch (field) {
21366       case TABLE_NAME:
21367         if (value == null) {
21368           unsetTableName();
21369         } else {
21370           setTableName((byte[])value);
21371         }
21372         break;
21373 
21374       case ROW:
21375         if (value == null) {
21376           unsetRow();
21377         } else {
21378           setRow((byte[])value);
21379         }
21380         break;
21381 
21382       case MUTATIONS:
21383         if (value == null) {
21384           unsetMutations();
21385         } else {
21386           setMutations((List<Mutation>)value);
21387         }
21388         break;
21389 
21390       case TIMESTAMP:
21391         if (value == null) {
21392           unsetTimestamp();
21393         } else {
21394           setTimestamp((Long)value);
21395         }
21396         break;
21397 
21398       }
21399     }
21400 
21401     public void setFieldValue(int fieldID, Object value) {
21402       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21403     }
21404 
21405     public Object getFieldValue(_Fields field) {
21406       switch (field) {
21407       case TABLE_NAME:
21408         return getTableName();
21409 
21410       case ROW:
21411         return getRow();
21412 
21413       case MUTATIONS:
21414         return getMutations();
21415 
21416       case TIMESTAMP:
21417         return new Long(getTimestamp());
21418 
21419       }
21420       throw new IllegalStateException();
21421     }
21422 
21423     public Object getFieldValue(int fieldId) {
21424       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21425     }
21426 
21427     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
21428     public boolean isSet(_Fields field) {
21429       switch (field) {
21430       case TABLE_NAME:
21431         return isSetTableName();
21432       case ROW:
21433         return isSetRow();
21434       case MUTATIONS:
21435         return isSetMutations();
21436       case TIMESTAMP:
21437         return isSetTimestamp();
21438       }
21439       throw new IllegalStateException();
21440     }
21441 
21442     public boolean isSet(int fieldID) {
21443       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21444     }
21445 
21446     @Override
21447     public boolean equals(Object that) {
21448       if (that == null)
21449         return false;
21450       if (that instanceof mutateRowTs_args)
21451         return this.equals((mutateRowTs_args)that);
21452       return false;
21453     }
21454 
21455     public boolean equals(mutateRowTs_args that) {
21456       if (that == null)
21457         return false;
21458 
21459       boolean this_present_tableName = true && this.isSetTableName();
21460       boolean that_present_tableName = true && that.isSetTableName();
21461       if (this_present_tableName || that_present_tableName) {
21462         if (!(this_present_tableName && that_present_tableName))
21463           return false;
21464         if (!java.util.Arrays.equals(this.tableName, that.tableName))
21465           return false;
21466       }
21467 
21468       boolean this_present_row = true && this.isSetRow();
21469       boolean that_present_row = true && that.isSetRow();
21470       if (this_present_row || that_present_row) {
21471         if (!(this_present_row && that_present_row))
21472           return false;
21473         if (!java.util.Arrays.equals(this.row, that.row))
21474           return false;
21475       }
21476 
21477       boolean this_present_mutations = true && this.isSetMutations();
21478       boolean that_present_mutations = true && that.isSetMutations();
21479       if (this_present_mutations || that_present_mutations) {
21480         if (!(this_present_mutations && that_present_mutations))
21481           return false;
21482         if (!this.mutations.equals(that.mutations))
21483           return false;
21484       }
21485 
21486       boolean this_present_timestamp = true;
21487       boolean that_present_timestamp = true;
21488       if (this_present_timestamp || that_present_timestamp) {
21489         if (!(this_present_timestamp && that_present_timestamp))
21490           return false;
21491         if (this.timestamp != that.timestamp)
21492           return false;
21493       }
21494 
21495       return true;
21496     }
21497 
21498     @Override
21499     public int hashCode() {
21500       HashCodeBuilder builder = new HashCodeBuilder();
21501 
21502       boolean present_tableName = true && (isSetTableName());
21503       builder.append(present_tableName);
21504       if (present_tableName)
21505         builder.append(tableName);
21506 
21507       boolean present_row = true && (isSetRow());
21508       builder.append(present_row);
21509       if (present_row)
21510         builder.append(row);
21511 
21512       boolean present_mutations = true && (isSetMutations());
21513       builder.append(present_mutations);
21514       if (present_mutations)
21515         builder.append(mutations);
21516 
21517       boolean present_timestamp = true;
21518       builder.append(present_timestamp);
21519       if (present_timestamp)
21520         builder.append(timestamp);
21521 
21522       return builder.toHashCode();
21523     }
21524 
21525     public int compareTo(mutateRowTs_args other) {
21526       if (!getClass().equals(other.getClass())) {
21527         return getClass().getName().compareTo(other.getClass().getName());
21528       }
21529 
21530       int lastComparison = 0;
21531       mutateRowTs_args typedOther = (mutateRowTs_args)other;
21532 
21533       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
21534       if (lastComparison != 0) {
21535         return lastComparison;
21536       }
21537       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
21538       if (lastComparison != 0) {
21539         return lastComparison;
21540       }
21541       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
21542       if (lastComparison != 0) {
21543         return lastComparison;
21544       }
21545       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
21546       if (lastComparison != 0) {
21547         return lastComparison;
21548       }
21549       lastComparison = Boolean.valueOf(isSetMutations()).compareTo(isSetMutations());
21550       if (lastComparison != 0) {
21551         return lastComparison;
21552       }
21553       lastComparison = TBaseHelper.compareTo(mutations, typedOther.mutations);
21554       if (lastComparison != 0) {
21555         return lastComparison;
21556       }
21557       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
21558       if (lastComparison != 0) {
21559         return lastComparison;
21560       }
21561       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
21562       if (lastComparison != 0) {
21563         return lastComparison;
21564       }
21565       return 0;
21566     }
21567 
21568     public void read(TProtocol iprot) throws TException {
21569       TField field;
21570       iprot.readStructBegin();
21571       while (true)
21572       {
21573         field = iprot.readFieldBegin();
21574         if (field.type == TType.STOP) {
21575           break;
21576         }
21577         _Fields fieldId = _Fields.findByThriftId(field.id);
21578         if (fieldId == null) {
21579           TProtocolUtil.skip(iprot, field.type);
21580         } else {
21581           switch (fieldId) {
21582             case TABLE_NAME:
21583               if (field.type == TType.STRING) {
21584                 this.tableName = iprot.readBinary();
21585               } else {
21586                 TProtocolUtil.skip(iprot, field.type);
21587               }
21588               break;
21589             case ROW:
21590               if (field.type == TType.STRING) {
21591                 this.row = iprot.readBinary();
21592               } else {
21593                 TProtocolUtil.skip(iprot, field.type);
21594               }
21595               break;
21596             case MUTATIONS:
21597               if (field.type == TType.LIST) {
21598                 {
21599                   TList _list106 = iprot.readListBegin();
21600                   this.mutations = new ArrayList<Mutation>(_list106.size);
21601                   for (int _i107 = 0; _i107 < _list106.size; ++_i107)
21602                   {
21603                     Mutation _elem108;
21604                     _elem108 = new Mutation();
21605                     _elem108.read(iprot);
21606                     this.mutations.add(_elem108);
21607                   }
21608                   iprot.readListEnd();
21609                 }
21610               } else {
21611                 TProtocolUtil.skip(iprot, field.type);
21612               }
21613               break;
21614             case TIMESTAMP:
21615               if (field.type == TType.I64) {
21616                 this.timestamp = iprot.readI64();
21617                 setTimestampIsSet(true);
21618               } else {
21619                 TProtocolUtil.skip(iprot, field.type);
21620               }
21621               break;
21622           }
21623           iprot.readFieldEnd();
21624         }
21625       }
21626       iprot.readStructEnd();
21627 
21628       // check for required fields of primitive type, which can't be checked in the validate method
21629       validate();
21630     }
21631 
21632     public void write(TProtocol oprot) throws TException {
21633       validate();
21634 
21635       oprot.writeStructBegin(STRUCT_DESC);
21636       if (this.tableName != null) {
21637         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
21638         oprot.writeBinary(this.tableName);
21639         oprot.writeFieldEnd();
21640       }
21641       if (this.row != null) {
21642         oprot.writeFieldBegin(ROW_FIELD_DESC);
21643         oprot.writeBinary(this.row);
21644         oprot.writeFieldEnd();
21645       }
21646       if (this.mutations != null) {
21647         oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
21648         {
21649           oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size()));
21650           for (Mutation _iter109 : this.mutations)
21651           {
21652             _iter109.write(oprot);
21653           }
21654           oprot.writeListEnd();
21655         }
21656         oprot.writeFieldEnd();
21657       }
21658       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
21659       oprot.writeI64(this.timestamp);
21660       oprot.writeFieldEnd();
21661       oprot.writeFieldStop();
21662       oprot.writeStructEnd();
21663     }
21664 
21665     @Override
21666     public String toString() {
21667       StringBuilder sb = new StringBuilder("mutateRowTs_args(");
21668       boolean first = true;
21669 
21670       sb.append("tableName:");
21671       if (this.tableName == null) {
21672         sb.append("null");
21673       } else {
21674         sb.append(this.tableName);
21675       }
21676       first = false;
21677       if (!first) sb.append(", ");
21678       sb.append("row:");
21679       if (this.row == null) {
21680         sb.append("null");
21681       } else {
21682         sb.append(this.row);
21683       }
21684       first = false;
21685       if (!first) sb.append(", ");
21686       sb.append("mutations:");
21687       if (this.mutations == null) {
21688         sb.append("null");
21689       } else {
21690         sb.append(this.mutations);
21691       }
21692       first = false;
21693       if (!first) sb.append(", ");
21694       sb.append("timestamp:");
21695       sb.append(this.timestamp);
21696       first = false;
21697       sb.append(")");
21698       return sb.toString();
21699     }
21700 
21701     public void validate() throws TException {
21702       // check for required fields
21703     }
21704 
21705   }
21706 
21707   public static class mutateRowTs_result implements TBase<mutateRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_result>   {
21708     private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_result");
21709 
21710     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
21711     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
21712 
21713     public IOError io;
21714     public IllegalArgument ia;
21715 
21716     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
21717     public enum _Fields implements TFieldIdEnum {
21718       IO((short)1, "io"),
21719       IA((short)2, "ia");
21720 
21721       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
21722       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
21723 
21724       static {
21725         for (_Fields field : EnumSet.allOf(_Fields.class)) {
21726           byId.put((int)field._thriftId, field);
21727           byName.put(field.getFieldName(), field);
21728         }
21729       }
21730 
21731       /**
21732        * Find the _Fields constant that matches fieldId, or null if its not found.
21733        */
21734       public static _Fields findByThriftId(int fieldId) {
21735         return byId.get(fieldId);
21736       }
21737 
21738       /**
21739        * Find the _Fields constant that matches fieldId, throwing an exception
21740        * if it is not found.
21741        */
21742       public static _Fields findByThriftIdOrThrow(int fieldId) {
21743         _Fields fields = findByThriftId(fieldId);
21744         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
21745         return fields;
21746       }
21747 
21748       /**
21749        * Find the _Fields constant that matches name, or null if its not found.
21750        */
21751       public static _Fields findByName(String name) {
21752         return byName.get(name);
21753       }
21754 
21755       private final short _thriftId;
21756       private final String _fieldName;
21757 
21758       _Fields(short thriftId, String fieldName) {
21759         _thriftId = thriftId;
21760         _fieldName = fieldName;
21761       }
21762 
21763       public short getThriftFieldId() {
21764         return _thriftId;
21765       }
21766 
21767       public String getFieldName() {
21768         return _fieldName;
21769       }
21770     }
21771 
21772     // isset id assignments
21773 
21774     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
21775       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
21776           new FieldValueMetaData(TType.STRUCT)));
21777       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
21778           new FieldValueMetaData(TType.STRUCT)));
21779     }});
21780 
21781     static {
21782       FieldMetaData.addStructMetaDataMap(mutateRowTs_result.class, metaDataMap);
21783     }
21784 
21785     public mutateRowTs_result() {
21786     }
21787 
21788     public mutateRowTs_result(
21789       IOError io,
21790       IllegalArgument ia)
21791     {
21792       this();
21793       this.io = io;
21794       this.ia = ia;
21795     }
21796 
21797     /**
21798      * Performs a deep copy on <i>other</i>.
21799      */
21800     public mutateRowTs_result(mutateRowTs_result other) {
21801       if (other.isSetIo()) {
21802         this.io = new IOError(other.io);
21803       }
21804       if (other.isSetIa()) {
21805         this.ia = new IllegalArgument(other.ia);
21806       }
21807     }
21808 
21809     public mutateRowTs_result deepCopy() {
21810       return new mutateRowTs_result(this);
21811     }
21812 
21813     @Deprecated
21814     public mutateRowTs_result clone() {
21815       return new mutateRowTs_result(this);
21816     }
21817 
21818     public IOError getIo() {
21819       return this.io;
21820     }
21821 
21822     public mutateRowTs_result setIo(IOError io) {
21823       this.io = io;
21824       return this;
21825     }
21826 
21827     public void unsetIo() {
21828       this.io = null;
21829     }
21830 
21831     /** Returns true if field io is set (has been asigned a value) and false otherwise */
21832     public boolean isSetIo() {
21833       return this.io != null;
21834     }
21835 
21836     public void setIoIsSet(boolean value) {
21837       if (!value) {
21838         this.io = null;
21839       }
21840     }
21841 
21842     public IllegalArgument getIa() {
21843       return this.ia;
21844     }
21845 
21846     public mutateRowTs_result setIa(IllegalArgument ia) {
21847       this.ia = ia;
21848       return this;
21849     }
21850 
21851     public void unsetIa() {
21852       this.ia = null;
21853     }
21854 
21855     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
21856     public boolean isSetIa() {
21857       return this.ia != null;
21858     }
21859 
21860     public void setIaIsSet(boolean value) {
21861       if (!value) {
21862         this.ia = null;
21863       }
21864     }
21865 
21866     public void setFieldValue(_Fields field, Object value) {
21867       switch (field) {
21868       case IO:
21869         if (value == null) {
21870           unsetIo();
21871         } else {
21872           setIo((IOError)value);
21873         }
21874         break;
21875 
21876       case IA:
21877         if (value == null) {
21878           unsetIa();
21879         } else {
21880           setIa((IllegalArgument)value);
21881         }
21882         break;
21883 
21884       }
21885     }
21886 
21887     public void setFieldValue(int fieldID, Object value) {
21888       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21889     }
21890 
21891     public Object getFieldValue(_Fields field) {
21892       switch (field) {
21893       case IO:
21894         return getIo();
21895 
21896       case IA:
21897         return getIa();
21898 
21899       }
21900       throw new IllegalStateException();
21901     }
21902 
21903     public Object getFieldValue(int fieldId) {
21904       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21905     }
21906 
21907     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
21908     public boolean isSet(_Fields field) {
21909       switch (field) {
21910       case IO:
21911         return isSetIo();
21912       case IA:
21913         return isSetIa();
21914       }
21915       throw new IllegalStateException();
21916     }
21917 
21918     public boolean isSet(int fieldID) {
21919       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21920     }
21921 
21922     @Override
21923     public boolean equals(Object that) {
21924       if (that == null)
21925         return false;
21926       if (that instanceof mutateRowTs_result)
21927         return this.equals((mutateRowTs_result)that);
21928       return false;
21929     }
21930 
21931     public boolean equals(mutateRowTs_result that) {
21932       if (that == null)
21933         return false;
21934 
21935       boolean this_present_io = true && this.isSetIo();
21936       boolean that_present_io = true && that.isSetIo();
21937       if (this_present_io || that_present_io) {
21938         if (!(this_present_io && that_present_io))
21939           return false;
21940         if (!this.io.equals(that.io))
21941           return false;
21942       }
21943 
21944       boolean this_present_ia = true && this.isSetIa();
21945       boolean that_present_ia = true && that.isSetIa();
21946       if (this_present_ia || that_present_ia) {
21947         if (!(this_present_ia && that_present_ia))
21948           return false;
21949         if (!this.ia.equals(that.ia))
21950           return false;
21951       }
21952 
21953       return true;
21954     }
21955 
21956     @Override
21957     public int hashCode() {
21958       HashCodeBuilder builder = new HashCodeBuilder();
21959 
21960       boolean present_io = true && (isSetIo());
21961       builder.append(present_io);
21962       if (present_io)
21963         builder.append(io);
21964 
21965       boolean present_ia = true && (isSetIa());
21966       builder.append(present_ia);
21967       if (present_ia)
21968         builder.append(ia);
21969 
21970       return builder.toHashCode();
21971     }
21972 
21973     public int compareTo(mutateRowTs_result other) {
21974       if (!getClass().equals(other.getClass())) {
21975         return getClass().getName().compareTo(other.getClass().getName());
21976       }
21977 
21978       int lastComparison = 0;
21979       mutateRowTs_result typedOther = (mutateRowTs_result)other;
21980 
21981       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
21982       if (lastComparison != 0) {
21983         return lastComparison;
21984       }
21985       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
21986       if (lastComparison != 0) {
21987         return lastComparison;
21988       }
21989       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
21990       if (lastComparison != 0) {
21991         return lastComparison;
21992       }
21993       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
21994       if (lastComparison != 0) {
21995         return lastComparison;
21996       }
21997       return 0;
21998     }
21999 
22000     public void read(TProtocol iprot) throws TException {
22001       TField field;
22002       iprot.readStructBegin();
22003       while (true)
22004       {
22005         field = iprot.readFieldBegin();
22006         if (field.type == TType.STOP) {
22007           break;
22008         }
22009         _Fields fieldId = _Fields.findByThriftId(field.id);
22010         if (fieldId == null) {
22011           TProtocolUtil.skip(iprot, field.type);
22012         } else {
22013           switch (fieldId) {
22014             case IO:
22015               if (field.type == TType.STRUCT) {
22016                 this.io = new IOError();
22017                 this.io.read(iprot);
22018               } else {
22019                 TProtocolUtil.skip(iprot, field.type);
22020               }
22021               break;
22022             case IA:
22023               if (field.type == TType.STRUCT) {
22024                 this.ia = new IllegalArgument();
22025                 this.ia.read(iprot);
22026               } else {
22027                 TProtocolUtil.skip(iprot, field.type);
22028               }
22029               break;
22030           }
22031           iprot.readFieldEnd();
22032         }
22033       }
22034       iprot.readStructEnd();
22035 
22036       // check for required fields of primitive type, which can't be checked in the validate method
22037       validate();
22038     }
22039 
22040     public void write(TProtocol oprot) throws TException {
22041       oprot.writeStructBegin(STRUCT_DESC);
22042 
22043       if (this.isSetIo()) {
22044         oprot.writeFieldBegin(IO_FIELD_DESC);
22045         this.io.write(oprot);
22046         oprot.writeFieldEnd();
22047       } else if (this.isSetIa()) {
22048         oprot.writeFieldBegin(IA_FIELD_DESC);
22049         this.ia.write(oprot);
22050         oprot.writeFieldEnd();
22051       }
22052       oprot.writeFieldStop();
22053       oprot.writeStructEnd();
22054     }
22055 
22056     @Override
22057     public String toString() {
22058       StringBuilder sb = new StringBuilder("mutateRowTs_result(");
22059       boolean first = true;
22060 
22061       sb.append("io:");
22062       if (this.io == null) {
22063         sb.append("null");
22064       } else {
22065         sb.append(this.io);
22066       }
22067       first = false;
22068       if (!first) sb.append(", ");
22069       sb.append("ia:");
22070       if (this.ia == null) {
22071         sb.append("null");
22072       } else {
22073         sb.append(this.ia);
22074       }
22075       first = false;
22076       sb.append(")");
22077       return sb.toString();
22078     }
22079 
22080     public void validate() throws TException {
22081       // check for required fields
22082     }
22083 
22084   }
22085 
22086   public static class mutateRows_args implements TBase<mutateRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_args>   {
22087     private static final TStruct STRUCT_DESC = new TStruct("mutateRows_args");
22088 
22089     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
22090     private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2);
22091 
22092     /**
22093      * name of table
22094      */
22095     public byte[] tableName;
22096     /**
22097      * list of row batches
22098      */
22099     public List<BatchMutation> rowBatches;
22100 
22101     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
22102     public enum _Fields implements TFieldIdEnum {
22103       /**
22104        * name of table
22105        */
22106       TABLE_NAME((short)1, "tableName"),
22107       /**
22108        * list of row batches
22109        */
22110       ROW_BATCHES((short)2, "rowBatches");
22111 
22112       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22113       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22114 
22115       static {
22116         for (_Fields field : EnumSet.allOf(_Fields.class)) {
22117           byId.put((int)field._thriftId, field);
22118           byName.put(field.getFieldName(), field);
22119         }
22120       }
22121 
22122       /**
22123        * Find the _Fields constant that matches fieldId, or null if its not found.
22124        */
22125       public static _Fields findByThriftId(int fieldId) {
22126         return byId.get(fieldId);
22127       }
22128 
22129       /**
22130        * Find the _Fields constant that matches fieldId, throwing an exception
22131        * if it is not found.
22132        */
22133       public static _Fields findByThriftIdOrThrow(int fieldId) {
22134         _Fields fields = findByThriftId(fieldId);
22135         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22136         return fields;
22137       }
22138 
22139       /**
22140        * Find the _Fields constant that matches name, or null if its not found.
22141        */
22142       public static _Fields findByName(String name) {
22143         return byName.get(name);
22144       }
22145 
22146       private final short _thriftId;
22147       private final String _fieldName;
22148 
22149       _Fields(short thriftId, String fieldName) {
22150         _thriftId = thriftId;
22151         _fieldName = fieldName;
22152       }
22153 
22154       public short getThriftFieldId() {
22155         return _thriftId;
22156       }
22157 
22158       public String getFieldName() {
22159         return _fieldName;
22160       }
22161     }
22162 
22163     // isset id assignments
22164 
22165     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22166       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
22167           new FieldValueMetaData(TType.STRING)));
22168       put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT,
22169           new ListMetaData(TType.LIST,
22170               new StructMetaData(TType.STRUCT, BatchMutation.class))));
22171     }});
22172 
22173     static {
22174       FieldMetaData.addStructMetaDataMap(mutateRows_args.class, metaDataMap);
22175     }
22176 
22177     public mutateRows_args() {
22178     }
22179 
22180     public mutateRows_args(
22181       byte[] tableName,
22182       List<BatchMutation> rowBatches)
22183     {
22184       this();
22185       this.tableName = tableName;
22186       this.rowBatches = rowBatches;
22187     }
22188 
22189     /**
22190      * Performs a deep copy on <i>other</i>.
22191      */
22192     public mutateRows_args(mutateRows_args other) {
22193       if (other.isSetTableName()) {
22194         this.tableName = other.tableName;
22195       }
22196       if (other.isSetRowBatches()) {
22197         List<BatchMutation> __this__rowBatches = new ArrayList<BatchMutation>();
22198         for (BatchMutation other_element : other.rowBatches) {
22199           __this__rowBatches.add(new BatchMutation(other_element));
22200         }
22201         this.rowBatches = __this__rowBatches;
22202       }
22203     }
22204 
22205     public mutateRows_args deepCopy() {
22206       return new mutateRows_args(this);
22207     }
22208 
22209     @Deprecated
22210     public mutateRows_args clone() {
22211       return new mutateRows_args(this);
22212     }
22213 
22214     /**
22215      * name of table
22216      */
22217     public byte[] getTableName() {
22218       return this.tableName;
22219     }
22220 
22221     /**
22222      * name of table
22223      */
22224     public mutateRows_args setTableName(byte[] tableName) {
22225       this.tableName = tableName;
22226       return this;
22227     }
22228 
22229     public void unsetTableName() {
22230       this.tableName = null;
22231     }
22232 
22233     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
22234     public boolean isSetTableName() {
22235       return this.tableName != null;
22236     }
22237 
22238     public void setTableNameIsSet(boolean value) {
22239       if (!value) {
22240         this.tableName = null;
22241       }
22242     }
22243 
22244     public int getRowBatchesSize() {
22245       return (this.rowBatches == null) ? 0 : this.rowBatches.size();
22246     }
22247 
22248     public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
22249       return (this.rowBatches == null) ? null : this.rowBatches.iterator();
22250     }
22251 
22252     public void addToRowBatches(BatchMutation elem) {
22253       if (this.rowBatches == null) {
22254         this.rowBatches = new ArrayList<BatchMutation>();
22255       }
22256       this.rowBatches.add(elem);
22257     }
22258 
22259     /**
22260      * list of row batches
22261      */
22262     public List<BatchMutation> getRowBatches() {
22263       return this.rowBatches;
22264     }
22265 
22266     /**
22267      * list of row batches
22268      */
22269     public mutateRows_args setRowBatches(List<BatchMutation> rowBatches) {
22270       this.rowBatches = rowBatches;
22271       return this;
22272     }
22273 
22274     public void unsetRowBatches() {
22275       this.rowBatches = null;
22276     }
22277 
22278     /** Returns true if field rowBatches is set (has been asigned a value) and false otherwise */
22279     public boolean isSetRowBatches() {
22280       return this.rowBatches != null;
22281     }
22282 
22283     public void setRowBatchesIsSet(boolean value) {
22284       if (!value) {
22285         this.rowBatches = null;
22286       }
22287     }
22288 
22289     public void setFieldValue(_Fields field, Object value) {
22290       switch (field) {
22291       case TABLE_NAME:
22292         if (value == null) {
22293           unsetTableName();
22294         } else {
22295           setTableName((byte[])value);
22296         }
22297         break;
22298 
22299       case ROW_BATCHES:
22300         if (value == null) {
22301           unsetRowBatches();
22302         } else {
22303           setRowBatches((List<BatchMutation>)value);
22304         }
22305         break;
22306 
22307       }
22308     }
22309 
22310     public void setFieldValue(int fieldID, Object value) {
22311       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
22312     }
22313 
22314     public Object getFieldValue(_Fields field) {
22315       switch (field) {
22316       case TABLE_NAME:
22317         return getTableName();
22318 
22319       case ROW_BATCHES:
22320         return getRowBatches();
22321 
22322       }
22323       throw new IllegalStateException();
22324     }
22325 
22326     public Object getFieldValue(int fieldId) {
22327       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
22328     }
22329 
22330     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
22331     public boolean isSet(_Fields field) {
22332       switch (field) {
22333       case TABLE_NAME:
22334         return isSetTableName();
22335       case ROW_BATCHES:
22336         return isSetRowBatches();
22337       }
22338       throw new IllegalStateException();
22339     }
22340 
22341     public boolean isSet(int fieldID) {
22342       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
22343     }
22344 
22345     @Override
22346     public boolean equals(Object that) {
22347       if (that == null)
22348         return false;
22349       if (that instanceof mutateRows_args)
22350         return this.equals((mutateRows_args)that);
22351       return false;
22352     }
22353 
22354     public boolean equals(mutateRows_args that) {
22355       if (that == null)
22356         return false;
22357 
22358       boolean this_present_tableName = true && this.isSetTableName();
22359       boolean that_present_tableName = true && that.isSetTableName();
22360       if (this_present_tableName || that_present_tableName) {
22361         if (!(this_present_tableName && that_present_tableName))
22362           return false;
22363         if (!java.util.Arrays.equals(this.tableName, that.tableName))
22364           return false;
22365       }
22366 
22367       boolean this_present_rowBatches = true && this.isSetRowBatches();
22368       boolean that_present_rowBatches = true && that.isSetRowBatches();
22369       if (this_present_rowBatches || that_present_rowBatches) {
22370         if (!(this_present_rowBatches && that_present_rowBatches))
22371           return false;
22372         if (!this.rowBatches.equals(that.rowBatches))
22373           return false;
22374       }
22375 
22376       return true;
22377     }
22378 
22379     @Override
22380     public int hashCode() {
22381       HashCodeBuilder builder = new HashCodeBuilder();
22382 
22383       boolean present_tableName = true && (isSetTableName());
22384       builder.append(present_tableName);
22385       if (present_tableName)
22386         builder.append(tableName);
22387 
22388       boolean present_rowBatches = true && (isSetRowBatches());
22389       builder.append(present_rowBatches);
22390       if (present_rowBatches)
22391         builder.append(rowBatches);
22392 
22393       return builder.toHashCode();
22394     }
22395 
22396     public int compareTo(mutateRows_args other) {
22397       if (!getClass().equals(other.getClass())) {
22398         return getClass().getName().compareTo(other.getClass().getName());
22399       }
22400 
22401       int lastComparison = 0;
22402       mutateRows_args typedOther = (mutateRows_args)other;
22403 
22404       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
22405       if (lastComparison != 0) {
22406         return lastComparison;
22407       }
22408       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
22409       if (lastComparison != 0) {
22410         return lastComparison;
22411       }
22412       lastComparison = Boolean.valueOf(isSetRowBatches()).compareTo(isSetRowBatches());
22413       if (lastComparison != 0) {
22414         return lastComparison;
22415       }
22416       lastComparison = TBaseHelper.compareTo(rowBatches, typedOther.rowBatches);
22417       if (lastComparison != 0) {
22418         return lastComparison;
22419       }
22420       return 0;
22421     }
22422 
22423     public void read(TProtocol iprot) throws TException {
22424       TField field;
22425       iprot.readStructBegin();
22426       while (true)
22427       {
22428         field = iprot.readFieldBegin();
22429         if (field.type == TType.STOP) {
22430           break;
22431         }
22432         _Fields fieldId = _Fields.findByThriftId(field.id);
22433         if (fieldId == null) {
22434           TProtocolUtil.skip(iprot, field.type);
22435         } else {
22436           switch (fieldId) {
22437             case TABLE_NAME:
22438               if (field.type == TType.STRING) {
22439                 this.tableName = iprot.readBinary();
22440               } else {
22441                 TProtocolUtil.skip(iprot, field.type);
22442               }
22443               break;
22444             case ROW_BATCHES:
22445               if (field.type == TType.LIST) {
22446                 {
22447                   TList _list110 = iprot.readListBegin();
22448                   this.rowBatches = new ArrayList<BatchMutation>(_list110.size);
22449                   for (int _i111 = 0; _i111 < _list110.size; ++_i111)
22450                   {
22451                     BatchMutation _elem112;
22452                     _elem112 = new BatchMutation();
22453                     _elem112.read(iprot);
22454                     this.rowBatches.add(_elem112);
22455                   }
22456                   iprot.readListEnd();
22457                 }
22458               } else {
22459                 TProtocolUtil.skip(iprot, field.type);
22460               }
22461               break;
22462           }
22463           iprot.readFieldEnd();
22464         }
22465       }
22466       iprot.readStructEnd();
22467 
22468       // check for required fields of primitive type, which can't be checked in the validate method
22469       validate();
22470     }
22471 
22472     public void write(TProtocol oprot) throws TException {
22473       validate();
22474 
22475       oprot.writeStructBegin(STRUCT_DESC);
22476       if (this.tableName != null) {
22477         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
22478         oprot.writeBinary(this.tableName);
22479         oprot.writeFieldEnd();
22480       }
22481       if (this.rowBatches != null) {
22482         oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
22483         {
22484           oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size()));
22485           for (BatchMutation _iter113 : this.rowBatches)
22486           {
22487             _iter113.write(oprot);
22488           }
22489           oprot.writeListEnd();
22490         }
22491         oprot.writeFieldEnd();
22492       }
22493       oprot.writeFieldStop();
22494       oprot.writeStructEnd();
22495     }
22496 
22497     @Override
22498     public String toString() {
22499       StringBuilder sb = new StringBuilder("mutateRows_args(");
22500       boolean first = true;
22501 
22502       sb.append("tableName:");
22503       if (this.tableName == null) {
22504         sb.append("null");
22505       } else {
22506         sb.append(this.tableName);
22507       }
22508       first = false;
22509       if (!first) sb.append(", ");
22510       sb.append("rowBatches:");
22511       if (this.rowBatches == null) {
22512         sb.append("null");
22513       } else {
22514         sb.append(this.rowBatches);
22515       }
22516       first = false;
22517       sb.append(")");
22518       return sb.toString();
22519     }
22520 
22521     public void validate() throws TException {
22522       // check for required fields
22523     }
22524 
22525   }
22526 
22527   public static class mutateRows_result implements TBase<mutateRows_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_result>   {
22528     private static final TStruct STRUCT_DESC = new TStruct("mutateRows_result");
22529 
22530     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
22531     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
22532 
22533     public IOError io;
22534     public IllegalArgument ia;
22535 
22536     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
22537     public enum _Fields implements TFieldIdEnum {
22538       IO((short)1, "io"),
22539       IA((short)2, "ia");
22540 
22541       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22542       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22543 
22544       static {
22545         for (_Fields field : EnumSet.allOf(_Fields.class)) {
22546           byId.put((int)field._thriftId, field);
22547           byName.put(field.getFieldName(), field);
22548         }
22549       }
22550 
22551       /**
22552        * Find the _Fields constant that matches fieldId, or null if its not found.
22553        */
22554       public static _Fields findByThriftId(int fieldId) {
22555         return byId.get(fieldId);
22556       }
22557 
22558       /**
22559        * Find the _Fields constant that matches fieldId, throwing an exception
22560        * if it is not found.
22561        */
22562       public static _Fields findByThriftIdOrThrow(int fieldId) {
22563         _Fields fields = findByThriftId(fieldId);
22564         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22565         return fields;
22566       }
22567 
22568       /**
22569        * Find the _Fields constant that matches name, or null if its not found.
22570        */
22571       public static _Fields findByName(String name) {
22572         return byName.get(name);
22573       }
22574 
22575       private final short _thriftId;
22576       private final String _fieldName;
22577 
22578       _Fields(short thriftId, String fieldName) {
22579         _thriftId = thriftId;
22580         _fieldName = fieldName;
22581       }
22582 
22583       public short getThriftFieldId() {
22584         return _thriftId;
22585       }
22586 
22587       public String getFieldName() {
22588         return _fieldName;
22589       }
22590     }
22591 
22592     // isset id assignments
22593 
22594     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22595       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
22596           new FieldValueMetaData(TType.STRUCT)));
22597       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
22598           new FieldValueMetaData(TType.STRUCT)));
22599     }});
22600 
22601     static {
22602       FieldMetaData.addStructMetaDataMap(mutateRows_result.class, metaDataMap);
22603     }
22604 
22605     public mutateRows_result() {
22606     }
22607 
22608     public mutateRows_result(
22609       IOError io,
22610       IllegalArgument ia)
22611     {
22612       this();
22613       this.io = io;
22614       this.ia = ia;
22615     }
22616 
22617     /**
22618      * Performs a deep copy on <i>other</i>.
22619      */
22620     public mutateRows_result(mutateRows_result other) {
22621       if (other.isSetIo()) {
22622         this.io = new IOError(other.io);
22623       }
22624       if (other.isSetIa()) {
22625         this.ia = new IllegalArgument(other.ia);
22626       }
22627     }
22628 
22629     public mutateRows_result deepCopy() {
22630       return new mutateRows_result(this);
22631     }
22632 
22633     @Deprecated
22634     public mutateRows_result clone() {
22635       return new mutateRows_result(this);
22636     }
22637 
22638     public IOError getIo() {
22639       return this.io;
22640     }
22641 
22642     public mutateRows_result setIo(IOError io) {
22643       this.io = io;
22644       return this;
22645     }
22646 
22647     public void unsetIo() {
22648       this.io = null;
22649     }
22650 
22651     /** Returns true if field io is set (has been asigned a value) and false otherwise */
22652     public boolean isSetIo() {
22653       return this.io != null;
22654     }
22655 
22656     public void setIoIsSet(boolean value) {
22657       if (!value) {
22658         this.io = null;
22659       }
22660     }
22661 
22662     public IllegalArgument getIa() {
22663       return this.ia;
22664     }
22665 
22666     public mutateRows_result setIa(IllegalArgument ia) {
22667       this.ia = ia;
22668       return this;
22669     }
22670 
22671     public void unsetIa() {
22672       this.ia = null;
22673     }
22674 
22675     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
22676     public boolean isSetIa() {
22677       return this.ia != null;
22678     }
22679 
22680     public void setIaIsSet(boolean value) {
22681       if (!value) {
22682         this.ia = null;
22683       }
22684     }
22685 
22686     public void setFieldValue(_Fields field, Object value) {
22687       switch (field) {
22688       case IO:
22689         if (value == null) {
22690           unsetIo();
22691         } else {
22692           setIo((IOError)value);
22693         }
22694         break;
22695 
22696       case IA:
22697         if (value == null) {
22698           unsetIa();
22699         } else {
22700           setIa((IllegalArgument)value);
22701         }
22702         break;
22703 
22704       }
22705     }
22706 
22707     public void setFieldValue(int fieldID, Object value) {
22708       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
22709     }
22710 
22711     public Object getFieldValue(_Fields field) {
22712       switch (field) {
22713       case IO:
22714         return getIo();
22715 
22716       case IA:
22717         return getIa();
22718 
22719       }
22720       throw new IllegalStateException();
22721     }
22722 
22723     public Object getFieldValue(int fieldId) {
22724       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
22725     }
22726 
22727     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
22728     public boolean isSet(_Fields field) {
22729       switch (field) {
22730       case IO:
22731         return isSetIo();
22732       case IA:
22733         return isSetIa();
22734       }
22735       throw new IllegalStateException();
22736     }
22737 
22738     public boolean isSet(int fieldID) {
22739       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
22740     }
22741 
22742     @Override
22743     public boolean equals(Object that) {
22744       if (that == null)
22745         return false;
22746       if (that instanceof mutateRows_result)
22747         return this.equals((mutateRows_result)that);
22748       return false;
22749     }
22750 
22751     public boolean equals(mutateRows_result that) {
22752       if (that == null)
22753         return false;
22754 
22755       boolean this_present_io = true && this.isSetIo();
22756       boolean that_present_io = true && that.isSetIo();
22757       if (this_present_io || that_present_io) {
22758         if (!(this_present_io && that_present_io))
22759           return false;
22760         if (!this.io.equals(that.io))
22761           return false;
22762       }
22763 
22764       boolean this_present_ia = true && this.isSetIa();
22765       boolean that_present_ia = true && that.isSetIa();
22766       if (this_present_ia || that_present_ia) {
22767         if (!(this_present_ia && that_present_ia))
22768           return false;
22769         if (!this.ia.equals(that.ia))
22770           return false;
22771       }
22772 
22773       return true;
22774     }
22775 
22776     @Override
22777     public int hashCode() {
22778       HashCodeBuilder builder = new HashCodeBuilder();
22779 
22780       boolean present_io = true && (isSetIo());
22781       builder.append(present_io);
22782       if (present_io)
22783         builder.append(io);
22784 
22785       boolean present_ia = true && (isSetIa());
22786       builder.append(present_ia);
22787       if (present_ia)
22788         builder.append(ia);
22789 
22790       return builder.toHashCode();
22791     }
22792 
22793     public int compareTo(mutateRows_result other) {
22794       if (!getClass().equals(other.getClass())) {
22795         return getClass().getName().compareTo(other.getClass().getName());
22796       }
22797 
22798       int lastComparison = 0;
22799       mutateRows_result typedOther = (mutateRows_result)other;
22800 
22801       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
22802       if (lastComparison != 0) {
22803         return lastComparison;
22804       }
22805       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
22806       if (lastComparison != 0) {
22807         return lastComparison;
22808       }
22809       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
22810       if (lastComparison != 0) {
22811         return lastComparison;
22812       }
22813       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
22814       if (lastComparison != 0) {
22815         return lastComparison;
22816       }
22817       return 0;
22818     }
22819 
22820     public void read(TProtocol iprot) throws TException {
22821       TField field;
22822       iprot.readStructBegin();
22823       while (true)
22824       {
22825         field = iprot.readFieldBegin();
22826         if (field.type == TType.STOP) {
22827           break;
22828         }
22829         _Fields fieldId = _Fields.findByThriftId(field.id);
22830         if (fieldId == null) {
22831           TProtocolUtil.skip(iprot, field.type);
22832         } else {
22833           switch (fieldId) {
22834             case IO:
22835               if (field.type == TType.STRUCT) {
22836                 this.io = new IOError();
22837                 this.io.read(iprot);
22838               } else {
22839                 TProtocolUtil.skip(iprot, field.type);
22840               }
22841               break;
22842             case IA:
22843               if (field.type == TType.STRUCT) {
22844                 this.ia = new IllegalArgument();
22845                 this.ia.read(iprot);
22846               } else {
22847                 TProtocolUtil.skip(iprot, field.type);
22848               }
22849               break;
22850           }
22851           iprot.readFieldEnd();
22852         }
22853       }
22854       iprot.readStructEnd();
22855 
22856       // check for required fields of primitive type, which can't be checked in the validate method
22857       validate();
22858     }
22859 
22860     public void write(TProtocol oprot) throws TException {
22861       oprot.writeStructBegin(STRUCT_DESC);
22862 
22863       if (this.isSetIo()) {
22864         oprot.writeFieldBegin(IO_FIELD_DESC);
22865         this.io.write(oprot);
22866         oprot.writeFieldEnd();
22867       } else if (this.isSetIa()) {
22868         oprot.writeFieldBegin(IA_FIELD_DESC);
22869         this.ia.write(oprot);
22870         oprot.writeFieldEnd();
22871       }
22872       oprot.writeFieldStop();
22873       oprot.writeStructEnd();
22874     }
22875 
22876     @Override
22877     public String toString() {
22878       StringBuilder sb = new StringBuilder("mutateRows_result(");
22879       boolean first = true;
22880 
22881       sb.append("io:");
22882       if (this.io == null) {
22883         sb.append("null");
22884       } else {
22885         sb.append(this.io);
22886       }
22887       first = false;
22888       if (!first) sb.append(", ");
22889       sb.append("ia:");
22890       if (this.ia == null) {
22891         sb.append("null");
22892       } else {
22893         sb.append(this.ia);
22894       }
22895       first = false;
22896       sb.append(")");
22897       return sb.toString();
22898     }
22899 
22900     public void validate() throws TException {
22901       // check for required fields
22902     }
22903 
22904   }
22905 
22906   public static class mutateRowsTs_args implements TBase<mutateRowsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_args>   {
22907     private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_args");
22908 
22909     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
22910     private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2);
22911     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
22912 
22913     /**
22914      * name of table
22915      */
22916     public byte[] tableName;
22917     /**
22918      * list of row batches
22919      */
22920     public List<BatchMutation> rowBatches;
22921     /**
22922      * timestamp
22923      */
22924     public long timestamp;
22925 
22926     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
22927     public enum _Fields implements TFieldIdEnum {
22928       /**
22929        * name of table
22930        */
22931       TABLE_NAME((short)1, "tableName"),
22932       /**
22933        * list of row batches
22934        */
22935       ROW_BATCHES((short)2, "rowBatches"),
22936       /**
22937        * timestamp
22938        */
22939       TIMESTAMP((short)3, "timestamp");
22940 
22941       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22942       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22943 
22944       static {
22945         for (_Fields field : EnumSet.allOf(_Fields.class)) {
22946           byId.put((int)field._thriftId, field);
22947           byName.put(field.getFieldName(), field);
22948         }
22949       }
22950 
22951       /**
22952        * Find the _Fields constant that matches fieldId, or null if its not found.
22953        */
22954       public static _Fields findByThriftId(int fieldId) {
22955         return byId.get(fieldId);
22956       }
22957 
22958       /**
22959        * Find the _Fields constant that matches fieldId, throwing an exception
22960        * if it is not found.
22961        */
22962       public static _Fields findByThriftIdOrThrow(int fieldId) {
22963         _Fields fields = findByThriftId(fieldId);
22964         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22965         return fields;
22966       }
22967 
22968       /**
22969        * Find the _Fields constant that matches name, or null if its not found.
22970        */
22971       public static _Fields findByName(String name) {
22972         return byName.get(name);
22973       }
22974 
22975       private final short _thriftId;
22976       private final String _fieldName;
22977 
22978       _Fields(short thriftId, String fieldName) {
22979         _thriftId = thriftId;
22980         _fieldName = fieldName;
22981       }
22982 
22983       public short getThriftFieldId() {
22984         return _thriftId;
22985       }
22986 
22987       public String getFieldName() {
22988         return _fieldName;
22989       }
22990     }
22991 
22992     // isset id assignments
22993     private static final int __TIMESTAMP_ISSET_ID = 0;
22994     private BitSet __isset_bit_vector = new BitSet(1);
22995 
22996     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22997       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
22998           new FieldValueMetaData(TType.STRING)));
22999       put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT,
23000           new ListMetaData(TType.LIST,
23001               new StructMetaData(TType.STRUCT, BatchMutation.class))));
23002       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
23003           new FieldValueMetaData(TType.I64)));
23004     }});
23005 
23006     static {
23007       FieldMetaData.addStructMetaDataMap(mutateRowsTs_args.class, metaDataMap);
23008     }
23009 
23010     public mutateRowsTs_args() {
23011     }
23012 
23013     public mutateRowsTs_args(
23014       byte[] tableName,
23015       List<BatchMutation> rowBatches,
23016       long timestamp)
23017     {
23018       this();
23019       this.tableName = tableName;
23020       this.rowBatches = rowBatches;
23021       this.timestamp = timestamp;
23022       setTimestampIsSet(true);
23023     }
23024 
23025     /**
23026      * Performs a deep copy on <i>other</i>.
23027      */
23028     public mutateRowsTs_args(mutateRowsTs_args other) {
23029       __isset_bit_vector.clear();
23030       __isset_bit_vector.or(other.__isset_bit_vector);
23031       if (other.isSetTableName()) {
23032         this.tableName = other.tableName;
23033       }
23034       if (other.isSetRowBatches()) {
23035         List<BatchMutation> __this__rowBatches = new ArrayList<BatchMutation>();
23036         for (BatchMutation other_element : other.rowBatches) {
23037           __this__rowBatches.add(new BatchMutation(other_element));
23038         }
23039         this.rowBatches = __this__rowBatches;
23040       }
23041       this.timestamp = other.timestamp;
23042     }
23043 
23044     public mutateRowsTs_args deepCopy() {
23045       return new mutateRowsTs_args(this);
23046     }
23047 
23048     @Deprecated
23049     public mutateRowsTs_args clone() {
23050       return new mutateRowsTs_args(this);
23051     }
23052 
23053     /**
23054      * name of table
23055      */
23056     public byte[] getTableName() {
23057       return this.tableName;
23058     }
23059 
23060     /**
23061      * name of table
23062      */
23063     public mutateRowsTs_args setTableName(byte[] tableName) {
23064       this.tableName = tableName;
23065       return this;
23066     }
23067 
23068     public void unsetTableName() {
23069       this.tableName = null;
23070     }
23071 
23072     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
23073     public boolean isSetTableName() {
23074       return this.tableName != null;
23075     }
23076 
23077     public void setTableNameIsSet(boolean value) {
23078       if (!value) {
23079         this.tableName = null;
23080       }
23081     }
23082 
23083     public int getRowBatchesSize() {
23084       return (this.rowBatches == null) ? 0 : this.rowBatches.size();
23085     }
23086 
23087     public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
23088       return (this.rowBatches == null) ? null : this.rowBatches.iterator();
23089     }
23090 
23091     public void addToRowBatches(BatchMutation elem) {
23092       if (this.rowBatches == null) {
23093         this.rowBatches = new ArrayList<BatchMutation>();
23094       }
23095       this.rowBatches.add(elem);
23096     }
23097 
23098     /**
23099      * list of row batches
23100      */
23101     public List<BatchMutation> getRowBatches() {
23102       return this.rowBatches;
23103     }
23104 
23105     /**
23106      * list of row batches
23107      */
23108     public mutateRowsTs_args setRowBatches(List<BatchMutation> rowBatches) {
23109       this.rowBatches = rowBatches;
23110       return this;
23111     }
23112 
23113     public void unsetRowBatches() {
23114       this.rowBatches = null;
23115     }
23116 
23117     /** Returns true if field rowBatches is set (has been asigned a value) and false otherwise */
23118     public boolean isSetRowBatches() {
23119       return this.rowBatches != null;
23120     }
23121 
23122     public void setRowBatchesIsSet(boolean value) {
23123       if (!value) {
23124         this.rowBatches = null;
23125       }
23126     }
23127 
23128     /**
23129      * timestamp
23130      */
23131     public long getTimestamp() {
23132       return this.timestamp;
23133     }
23134 
23135     /**
23136      * timestamp
23137      */
23138     public mutateRowsTs_args setTimestamp(long timestamp) {
23139       this.timestamp = timestamp;
23140       setTimestampIsSet(true);
23141       return this;
23142     }
23143 
23144     public void unsetTimestamp() {
23145       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
23146     }
23147 
23148     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
23149     public boolean isSetTimestamp() {
23150       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
23151     }
23152 
23153     public void setTimestampIsSet(boolean value) {
23154       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
23155     }
23156 
23157     public void setFieldValue(_Fields field, Object value) {
23158       switch (field) {
23159       case TABLE_NAME:
23160         if (value == null) {
23161           unsetTableName();
23162         } else {
23163           setTableName((byte[])value);
23164         }
23165         break;
23166 
23167       case ROW_BATCHES:
23168         if (value == null) {
23169           unsetRowBatches();
23170         } else {
23171           setRowBatches((List<BatchMutation>)value);
23172         }
23173         break;
23174 
23175       case TIMESTAMP:
23176         if (value == null) {
23177           unsetTimestamp();
23178         } else {
23179           setTimestamp((Long)value);
23180         }
23181         break;
23182 
23183       }
23184     }
23185 
23186     public void setFieldValue(int fieldID, Object value) {
23187       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23188     }
23189 
23190     public Object getFieldValue(_Fields field) {
23191       switch (field) {
23192       case TABLE_NAME:
23193         return getTableName();
23194 
23195       case ROW_BATCHES:
23196         return getRowBatches();
23197 
23198       case TIMESTAMP:
23199         return new Long(getTimestamp());
23200 
23201       }
23202       throw new IllegalStateException();
23203     }
23204 
23205     public Object getFieldValue(int fieldId) {
23206       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23207     }
23208 
23209     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
23210     public boolean isSet(_Fields field) {
23211       switch (field) {
23212       case TABLE_NAME:
23213         return isSetTableName();
23214       case ROW_BATCHES:
23215         return isSetRowBatches();
23216       case TIMESTAMP:
23217         return isSetTimestamp();
23218       }
23219       throw new IllegalStateException();
23220     }
23221 
23222     public boolean isSet(int fieldID) {
23223       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23224     }
23225 
23226     @Override
23227     public boolean equals(Object that) {
23228       if (that == null)
23229         return false;
23230       if (that instanceof mutateRowsTs_args)
23231         return this.equals((mutateRowsTs_args)that);
23232       return false;
23233     }
23234 
23235     public boolean equals(mutateRowsTs_args that) {
23236       if (that == null)
23237         return false;
23238 
23239       boolean this_present_tableName = true && this.isSetTableName();
23240       boolean that_present_tableName = true && that.isSetTableName();
23241       if (this_present_tableName || that_present_tableName) {
23242         if (!(this_present_tableName && that_present_tableName))
23243           return false;
23244         if (!java.util.Arrays.equals(this.tableName, that.tableName))
23245           return false;
23246       }
23247 
23248       boolean this_present_rowBatches = true && this.isSetRowBatches();
23249       boolean that_present_rowBatches = true && that.isSetRowBatches();
23250       if (this_present_rowBatches || that_present_rowBatches) {
23251         if (!(this_present_rowBatches && that_present_rowBatches))
23252           return false;
23253         if (!this.rowBatches.equals(that.rowBatches))
23254           return false;
23255       }
23256 
23257       boolean this_present_timestamp = true;
23258       boolean that_present_timestamp = true;
23259       if (this_present_timestamp || that_present_timestamp) {
23260         if (!(this_present_timestamp && that_present_timestamp))
23261           return false;
23262         if (this.timestamp != that.timestamp)
23263           return false;
23264       }
23265 
23266       return true;
23267     }
23268 
23269     @Override
23270     public int hashCode() {
23271       HashCodeBuilder builder = new HashCodeBuilder();
23272 
23273       boolean present_tableName = true && (isSetTableName());
23274       builder.append(present_tableName);
23275       if (present_tableName)
23276         builder.append(tableName);
23277 
23278       boolean present_rowBatches = true && (isSetRowBatches());
23279       builder.append(present_rowBatches);
23280       if (present_rowBatches)
23281         builder.append(rowBatches);
23282 
23283       boolean present_timestamp = true;
23284       builder.append(present_timestamp);
23285       if (present_timestamp)
23286         builder.append(timestamp);
23287 
23288       return builder.toHashCode();
23289     }
23290 
23291     public int compareTo(mutateRowsTs_args other) {
23292       if (!getClass().equals(other.getClass())) {
23293         return getClass().getName().compareTo(other.getClass().getName());
23294       }
23295 
23296       int lastComparison = 0;
23297       mutateRowsTs_args typedOther = (mutateRowsTs_args)other;
23298 
23299       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
23300       if (lastComparison != 0) {
23301         return lastComparison;
23302       }
23303       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
23304       if (lastComparison != 0) {
23305         return lastComparison;
23306       }
23307       lastComparison = Boolean.valueOf(isSetRowBatches()).compareTo(isSetRowBatches());
23308       if (lastComparison != 0) {
23309         return lastComparison;
23310       }
23311       lastComparison = TBaseHelper.compareTo(rowBatches, typedOther.rowBatches);
23312       if (lastComparison != 0) {
23313         return lastComparison;
23314       }
23315       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
23316       if (lastComparison != 0) {
23317         return lastComparison;
23318       }
23319       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
23320       if (lastComparison != 0) {
23321         return lastComparison;
23322       }
23323       return 0;
23324     }
23325 
23326     public void read(TProtocol iprot) throws TException {
23327       TField field;
23328       iprot.readStructBegin();
23329       while (true)
23330       {
23331         field = iprot.readFieldBegin();
23332         if (field.type == TType.STOP) {
23333           break;
23334         }
23335         _Fields fieldId = _Fields.findByThriftId(field.id);
23336         if (fieldId == null) {
23337           TProtocolUtil.skip(iprot, field.type);
23338         } else {
23339           switch (fieldId) {
23340             case TABLE_NAME:
23341               if (field.type == TType.STRING) {
23342                 this.tableName = iprot.readBinary();
23343               } else {
23344                 TProtocolUtil.skip(iprot, field.type);
23345               }
23346               break;
23347             case ROW_BATCHES:
23348               if (field.type == TType.LIST) {
23349                 {
23350                   TList _list114 = iprot.readListBegin();
23351                   this.rowBatches = new ArrayList<BatchMutation>(_list114.size);
23352                   for (int _i115 = 0; _i115 < _list114.size; ++_i115)
23353                   {
23354                     BatchMutation _elem116;
23355                     _elem116 = new BatchMutation();
23356                     _elem116.read(iprot);
23357                     this.rowBatches.add(_elem116);
23358                   }
23359                   iprot.readListEnd();
23360                 }
23361               } else {
23362                 TProtocolUtil.skip(iprot, field.type);
23363               }
23364               break;
23365             case TIMESTAMP:
23366               if (field.type == TType.I64) {
23367                 this.timestamp = iprot.readI64();
23368                 setTimestampIsSet(true);
23369               } else {
23370                 TProtocolUtil.skip(iprot, field.type);
23371               }
23372               break;
23373           }
23374           iprot.readFieldEnd();
23375         }
23376       }
23377       iprot.readStructEnd();
23378 
23379       // check for required fields of primitive type, which can't be checked in the validate method
23380       validate();
23381     }
23382 
23383     public void write(TProtocol oprot) throws TException {
23384       validate();
23385 
23386       oprot.writeStructBegin(STRUCT_DESC);
23387       if (this.tableName != null) {
23388         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
23389         oprot.writeBinary(this.tableName);
23390         oprot.writeFieldEnd();
23391       }
23392       if (this.rowBatches != null) {
23393         oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
23394         {
23395           oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size()));
23396           for (BatchMutation _iter117 : this.rowBatches)
23397           {
23398             _iter117.write(oprot);
23399           }
23400           oprot.writeListEnd();
23401         }
23402         oprot.writeFieldEnd();
23403       }
23404       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
23405       oprot.writeI64(this.timestamp);
23406       oprot.writeFieldEnd();
23407       oprot.writeFieldStop();
23408       oprot.writeStructEnd();
23409     }
23410 
23411     @Override
23412     public String toString() {
23413       StringBuilder sb = new StringBuilder("mutateRowsTs_args(");
23414       boolean first = true;
23415 
23416       sb.append("tableName:");
23417       if (this.tableName == null) {
23418         sb.append("null");
23419       } else {
23420         sb.append(this.tableName);
23421       }
23422       first = false;
23423       if (!first) sb.append(", ");
23424       sb.append("rowBatches:");
23425       if (this.rowBatches == null) {
23426         sb.append("null");
23427       } else {
23428         sb.append(this.rowBatches);
23429       }
23430       first = false;
23431       if (!first) sb.append(", ");
23432       sb.append("timestamp:");
23433       sb.append(this.timestamp);
23434       first = false;
23435       sb.append(")");
23436       return sb.toString();
23437     }
23438 
23439     public void validate() throws TException {
23440       // check for required fields
23441     }
23442 
23443   }
23444 
23445   public static class mutateRowsTs_result implements TBase<mutateRowsTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_result>   {
23446     private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_result");
23447 
23448     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
23449     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
23450 
23451     public IOError io;
23452     public IllegalArgument ia;
23453 
23454     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
23455     public enum _Fields implements TFieldIdEnum {
23456       IO((short)1, "io"),
23457       IA((short)2, "ia");
23458 
23459       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23460       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23461 
23462       static {
23463         for (_Fields field : EnumSet.allOf(_Fields.class)) {
23464           byId.put((int)field._thriftId, field);
23465           byName.put(field.getFieldName(), field);
23466         }
23467       }
23468 
23469       /**
23470        * Find the _Fields constant that matches fieldId, or null if its not found.
23471        */
23472       public static _Fields findByThriftId(int fieldId) {
23473         return byId.get(fieldId);
23474       }
23475 
23476       /**
23477        * Find the _Fields constant that matches fieldId, throwing an exception
23478        * if it is not found.
23479        */
23480       public static _Fields findByThriftIdOrThrow(int fieldId) {
23481         _Fields fields = findByThriftId(fieldId);
23482         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
23483         return fields;
23484       }
23485 
23486       /**
23487        * Find the _Fields constant that matches name, or null if its not found.
23488        */
23489       public static _Fields findByName(String name) {
23490         return byName.get(name);
23491       }
23492 
23493       private final short _thriftId;
23494       private final String _fieldName;
23495 
23496       _Fields(short thriftId, String fieldName) {
23497         _thriftId = thriftId;
23498         _fieldName = fieldName;
23499       }
23500 
23501       public short getThriftFieldId() {
23502         return _thriftId;
23503       }
23504 
23505       public String getFieldName() {
23506         return _fieldName;
23507       }
23508     }
23509 
23510     // isset id assignments
23511 
23512     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
23513       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
23514           new FieldValueMetaData(TType.STRUCT)));
23515       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
23516           new FieldValueMetaData(TType.STRUCT)));
23517     }});
23518 
23519     static {
23520       FieldMetaData.addStructMetaDataMap(mutateRowsTs_result.class, metaDataMap);
23521     }
23522 
23523     public mutateRowsTs_result() {
23524     }
23525 
23526     public mutateRowsTs_result(
23527       IOError io,
23528       IllegalArgument ia)
23529     {
23530       this();
23531       this.io = io;
23532       this.ia = ia;
23533     }
23534 
23535     /**
23536      * Performs a deep copy on <i>other</i>.
23537      */
23538     public mutateRowsTs_result(mutateRowsTs_result other) {
23539       if (other.isSetIo()) {
23540         this.io = new IOError(other.io);
23541       }
23542       if (other.isSetIa()) {
23543         this.ia = new IllegalArgument(other.ia);
23544       }
23545     }
23546 
23547     public mutateRowsTs_result deepCopy() {
23548       return new mutateRowsTs_result(this);
23549     }
23550 
23551     @Deprecated
23552     public mutateRowsTs_result clone() {
23553       return new mutateRowsTs_result(this);
23554     }
23555 
23556     public IOError getIo() {
23557       return this.io;
23558     }
23559 
23560     public mutateRowsTs_result setIo(IOError io) {
23561       this.io = io;
23562       return this;
23563     }
23564 
23565     public void unsetIo() {
23566       this.io = null;
23567     }
23568 
23569     /** Returns true if field io is set (has been asigned a value) and false otherwise */
23570     public boolean isSetIo() {
23571       return this.io != null;
23572     }
23573 
23574     public void setIoIsSet(boolean value) {
23575       if (!value) {
23576         this.io = null;
23577       }
23578     }
23579 
23580     public IllegalArgument getIa() {
23581       return this.ia;
23582     }
23583 
23584     public mutateRowsTs_result setIa(IllegalArgument ia) {
23585       this.ia = ia;
23586       return this;
23587     }
23588 
23589     public void unsetIa() {
23590       this.ia = null;
23591     }
23592 
23593     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
23594     public boolean isSetIa() {
23595       return this.ia != null;
23596     }
23597 
23598     public void setIaIsSet(boolean value) {
23599       if (!value) {
23600         this.ia = null;
23601       }
23602     }
23603 
23604     public void setFieldValue(_Fields field, Object value) {
23605       switch (field) {
23606       case IO:
23607         if (value == null) {
23608           unsetIo();
23609         } else {
23610           setIo((IOError)value);
23611         }
23612         break;
23613 
23614       case IA:
23615         if (value == null) {
23616           unsetIa();
23617         } else {
23618           setIa((IllegalArgument)value);
23619         }
23620         break;
23621 
23622       }
23623     }
23624 
23625     public void setFieldValue(int fieldID, Object value) {
23626       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23627     }
23628 
23629     public Object getFieldValue(_Fields field) {
23630       switch (field) {
23631       case IO:
23632         return getIo();
23633 
23634       case IA:
23635         return getIa();
23636 
23637       }
23638       throw new IllegalStateException();
23639     }
23640 
23641     public Object getFieldValue(int fieldId) {
23642       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23643     }
23644 
23645     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
23646     public boolean isSet(_Fields field) {
23647       switch (field) {
23648       case IO:
23649         return isSetIo();
23650       case IA:
23651         return isSetIa();
23652       }
23653       throw new IllegalStateException();
23654     }
23655 
23656     public boolean isSet(int fieldID) {
23657       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23658     }
23659 
23660     @Override
23661     public boolean equals(Object that) {
23662       if (that == null)
23663         return false;
23664       if (that instanceof mutateRowsTs_result)
23665         return this.equals((mutateRowsTs_result)that);
23666       return false;
23667     }
23668 
23669     public boolean equals(mutateRowsTs_result that) {
23670       if (that == null)
23671         return false;
23672 
23673       boolean this_present_io = true && this.isSetIo();
23674       boolean that_present_io = true && that.isSetIo();
23675       if (this_present_io || that_present_io) {
23676         if (!(this_present_io && that_present_io))
23677           return false;
23678         if (!this.io.equals(that.io))
23679           return false;
23680       }
23681 
23682       boolean this_present_ia = true && this.isSetIa();
23683       boolean that_present_ia = true && that.isSetIa();
23684       if (this_present_ia || that_present_ia) {
23685         if (!(this_present_ia && that_present_ia))
23686           return false;
23687         if (!this.ia.equals(that.ia))
23688           return false;
23689       }
23690 
23691       return true;
23692     }
23693 
23694     @Override
23695     public int hashCode() {
23696       HashCodeBuilder builder = new HashCodeBuilder();
23697 
23698       boolean present_io = true && (isSetIo());
23699       builder.append(present_io);
23700       if (present_io)
23701         builder.append(io);
23702 
23703       boolean present_ia = true && (isSetIa());
23704       builder.append(present_ia);
23705       if (present_ia)
23706         builder.append(ia);
23707 
23708       return builder.toHashCode();
23709     }
23710 
23711     public int compareTo(mutateRowsTs_result other) {
23712       if (!getClass().equals(other.getClass())) {
23713         return getClass().getName().compareTo(other.getClass().getName());
23714       }
23715 
23716       int lastComparison = 0;
23717       mutateRowsTs_result typedOther = (mutateRowsTs_result)other;
23718 
23719       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
23720       if (lastComparison != 0) {
23721         return lastComparison;
23722       }
23723       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
23724       if (lastComparison != 0) {
23725         return lastComparison;
23726       }
23727       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
23728       if (lastComparison != 0) {
23729         return lastComparison;
23730       }
23731       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
23732       if (lastComparison != 0) {
23733         return lastComparison;
23734       }
23735       return 0;
23736     }
23737 
23738     public void read(TProtocol iprot) throws TException {
23739       TField field;
23740       iprot.readStructBegin();
23741       while (true)
23742       {
23743         field = iprot.readFieldBegin();
23744         if (field.type == TType.STOP) {
23745           break;
23746         }
23747         _Fields fieldId = _Fields.findByThriftId(field.id);
23748         if (fieldId == null) {
23749           TProtocolUtil.skip(iprot, field.type);
23750         } else {
23751           switch (fieldId) {
23752             case IO:
23753               if (field.type == TType.STRUCT) {
23754                 this.io = new IOError();
23755                 this.io.read(iprot);
23756               } else {
23757                 TProtocolUtil.skip(iprot, field.type);
23758               }
23759               break;
23760             case IA:
23761               if (field.type == TType.STRUCT) {
23762                 this.ia = new IllegalArgument();
23763                 this.ia.read(iprot);
23764               } else {
23765                 TProtocolUtil.skip(iprot, field.type);
23766               }
23767               break;
23768           }
23769           iprot.readFieldEnd();
23770         }
23771       }
23772       iprot.readStructEnd();
23773 
23774       // check for required fields of primitive type, which can't be checked in the validate method
23775       validate();
23776     }
23777 
23778     public void write(TProtocol oprot) throws TException {
23779       oprot.writeStructBegin(STRUCT_DESC);
23780 
23781       if (this.isSetIo()) {
23782         oprot.writeFieldBegin(IO_FIELD_DESC);
23783         this.io.write(oprot);
23784         oprot.writeFieldEnd();
23785       } else if (this.isSetIa()) {
23786         oprot.writeFieldBegin(IA_FIELD_DESC);
23787         this.ia.write(oprot);
23788         oprot.writeFieldEnd();
23789       }
23790       oprot.writeFieldStop();
23791       oprot.writeStructEnd();
23792     }
23793 
23794     @Override
23795     public String toString() {
23796       StringBuilder sb = new StringBuilder("mutateRowsTs_result(");
23797       boolean first = true;
23798 
23799       sb.append("io:");
23800       if (this.io == null) {
23801         sb.append("null");
23802       } else {
23803         sb.append(this.io);
23804       }
23805       first = false;
23806       if (!first) sb.append(", ");
23807       sb.append("ia:");
23808       if (this.ia == null) {
23809         sb.append("null");
23810       } else {
23811         sb.append(this.ia);
23812       }
23813       first = false;
23814       sb.append(")");
23815       return sb.toString();
23816     }
23817 
23818     public void validate() throws TException {
23819       // check for required fields
23820     }
23821 
23822   }
23823 
23824   public static class atomicIncrement_args implements TBase<atomicIncrement_args._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_args>   {
23825     private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_args");
23826 
23827     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
23828     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
23829     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
23830     private static final TField VALUE_FIELD_DESC = new TField("value", TType.I64, (short)4);
23831 
23832     /**
23833      * name of table
23834      */
23835     public byte[] tableName;
23836     /**
23837      * row to increment
23838      */
23839     public byte[] row;
23840     /**
23841      * name of column
23842      */
23843     public byte[] column;
23844     /**
23845      * amount to increment by
23846      */
23847     public long value;
23848 
23849     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
23850     public enum _Fields implements TFieldIdEnum {
23851       /**
23852        * name of table
23853        */
23854       TABLE_NAME((short)1, "tableName"),
23855       /**
23856        * row to increment
23857        */
23858       ROW((short)2, "row"),
23859       /**
23860        * name of column
23861        */
23862       COLUMN((short)3, "column"),
23863       /**
23864        * amount to increment by
23865        */
23866       VALUE((short)4, "value");
23867 
23868       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23869       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23870 
23871       static {
23872         for (_Fields field : EnumSet.allOf(_Fields.class)) {
23873           byId.put((int)field._thriftId, field);
23874           byName.put(field.getFieldName(), field);
23875         }
23876       }
23877 
23878       /**
23879        * Find the _Fields constant that matches fieldId, or null if its not found.
23880        */
23881       public static _Fields findByThriftId(int fieldId) {
23882         return byId.get(fieldId);
23883       }
23884 
23885       /**
23886        * Find the _Fields constant that matches fieldId, throwing an exception
23887        * if it is not found.
23888        */
23889       public static _Fields findByThriftIdOrThrow(int fieldId) {
23890         _Fields fields = findByThriftId(fieldId);
23891         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
23892         return fields;
23893       }
23894 
23895       /**
23896        * Find the _Fields constant that matches name, or null if its not found.
23897        */
23898       public static _Fields findByName(String name) {
23899         return byName.get(name);
23900       }
23901 
23902       private final short _thriftId;
23903       private final String _fieldName;
23904 
23905       _Fields(short thriftId, String fieldName) {
23906         _thriftId = thriftId;
23907         _fieldName = fieldName;
23908       }
23909 
23910       public short getThriftFieldId() {
23911         return _thriftId;
23912       }
23913 
23914       public String getFieldName() {
23915         return _fieldName;
23916       }
23917     }
23918 
23919     // isset id assignments
23920     private static final int __VALUE_ISSET_ID = 0;
23921     private BitSet __isset_bit_vector = new BitSet(1);
23922 
23923     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
23924       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
23925           new FieldValueMetaData(TType.STRING)));
23926       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
23927           new FieldValueMetaData(TType.STRING)));
23928       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
23929           new FieldValueMetaData(TType.STRING)));
23930       put(_Fields.VALUE, new FieldMetaData("value", TFieldRequirementType.DEFAULT,
23931           new FieldValueMetaData(TType.I64)));
23932     }});
23933 
23934     static {
23935       FieldMetaData.addStructMetaDataMap(atomicIncrement_args.class, metaDataMap);
23936     }
23937 
23938     public atomicIncrement_args() {
23939     }
23940 
23941     public atomicIncrement_args(
23942       byte[] tableName,
23943       byte[] row,
23944       byte[] column,
23945       long value)
23946     {
23947       this();
23948       this.tableName = tableName;
23949       this.row = row;
23950       this.column = column;
23951       this.value = value;
23952       setValueIsSet(true);
23953     }
23954 
23955     /**
23956      * Performs a deep copy on <i>other</i>.
23957      */
23958     public atomicIncrement_args(atomicIncrement_args other) {
23959       __isset_bit_vector.clear();
23960       __isset_bit_vector.or(other.__isset_bit_vector);
23961       if (other.isSetTableName()) {
23962         this.tableName = other.tableName;
23963       }
23964       if (other.isSetRow()) {
23965         this.row = other.row;
23966       }
23967       if (other.isSetColumn()) {
23968         this.column = other.column;
23969       }
23970       this.value = other.value;
23971     }
23972 
23973     public atomicIncrement_args deepCopy() {
23974       return new atomicIncrement_args(this);
23975     }
23976 
23977     @Deprecated
23978     public atomicIncrement_args clone() {
23979       return new atomicIncrement_args(this);
23980     }
23981 
23982     /**
23983      * name of table
23984      */
23985     public byte[] getTableName() {
23986       return this.tableName;
23987     }
23988 
23989     /**
23990      * name of table
23991      */
23992     public atomicIncrement_args setTableName(byte[] tableName) {
23993       this.tableName = tableName;
23994       return this;
23995     }
23996 
23997     public void unsetTableName() {
23998       this.tableName = null;
23999     }
24000 
24001     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
24002     public boolean isSetTableName() {
24003       return this.tableName != null;
24004     }
24005 
24006     public void setTableNameIsSet(boolean value) {
24007       if (!value) {
24008         this.tableName = null;
24009       }
24010     }
24011 
24012     /**
24013      * row to increment
24014      */
24015     public byte[] getRow() {
24016       return this.row;
24017     }
24018 
24019     /**
24020      * row to increment
24021      */
24022     public atomicIncrement_args setRow(byte[] row) {
24023       this.row = row;
24024       return this;
24025     }
24026 
24027     public void unsetRow() {
24028       this.row = null;
24029     }
24030 
24031     /** Returns true if field row is set (has been asigned a value) and false otherwise */
24032     public boolean isSetRow() {
24033       return this.row != null;
24034     }
24035 
24036     public void setRowIsSet(boolean value) {
24037       if (!value) {
24038         this.row = null;
24039       }
24040     }
24041 
24042     /**
24043      * name of column
24044      */
24045     public byte[] getColumn() {
24046       return this.column;
24047     }
24048 
24049     /**
24050      * name of column
24051      */
24052     public atomicIncrement_args setColumn(byte[] column) {
24053       this.column = column;
24054       return this;
24055     }
24056 
24057     public void unsetColumn() {
24058       this.column = null;
24059     }
24060 
24061     /** Returns true if field column is set (has been asigned a value) and false otherwise */
24062     public boolean isSetColumn() {
24063       return this.column != null;
24064     }
24065 
24066     public void setColumnIsSet(boolean value) {
24067       if (!value) {
24068         this.column = null;
24069       }
24070     }
24071 
24072     /**
24073      * amount to increment by
24074      */
24075     public long getValue() {
24076       return this.value;
24077     }
24078 
24079     /**
24080      * amount to increment by
24081      */
24082     public atomicIncrement_args setValue(long value) {
24083       this.value = value;
24084       setValueIsSet(true);
24085       return this;
24086     }
24087 
24088     public void unsetValue() {
24089       __isset_bit_vector.clear(__VALUE_ISSET_ID);
24090     }
24091 
24092     /** Returns true if field value is set (has been asigned a value) and false otherwise */
24093     public boolean isSetValue() {
24094       return __isset_bit_vector.get(__VALUE_ISSET_ID);
24095     }
24096 
24097     public void setValueIsSet(boolean value) {
24098       __isset_bit_vector.set(__VALUE_ISSET_ID, value);
24099     }
24100 
24101     public void setFieldValue(_Fields field, Object value) {
24102       switch (field) {
24103       case TABLE_NAME:
24104         if (value == null) {
24105           unsetTableName();
24106         } else {
24107           setTableName((byte[])value);
24108         }
24109         break;
24110 
24111       case ROW:
24112         if (value == null) {
24113           unsetRow();
24114         } else {
24115           setRow((byte[])value);
24116         }
24117         break;
24118 
24119       case COLUMN:
24120         if (value == null) {
24121           unsetColumn();
24122         } else {
24123           setColumn((byte[])value);
24124         }
24125         break;
24126 
24127       case VALUE:
24128         if (value == null) {
24129           unsetValue();
24130         } else {
24131           setValue((Long)value);
24132         }
24133         break;
24134 
24135       }
24136     }
24137 
24138     public void setFieldValue(int fieldID, Object value) {
24139       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
24140     }
24141 
24142     public Object getFieldValue(_Fields field) {
24143       switch (field) {
24144       case TABLE_NAME:
24145         return getTableName();
24146 
24147       case ROW:
24148         return getRow();
24149 
24150       case COLUMN:
24151         return getColumn();
24152 
24153       case VALUE:
24154         return new Long(getValue());
24155 
24156       }
24157       throw new IllegalStateException();
24158     }
24159 
24160     public Object getFieldValue(int fieldId) {
24161       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
24162     }
24163 
24164     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
24165     public boolean isSet(_Fields field) {
24166       switch (field) {
24167       case TABLE_NAME:
24168         return isSetTableName();
24169       case ROW:
24170         return isSetRow();
24171       case COLUMN:
24172         return isSetColumn();
24173       case VALUE:
24174         return isSetValue();
24175       }
24176       throw new IllegalStateException();
24177     }
24178 
24179     public boolean isSet(int fieldID) {
24180       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
24181     }
24182 
24183     @Override
24184     public boolean equals(Object that) {
24185       if (that == null)
24186         return false;
24187       if (that instanceof atomicIncrement_args)
24188         return this.equals((atomicIncrement_args)that);
24189       return false;
24190     }
24191 
24192     public boolean equals(atomicIncrement_args that) {
24193       if (that == null)
24194         return false;
24195 
24196       boolean this_present_tableName = true && this.isSetTableName();
24197       boolean that_present_tableName = true && that.isSetTableName();
24198       if (this_present_tableName || that_present_tableName) {
24199         if (!(this_present_tableName && that_present_tableName))
24200           return false;
24201         if (!java.util.Arrays.equals(this.tableName, that.tableName))
24202           return false;
24203       }
24204 
24205       boolean this_present_row = true && this.isSetRow();
24206       boolean that_present_row = true && that.isSetRow();
24207       if (this_present_row || that_present_row) {
24208         if (!(this_present_row && that_present_row))
24209           return false;
24210         if (!java.util.Arrays.equals(this.row, that.row))
24211           return false;
24212       }
24213 
24214       boolean this_present_column = true && this.isSetColumn();
24215       boolean that_present_column = true && that.isSetColumn();
24216       if (this_present_column || that_present_column) {
24217         if (!(this_present_column && that_present_column))
24218           return false;
24219         if (!java.util.Arrays.equals(this.column, that.column))
24220           return false;
24221       }
24222 
24223       boolean this_present_value = true;
24224       boolean that_present_value = true;
24225       if (this_present_value || that_present_value) {
24226         if (!(this_present_value && that_present_value))
24227           return false;
24228         if (this.value != that.value)
24229           return false;
24230       }
24231 
24232       return true;
24233     }
24234 
24235     @Override
24236     public int hashCode() {
24237       HashCodeBuilder builder = new HashCodeBuilder();
24238 
24239       boolean present_tableName = true && (isSetTableName());
24240       builder.append(present_tableName);
24241       if (present_tableName)
24242         builder.append(tableName);
24243 
24244       boolean present_row = true && (isSetRow());
24245       builder.append(present_row);
24246       if (present_row)
24247         builder.append(row);
24248 
24249       boolean present_column = true && (isSetColumn());
24250       builder.append(present_column);
24251       if (present_column)
24252         builder.append(column);
24253 
24254       boolean present_value = true;
24255       builder.append(present_value);
24256       if (present_value)
24257         builder.append(value);
24258 
24259       return builder.toHashCode();
24260     }
24261 
24262     public int compareTo(atomicIncrement_args other) {
24263       if (!getClass().equals(other.getClass())) {
24264         return getClass().getName().compareTo(other.getClass().getName());
24265       }
24266 
24267       int lastComparison = 0;
24268       atomicIncrement_args typedOther = (atomicIncrement_args)other;
24269 
24270       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
24271       if (lastComparison != 0) {
24272         return lastComparison;
24273       }
24274       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
24275       if (lastComparison != 0) {
24276         return lastComparison;
24277       }
24278       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
24279       if (lastComparison != 0) {
24280         return lastComparison;
24281       }
24282       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
24283       if (lastComparison != 0) {
24284         return lastComparison;
24285       }
24286       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
24287       if (lastComparison != 0) {
24288         return lastComparison;
24289       }
24290       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
24291       if (lastComparison != 0) {
24292         return lastComparison;
24293       }
24294       lastComparison = Boolean.valueOf(isSetValue()).compareTo(isSetValue());
24295       if (lastComparison != 0) {
24296         return lastComparison;
24297       }
24298       lastComparison = TBaseHelper.compareTo(value, typedOther.value);
24299       if (lastComparison != 0) {
24300         return lastComparison;
24301       }
24302       return 0;
24303     }
24304 
24305     public void read(TProtocol iprot) throws TException {
24306       TField field;
24307       iprot.readStructBegin();
24308       while (true)
24309       {
24310         field = iprot.readFieldBegin();
24311         if (field.type == TType.STOP) {
24312           break;
24313         }
24314         _Fields fieldId = _Fields.findByThriftId(field.id);
24315         if (fieldId == null) {
24316           TProtocolUtil.skip(iprot, field.type);
24317         } else {
24318           switch (fieldId) {
24319             case TABLE_NAME:
24320               if (field.type == TType.STRING) {
24321                 this.tableName = iprot.readBinary();
24322               } else {
24323                 TProtocolUtil.skip(iprot, field.type);
24324               }
24325               break;
24326             case ROW:
24327               if (field.type == TType.STRING) {
24328                 this.row = iprot.readBinary();
24329               } else {
24330                 TProtocolUtil.skip(iprot, field.type);
24331               }
24332               break;
24333             case COLUMN:
24334               if (field.type == TType.STRING) {
24335                 this.column = iprot.readBinary();
24336               } else {
24337                 TProtocolUtil.skip(iprot, field.type);
24338               }
24339               break;
24340             case VALUE:
24341               if (field.type == TType.I64) {
24342                 this.value = iprot.readI64();
24343                 setValueIsSet(true);
24344               } else {
24345                 TProtocolUtil.skip(iprot, field.type);
24346               }
24347               break;
24348           }
24349           iprot.readFieldEnd();
24350         }
24351       }
24352       iprot.readStructEnd();
24353 
24354       // check for required fields of primitive type, which can't be checked in the validate method
24355       validate();
24356     }
24357 
24358     public void write(TProtocol oprot) throws TException {
24359       validate();
24360 
24361       oprot.writeStructBegin(STRUCT_DESC);
24362       if (this.tableName != null) {
24363         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
24364         oprot.writeBinary(this.tableName);
24365         oprot.writeFieldEnd();
24366       }
24367       if (this.row != null) {
24368         oprot.writeFieldBegin(ROW_FIELD_DESC);
24369         oprot.writeBinary(this.row);
24370         oprot.writeFieldEnd();
24371       }
24372       if (this.column != null) {
24373         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
24374         oprot.writeBinary(this.column);
24375         oprot.writeFieldEnd();
24376       }
24377       oprot.writeFieldBegin(VALUE_FIELD_DESC);
24378       oprot.writeI64(this.value);
24379       oprot.writeFieldEnd();
24380       oprot.writeFieldStop();
24381       oprot.writeStructEnd();
24382     }
24383 
24384     @Override
24385     public String toString() {
24386       StringBuilder sb = new StringBuilder("atomicIncrement_args(");
24387       boolean first = true;
24388 
24389       sb.append("tableName:");
24390       if (this.tableName == null) {
24391         sb.append("null");
24392       } else {
24393         sb.append(this.tableName);
24394       }
24395       first = false;
24396       if (!first) sb.append(", ");
24397       sb.append("row:");
24398       if (this.row == null) {
24399         sb.append("null");
24400       } else {
24401         sb.append(this.row);
24402       }
24403       first = false;
24404       if (!first) sb.append(", ");
24405       sb.append("column:");
24406       if (this.column == null) {
24407         sb.append("null");
24408       } else {
24409         sb.append(this.column);
24410       }
24411       first = false;
24412       if (!first) sb.append(", ");
24413       sb.append("value:");
24414       sb.append(this.value);
24415       first = false;
24416       sb.append(")");
24417       return sb.toString();
24418     }
24419 
24420     public void validate() throws TException {
24421       // check for required fields
24422     }
24423 
24424   }
24425 
24426   public static class atomicIncrement_result implements TBase<atomicIncrement_result._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_result>   {
24427     private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_result");
24428 
24429     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short)0);
24430     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
24431     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
24432 
24433     public long success;
24434     public IOError io;
24435     public IllegalArgument ia;
24436 
24437     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
24438     public enum _Fields implements TFieldIdEnum {
24439       SUCCESS((short)0, "success"),
24440       IO((short)1, "io"),
24441       IA((short)2, "ia");
24442 
24443       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
24444       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
24445 
24446       static {
24447         for (_Fields field : EnumSet.allOf(_Fields.class)) {
24448           byId.put((int)field._thriftId, field);
24449           byName.put(field.getFieldName(), field);
24450         }
24451       }
24452 
24453       /**
24454        * Find the _Fields constant that matches fieldId, or null if its not found.
24455        */
24456       public static _Fields findByThriftId(int fieldId) {
24457         return byId.get(fieldId);
24458       }
24459 
24460       /**
24461        * Find the _Fields constant that matches fieldId, throwing an exception
24462        * if it is not found.
24463        */
24464       public static _Fields findByThriftIdOrThrow(int fieldId) {
24465         _Fields fields = findByThriftId(fieldId);
24466         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24467         return fields;
24468       }
24469 
24470       /**
24471        * Find the _Fields constant that matches name, or null if its not found.
24472        */
24473       public static _Fields findByName(String name) {
24474         return byName.get(name);
24475       }
24476 
24477       private final short _thriftId;
24478       private final String _fieldName;
24479 
24480       _Fields(short thriftId, String fieldName) {
24481         _thriftId = thriftId;
24482         _fieldName = fieldName;
24483       }
24484 
24485       public short getThriftFieldId() {
24486         return _thriftId;
24487       }
24488 
24489       public String getFieldName() {
24490         return _fieldName;
24491       }
24492     }
24493 
24494     // isset id assignments
24495     private static final int __SUCCESS_ISSET_ID = 0;
24496     private BitSet __isset_bit_vector = new BitSet(1);
24497 
24498     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24499       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
24500           new FieldValueMetaData(TType.I64)));
24501       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
24502           new FieldValueMetaData(TType.STRUCT)));
24503       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
24504           new FieldValueMetaData(TType.STRUCT)));
24505     }});
24506 
24507     static {
24508       FieldMetaData.addStructMetaDataMap(atomicIncrement_result.class, metaDataMap);
24509     }
24510 
24511     public atomicIncrement_result() {
24512     }
24513 
24514     public atomicIncrement_result(
24515       long success,
24516       IOError io,
24517       IllegalArgument ia)
24518     {
24519       this();
24520       this.success = success;
24521       setSuccessIsSet(true);
24522       this.io = io;
24523       this.ia = ia;
24524     }
24525 
24526     /**
24527      * Performs a deep copy on <i>other</i>.
24528      */
24529     public atomicIncrement_result(atomicIncrement_result other) {
24530       __isset_bit_vector.clear();
24531       __isset_bit_vector.or(other.__isset_bit_vector);
24532       this.success = other.success;
24533       if (other.isSetIo()) {
24534         this.io = new IOError(other.io);
24535       }
24536       if (other.isSetIa()) {
24537         this.ia = new IllegalArgument(other.ia);
24538       }
24539     }
24540 
24541     public atomicIncrement_result deepCopy() {
24542       return new atomicIncrement_result(this);
24543     }
24544 
24545     @Deprecated
24546     public atomicIncrement_result clone() {
24547       return new atomicIncrement_result(this);
24548     }
24549 
24550     public long getSuccess() {
24551       return this.success;
24552     }
24553 
24554     public atomicIncrement_result setSuccess(long success) {
24555       this.success = success;
24556       setSuccessIsSet(true);
24557       return this;
24558     }
24559 
24560     public void unsetSuccess() {
24561       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
24562     }
24563 
24564     /** Returns true if field success is set (has been asigned a value) and false otherwise */
24565     public boolean isSetSuccess() {
24566       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
24567     }
24568 
24569     public void setSuccessIsSet(boolean value) {
24570       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
24571     }
24572 
24573     public IOError getIo() {
24574       return this.io;
24575     }
24576 
24577     public atomicIncrement_result setIo(IOError io) {
24578       this.io = io;
24579       return this;
24580     }
24581 
24582     public void unsetIo() {
24583       this.io = null;
24584     }
24585 
24586     /** Returns true if field io is set (has been asigned a value) and false otherwise */
24587     public boolean isSetIo() {
24588       return this.io != null;
24589     }
24590 
24591     public void setIoIsSet(boolean value) {
24592       if (!value) {
24593         this.io = null;
24594       }
24595     }
24596 
24597     public IllegalArgument getIa() {
24598       return this.ia;
24599     }
24600 
24601     public atomicIncrement_result setIa(IllegalArgument ia) {
24602       this.ia = ia;
24603       return this;
24604     }
24605 
24606     public void unsetIa() {
24607       this.ia = null;
24608     }
24609 
24610     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
24611     public boolean isSetIa() {
24612       return this.ia != null;
24613     }
24614 
24615     public void setIaIsSet(boolean value) {
24616       if (!value) {
24617         this.ia = null;
24618       }
24619     }
24620 
24621     public void setFieldValue(_Fields field, Object value) {
24622       switch (field) {
24623       case SUCCESS:
24624         if (value == null) {
24625           unsetSuccess();
24626         } else {
24627           setSuccess((Long)value);
24628         }
24629         break;
24630 
24631       case IO:
24632         if (value == null) {
24633           unsetIo();
24634         } else {
24635           setIo((IOError)value);
24636         }
24637         break;
24638 
24639       case IA:
24640         if (value == null) {
24641           unsetIa();
24642         } else {
24643           setIa((IllegalArgument)value);
24644         }
24645         break;
24646 
24647       }
24648     }
24649 
24650     public void setFieldValue(int fieldID, Object value) {
24651       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
24652     }
24653 
24654     public Object getFieldValue(_Fields field) {
24655       switch (field) {
24656       case SUCCESS:
24657         return new Long(getSuccess());
24658 
24659       case IO:
24660         return getIo();
24661 
24662       case IA:
24663         return getIa();
24664 
24665       }
24666       throw new IllegalStateException();
24667     }
24668 
24669     public Object getFieldValue(int fieldId) {
24670       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
24671     }
24672 
24673     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
24674     public boolean isSet(_Fields field) {
24675       switch (field) {
24676       case SUCCESS:
24677         return isSetSuccess();
24678       case IO:
24679         return isSetIo();
24680       case IA:
24681         return isSetIa();
24682       }
24683       throw new IllegalStateException();
24684     }
24685 
24686     public boolean isSet(int fieldID) {
24687       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
24688     }
24689 
24690     @Override
24691     public boolean equals(Object that) {
24692       if (that == null)
24693         return false;
24694       if (that instanceof atomicIncrement_result)
24695         return this.equals((atomicIncrement_result)that);
24696       return false;
24697     }
24698 
24699     public boolean equals(atomicIncrement_result that) {
24700       if (that == null)
24701         return false;
24702 
24703       boolean this_present_success = true;
24704       boolean that_present_success = true;
24705       if (this_present_success || that_present_success) {
24706         if (!(this_present_success && that_present_success))
24707           return false;
24708         if (this.success != that.success)
24709           return false;
24710       }
24711 
24712       boolean this_present_io = true && this.isSetIo();
24713       boolean that_present_io = true && that.isSetIo();
24714       if (this_present_io || that_present_io) {
24715         if (!(this_present_io && that_present_io))
24716           return false;
24717         if (!this.io.equals(that.io))
24718           return false;
24719       }
24720 
24721       boolean this_present_ia = true && this.isSetIa();
24722       boolean that_present_ia = true && that.isSetIa();
24723       if (this_present_ia || that_present_ia) {
24724         if (!(this_present_ia && that_present_ia))
24725           return false;
24726         if (!this.ia.equals(that.ia))
24727           return false;
24728       }
24729 
24730       return true;
24731     }
24732 
24733     @Override
24734     public int hashCode() {
24735       HashCodeBuilder builder = new HashCodeBuilder();
24736 
24737       boolean present_success = true;
24738       builder.append(present_success);
24739       if (present_success)
24740         builder.append(success);
24741 
24742       boolean present_io = true && (isSetIo());
24743       builder.append(present_io);
24744       if (present_io)
24745         builder.append(io);
24746 
24747       boolean present_ia = true && (isSetIa());
24748       builder.append(present_ia);
24749       if (present_ia)
24750         builder.append(ia);
24751 
24752       return builder.toHashCode();
24753     }
24754 
24755     public int compareTo(atomicIncrement_result other) {
24756       if (!getClass().equals(other.getClass())) {
24757         return getClass().getName().compareTo(other.getClass().getName());
24758       }
24759 
24760       int lastComparison = 0;
24761       atomicIncrement_result typedOther = (atomicIncrement_result)other;
24762 
24763       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
24764       if (lastComparison != 0) {
24765         return lastComparison;
24766       }
24767       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
24768       if (lastComparison != 0) {
24769         return lastComparison;
24770       }
24771       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
24772       if (lastComparison != 0) {
24773         return lastComparison;
24774       }
24775       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
24776       if (lastComparison != 0) {
24777         return lastComparison;
24778       }
24779       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
24780       if (lastComparison != 0) {
24781         return lastComparison;
24782       }
24783       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
24784       if (lastComparison != 0) {
24785         return lastComparison;
24786       }
24787       return 0;
24788     }
24789 
24790     public void read(TProtocol iprot) throws TException {
24791       TField field;
24792       iprot.readStructBegin();
24793       while (true)
24794       {
24795         field = iprot.readFieldBegin();
24796         if (field.type == TType.STOP) {
24797           break;
24798         }
24799         _Fields fieldId = _Fields.findByThriftId(field.id);
24800         if (fieldId == null) {
24801           TProtocolUtil.skip(iprot, field.type);
24802         } else {
24803           switch (fieldId) {
24804             case SUCCESS:
24805               if (field.type == TType.I64) {
24806                 this.success = iprot.readI64();
24807                 setSuccessIsSet(true);
24808               } else {
24809                 TProtocolUtil.skip(iprot, field.type);
24810               }
24811               break;
24812             case IO:
24813               if (field.type == TType.STRUCT) {
24814                 this.io = new IOError();
24815                 this.io.read(iprot);
24816               } else {
24817                 TProtocolUtil.skip(iprot, field.type);
24818               }
24819               break;
24820             case IA:
24821               if (field.type == TType.STRUCT) {
24822                 this.ia = new IllegalArgument();
24823                 this.ia.read(iprot);
24824               } else {
24825                 TProtocolUtil.skip(iprot, field.type);
24826               }
24827               break;
24828           }
24829           iprot.readFieldEnd();
24830         }
24831       }
24832       iprot.readStructEnd();
24833 
24834       // check for required fields of primitive type, which can't be checked in the validate method
24835       validate();
24836     }
24837 
24838     public void write(TProtocol oprot) throws TException {
24839       oprot.writeStructBegin(STRUCT_DESC);
24840 
24841       if (this.isSetSuccess()) {
24842         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
24843         oprot.writeI64(this.success);
24844         oprot.writeFieldEnd();
24845       } else if (this.isSetIo()) {
24846         oprot.writeFieldBegin(IO_FIELD_DESC);
24847         this.io.write(oprot);
24848         oprot.writeFieldEnd();
24849       } else if (this.isSetIa()) {
24850         oprot.writeFieldBegin(IA_FIELD_DESC);
24851         this.ia.write(oprot);
24852         oprot.writeFieldEnd();
24853       }
24854       oprot.writeFieldStop();
24855       oprot.writeStructEnd();
24856     }
24857 
24858     @Override
24859     public String toString() {
24860       StringBuilder sb = new StringBuilder("atomicIncrement_result(");
24861       boolean first = true;
24862 
24863       sb.append("success:");
24864       sb.append(this.success);
24865       first = false;
24866       if (!first) sb.append(", ");
24867       sb.append("io:");
24868       if (this.io == null) {
24869         sb.append("null");
24870       } else {
24871         sb.append(this.io);
24872       }
24873       first = false;
24874       if (!first) sb.append(", ");
24875       sb.append("ia:");
24876       if (this.ia == null) {
24877         sb.append("null");
24878       } else {
24879         sb.append(this.ia);
24880       }
24881       first = false;
24882       sb.append(")");
24883       return sb.toString();
24884     }
24885 
24886     public void validate() throws TException {
24887       // check for required fields
24888     }
24889 
24890   }
24891 
24892   public static class deleteAll_args implements TBase<deleteAll_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_args>   {
24893     private static final TStruct STRUCT_DESC = new TStruct("deleteAll_args");
24894 
24895     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
24896     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
24897     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
24898 
24899     /**
24900      * name of table
24901      */
24902     public byte[] tableName;
24903     /**
24904      * Row to update
24905      */
24906     public byte[] row;
24907     /**
24908      * name of column whose value is to be deleted
24909      */
24910     public byte[] column;
24911 
24912     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
24913     public enum _Fields implements TFieldIdEnum {
24914       /**
24915        * name of table
24916        */
24917       TABLE_NAME((short)1, "tableName"),
24918       /**
24919        * Row to update
24920        */
24921       ROW((short)2, "row"),
24922       /**
24923        * name of column whose value is to be deleted
24924        */
24925       COLUMN((short)3, "column");
24926 
24927       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
24928       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
24929 
24930       static {
24931         for (_Fields field : EnumSet.allOf(_Fields.class)) {
24932           byId.put((int)field._thriftId, field);
24933           byName.put(field.getFieldName(), field);
24934         }
24935       }
24936 
24937       /**
24938        * Find the _Fields constant that matches fieldId, or null if its not found.
24939        */
24940       public static _Fields findByThriftId(int fieldId) {
24941         return byId.get(fieldId);
24942       }
24943 
24944       /**
24945        * Find the _Fields constant that matches fieldId, throwing an exception
24946        * if it is not found.
24947        */
24948       public static _Fields findByThriftIdOrThrow(int fieldId) {
24949         _Fields fields = findByThriftId(fieldId);
24950         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24951         return fields;
24952       }
24953 
24954       /**
24955        * Find the _Fields constant that matches name, or null if its not found.
24956        */
24957       public static _Fields findByName(String name) {
24958         return byName.get(name);
24959       }
24960 
24961       private final short _thriftId;
24962       private final String _fieldName;
24963 
24964       _Fields(short thriftId, String fieldName) {
24965         _thriftId = thriftId;
24966         _fieldName = fieldName;
24967       }
24968 
24969       public short getThriftFieldId() {
24970         return _thriftId;
24971       }
24972 
24973       public String getFieldName() {
24974         return _fieldName;
24975       }
24976     }
24977 
24978     // isset id assignments
24979 
24980     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24981       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
24982           new FieldValueMetaData(TType.STRING)));
24983       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
24984           new FieldValueMetaData(TType.STRING)));
24985       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
24986           new FieldValueMetaData(TType.STRING)));
24987     }});
24988 
24989     static {
24990       FieldMetaData.addStructMetaDataMap(deleteAll_args.class, metaDataMap);
24991     }
24992 
24993     public deleteAll_args() {
24994     }
24995 
24996     public deleteAll_args(
24997       byte[] tableName,
24998       byte[] row,
24999       byte[] column)
25000     {
25001       this();
25002       this.tableName = tableName;
25003       this.row = row;
25004       this.column = column;
25005     }
25006 
25007     /**
25008      * Performs a deep copy on <i>other</i>.
25009      */
25010     public deleteAll_args(deleteAll_args other) {
25011       if (other.isSetTableName()) {
25012         this.tableName = other.tableName;
25013       }
25014       if (other.isSetRow()) {
25015         this.row = other.row;
25016       }
25017       if (other.isSetColumn()) {
25018         this.column = other.column;
25019       }
25020     }
25021 
25022     public deleteAll_args deepCopy() {
25023       return new deleteAll_args(this);
25024     }
25025 
25026     @Deprecated
25027     public deleteAll_args clone() {
25028       return new deleteAll_args(this);
25029     }
25030 
25031     /**
25032      * name of table
25033      */
25034     public byte[] getTableName() {
25035       return this.tableName;
25036     }
25037 
25038     /**
25039      * name of table
25040      */
25041     public deleteAll_args setTableName(byte[] tableName) {
25042       this.tableName = tableName;
25043       return this;
25044     }
25045 
25046     public void unsetTableName() {
25047       this.tableName = null;
25048     }
25049 
25050     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
25051     public boolean isSetTableName() {
25052       return this.tableName != null;
25053     }
25054 
25055     public void setTableNameIsSet(boolean value) {
25056       if (!value) {
25057         this.tableName = null;
25058       }
25059     }
25060 
25061     /**
25062      * Row to update
25063      */
25064     public byte[] getRow() {
25065       return this.row;
25066     }
25067 
25068     /**
25069      * Row to update
25070      */
25071     public deleteAll_args setRow(byte[] row) {
25072       this.row = row;
25073       return this;
25074     }
25075 
25076     public void unsetRow() {
25077       this.row = null;
25078     }
25079 
25080     /** Returns true if field row is set (has been asigned a value) and false otherwise */
25081     public boolean isSetRow() {
25082       return this.row != null;
25083     }
25084 
25085     public void setRowIsSet(boolean value) {
25086       if (!value) {
25087         this.row = null;
25088       }
25089     }
25090 
25091     /**
25092      * name of column whose value is to be deleted
25093      */
25094     public byte[] getColumn() {
25095       return this.column;
25096     }
25097 
25098     /**
25099      * name of column whose value is to be deleted
25100      */
25101     public deleteAll_args setColumn(byte[] column) {
25102       this.column = column;
25103       return this;
25104     }
25105 
25106     public void unsetColumn() {
25107       this.column = null;
25108     }
25109 
25110     /** Returns true if field column is set (has been asigned a value) and false otherwise */
25111     public boolean isSetColumn() {
25112       return this.column != null;
25113     }
25114 
25115     public void setColumnIsSet(boolean value) {
25116       if (!value) {
25117         this.column = null;
25118       }
25119     }
25120 
25121     public void setFieldValue(_Fields field, Object value) {
25122       switch (field) {
25123       case TABLE_NAME:
25124         if (value == null) {
25125           unsetTableName();
25126         } else {
25127           setTableName((byte[])value);
25128         }
25129         break;
25130 
25131       case ROW:
25132         if (value == null) {
25133           unsetRow();
25134         } else {
25135           setRow((byte[])value);
25136         }
25137         break;
25138 
25139       case COLUMN:
25140         if (value == null) {
25141           unsetColumn();
25142         } else {
25143           setColumn((byte[])value);
25144         }
25145         break;
25146 
25147       }
25148     }
25149 
25150     public void setFieldValue(int fieldID, Object value) {
25151       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
25152     }
25153 
25154     public Object getFieldValue(_Fields field) {
25155       switch (field) {
25156       case TABLE_NAME:
25157         return getTableName();
25158 
25159       case ROW:
25160         return getRow();
25161 
25162       case COLUMN:
25163         return getColumn();
25164 
25165       }
25166       throw new IllegalStateException();
25167     }
25168 
25169     public Object getFieldValue(int fieldId) {
25170       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
25171     }
25172 
25173     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
25174     public boolean isSet(_Fields field) {
25175       switch (field) {
25176       case TABLE_NAME:
25177         return isSetTableName();
25178       case ROW:
25179         return isSetRow();
25180       case COLUMN:
25181         return isSetColumn();
25182       }
25183       throw new IllegalStateException();
25184     }
25185 
25186     public boolean isSet(int fieldID) {
25187       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
25188     }
25189 
25190     @Override
25191     public boolean equals(Object that) {
25192       if (that == null)
25193         return false;
25194       if (that instanceof deleteAll_args)
25195         return this.equals((deleteAll_args)that);
25196       return false;
25197     }
25198 
25199     public boolean equals(deleteAll_args that) {
25200       if (that == null)
25201         return false;
25202 
25203       boolean this_present_tableName = true && this.isSetTableName();
25204       boolean that_present_tableName = true && that.isSetTableName();
25205       if (this_present_tableName || that_present_tableName) {
25206         if (!(this_present_tableName && that_present_tableName))
25207           return false;
25208         if (!java.util.Arrays.equals(this.tableName, that.tableName))
25209           return false;
25210       }
25211 
25212       boolean this_present_row = true && this.isSetRow();
25213       boolean that_present_row = true && that.isSetRow();
25214       if (this_present_row || that_present_row) {
25215         if (!(this_present_row && that_present_row))
25216           return false;
25217         if (!java.util.Arrays.equals(this.row, that.row))
25218           return false;
25219       }
25220 
25221       boolean this_present_column = true && this.isSetColumn();
25222       boolean that_present_column = true && that.isSetColumn();
25223       if (this_present_column || that_present_column) {
25224         if (!(this_present_column && that_present_column))
25225           return false;
25226         if (!java.util.Arrays.equals(this.column, that.column))
25227           return false;
25228       }
25229 
25230       return true;
25231     }
25232 
25233     @Override
25234     public int hashCode() {
25235       HashCodeBuilder builder = new HashCodeBuilder();
25236 
25237       boolean present_tableName = true && (isSetTableName());
25238       builder.append(present_tableName);
25239       if (present_tableName)
25240         builder.append(tableName);
25241 
25242       boolean present_row = true && (isSetRow());
25243       builder.append(present_row);
25244       if (present_row)
25245         builder.append(row);
25246 
25247       boolean present_column = true && (isSetColumn());
25248       builder.append(present_column);
25249       if (present_column)
25250         builder.append(column);
25251 
25252       return builder.toHashCode();
25253     }
25254 
25255     public int compareTo(deleteAll_args other) {
25256       if (!getClass().equals(other.getClass())) {
25257         return getClass().getName().compareTo(other.getClass().getName());
25258       }
25259 
25260       int lastComparison = 0;
25261       deleteAll_args typedOther = (deleteAll_args)other;
25262 
25263       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
25264       if (lastComparison != 0) {
25265         return lastComparison;
25266       }
25267       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
25268       if (lastComparison != 0) {
25269         return lastComparison;
25270       }
25271       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
25272       if (lastComparison != 0) {
25273         return lastComparison;
25274       }
25275       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
25276       if (lastComparison != 0) {
25277         return lastComparison;
25278       }
25279       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
25280       if (lastComparison != 0) {
25281         return lastComparison;
25282       }
25283       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
25284       if (lastComparison != 0) {
25285         return lastComparison;
25286       }
25287       return 0;
25288     }
25289 
25290     public void read(TProtocol iprot) throws TException {
25291       TField field;
25292       iprot.readStructBegin();
25293       while (true)
25294       {
25295         field = iprot.readFieldBegin();
25296         if (field.type == TType.STOP) {
25297           break;
25298         }
25299         _Fields fieldId = _Fields.findByThriftId(field.id);
25300         if (fieldId == null) {
25301           TProtocolUtil.skip(iprot, field.type);
25302         } else {
25303           switch (fieldId) {
25304             case TABLE_NAME:
25305               if (field.type == TType.STRING) {
25306                 this.tableName = iprot.readBinary();
25307               } else {
25308                 TProtocolUtil.skip(iprot, field.type);
25309               }
25310               break;
25311             case ROW:
25312               if (field.type == TType.STRING) {
25313                 this.row = iprot.readBinary();
25314               } else {
25315                 TProtocolUtil.skip(iprot, field.type);
25316               }
25317               break;
25318             case COLUMN:
25319               if (field.type == TType.STRING) {
25320                 this.column = iprot.readBinary();
25321               } else {
25322                 TProtocolUtil.skip(iprot, field.type);
25323               }
25324               break;
25325           }
25326           iprot.readFieldEnd();
25327         }
25328       }
25329       iprot.readStructEnd();
25330 
25331       // check for required fields of primitive type, which can't be checked in the validate method
25332       validate();
25333     }
25334 
25335     public void write(TProtocol oprot) throws TException {
25336       validate();
25337 
25338       oprot.writeStructBegin(STRUCT_DESC);
25339       if (this.tableName != null) {
25340         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
25341         oprot.writeBinary(this.tableName);
25342         oprot.writeFieldEnd();
25343       }
25344       if (this.row != null) {
25345         oprot.writeFieldBegin(ROW_FIELD_DESC);
25346         oprot.writeBinary(this.row);
25347         oprot.writeFieldEnd();
25348       }
25349       if (this.column != null) {
25350         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
25351         oprot.writeBinary(this.column);
25352         oprot.writeFieldEnd();
25353       }
25354       oprot.writeFieldStop();
25355       oprot.writeStructEnd();
25356     }
25357 
25358     @Override
25359     public String toString() {
25360       StringBuilder sb = new StringBuilder("deleteAll_args(");
25361       boolean first = true;
25362 
25363       sb.append("tableName:");
25364       if (this.tableName == null) {
25365         sb.append("null");
25366       } else {
25367         sb.append(this.tableName);
25368       }
25369       first = false;
25370       if (!first) sb.append(", ");
25371       sb.append("row:");
25372       if (this.row == null) {
25373         sb.append("null");
25374       } else {
25375         sb.append(this.row);
25376       }
25377       first = false;
25378       if (!first) sb.append(", ");
25379       sb.append("column:");
25380       if (this.column == null) {
25381         sb.append("null");
25382       } else {
25383         sb.append(this.column);
25384       }
25385       first = false;
25386       sb.append(")");
25387       return sb.toString();
25388     }
25389 
25390     public void validate() throws TException {
25391       // check for required fields
25392     }
25393 
25394   }
25395 
25396   public static class deleteAll_result implements TBase<deleteAll_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_result>   {
25397     private static final TStruct STRUCT_DESC = new TStruct("deleteAll_result");
25398 
25399     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
25400 
25401     public IOError io;
25402 
25403     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
25404     public enum _Fields implements TFieldIdEnum {
25405       IO((short)1, "io");
25406 
25407       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
25408       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
25409 
25410       static {
25411         for (_Fields field : EnumSet.allOf(_Fields.class)) {
25412           byId.put((int)field._thriftId, field);
25413           byName.put(field.getFieldName(), field);
25414         }
25415       }
25416 
25417       /**
25418        * Find the _Fields constant that matches fieldId, or null if its not found.
25419        */
25420       public static _Fields findByThriftId(int fieldId) {
25421         return byId.get(fieldId);
25422       }
25423 
25424       /**
25425        * Find the _Fields constant that matches fieldId, throwing an exception
25426        * if it is not found.
25427        */
25428       public static _Fields findByThriftIdOrThrow(int fieldId) {
25429         _Fields fields = findByThriftId(fieldId);
25430         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
25431         return fields;
25432       }
25433 
25434       /**
25435        * Find the _Fields constant that matches name, or null if its not found.
25436        */
25437       public static _Fields findByName(String name) {
25438         return byName.get(name);
25439       }
25440 
25441       private final short _thriftId;
25442       private final String _fieldName;
25443 
25444       _Fields(short thriftId, String fieldName) {
25445         _thriftId = thriftId;
25446         _fieldName = fieldName;
25447       }
25448 
25449       public short getThriftFieldId() {
25450         return _thriftId;
25451       }
25452 
25453       public String getFieldName() {
25454         return _fieldName;
25455       }
25456     }
25457 
25458     // isset id assignments
25459 
25460     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
25461       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
25462           new FieldValueMetaData(TType.STRUCT)));
25463     }});
25464 
25465     static {
25466       FieldMetaData.addStructMetaDataMap(deleteAll_result.class, metaDataMap);
25467     }
25468 
25469     public deleteAll_result() {
25470     }
25471 
25472     public deleteAll_result(
25473       IOError io)
25474     {
25475       this();
25476       this.io = io;
25477     }
25478 
25479     /**
25480      * Performs a deep copy on <i>other</i>.
25481      */
25482     public deleteAll_result(deleteAll_result other) {
25483       if (other.isSetIo()) {
25484         this.io = new IOError(other.io);
25485       }
25486     }
25487 
25488     public deleteAll_result deepCopy() {
25489       return new deleteAll_result(this);
25490     }
25491 
25492     @Deprecated
25493     public deleteAll_result clone() {
25494       return new deleteAll_result(this);
25495     }
25496 
25497     public IOError getIo() {
25498       return this.io;
25499     }
25500 
25501     public deleteAll_result setIo(IOError io) {
25502       this.io = io;
25503       return this;
25504     }
25505 
25506     public void unsetIo() {
25507       this.io = null;
25508     }
25509 
25510     /** Returns true if field io is set (has been asigned a value) and false otherwise */
25511     public boolean isSetIo() {
25512       return this.io != null;
25513     }
25514 
25515     public void setIoIsSet(boolean value) {
25516       if (!value) {
25517         this.io = null;
25518       }
25519     }
25520 
25521     public void setFieldValue(_Fields field, Object value) {
25522       switch (field) {
25523       case IO:
25524         if (value == null) {
25525           unsetIo();
25526         } else {
25527           setIo((IOError)value);
25528         }
25529         break;
25530 
25531       }
25532     }
25533 
25534     public void setFieldValue(int fieldID, Object value) {
25535       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
25536     }
25537 
25538     public Object getFieldValue(_Fields field) {
25539       switch (field) {
25540       case IO:
25541         return getIo();
25542 
25543       }
25544       throw new IllegalStateException();
25545     }
25546 
25547     public Object getFieldValue(int fieldId) {
25548       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
25549     }
25550 
25551     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
25552     public boolean isSet(_Fields field) {
25553       switch (field) {
25554       case IO:
25555         return isSetIo();
25556       }
25557       throw new IllegalStateException();
25558     }
25559 
25560     public boolean isSet(int fieldID) {
25561       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
25562     }
25563 
25564     @Override
25565     public boolean equals(Object that) {
25566       if (that == null)
25567         return false;
25568       if (that instanceof deleteAll_result)
25569         return this.equals((deleteAll_result)that);
25570       return false;
25571     }
25572 
25573     public boolean equals(deleteAll_result that) {
25574       if (that == null)
25575         return false;
25576 
25577       boolean this_present_io = true && this.isSetIo();
25578       boolean that_present_io = true && that.isSetIo();
25579       if (this_present_io || that_present_io) {
25580         if (!(this_present_io && that_present_io))
25581           return false;
25582         if (!this.io.equals(that.io))
25583           return false;
25584       }
25585 
25586       return true;
25587     }
25588 
25589     @Override
25590     public int hashCode() {
25591       HashCodeBuilder builder = new HashCodeBuilder();
25592 
25593       boolean present_io = true && (isSetIo());
25594       builder.append(present_io);
25595       if (present_io)
25596         builder.append(io);
25597 
25598       return builder.toHashCode();
25599     }
25600 
25601     public int compareTo(deleteAll_result other) {
25602       if (!getClass().equals(other.getClass())) {
25603         return getClass().getName().compareTo(other.getClass().getName());
25604       }
25605 
25606       int lastComparison = 0;
25607       deleteAll_result typedOther = (deleteAll_result)other;
25608 
25609       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
25610       if (lastComparison != 0) {
25611         return lastComparison;
25612       }
25613       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
25614       if (lastComparison != 0) {
25615         return lastComparison;
25616       }
25617       return 0;
25618     }
25619 
25620     public void read(TProtocol iprot) throws TException {
25621       TField field;
25622       iprot.readStructBegin();
25623       while (true)
25624       {
25625         field = iprot.readFieldBegin();
25626         if (field.type == TType.STOP) {
25627           break;
25628         }
25629         _Fields fieldId = _Fields.findByThriftId(field.id);
25630         if (fieldId == null) {
25631           TProtocolUtil.skip(iprot, field.type);
25632         } else {
25633           switch (fieldId) {
25634             case IO:
25635               if (field.type == TType.STRUCT) {
25636                 this.io = new IOError();
25637                 this.io.read(iprot);
25638               } else {
25639                 TProtocolUtil.skip(iprot, field.type);
25640               }
25641               break;
25642           }
25643           iprot.readFieldEnd();
25644         }
25645       }
25646       iprot.readStructEnd();
25647 
25648       // check for required fields of primitive type, which can't be checked in the validate method
25649       validate();
25650     }
25651 
25652     public void write(TProtocol oprot) throws TException {
25653       oprot.writeStructBegin(STRUCT_DESC);
25654 
25655       if (this.isSetIo()) {
25656         oprot.writeFieldBegin(IO_FIELD_DESC);
25657         this.io.write(oprot);
25658         oprot.writeFieldEnd();
25659       }
25660       oprot.writeFieldStop();
25661       oprot.writeStructEnd();
25662     }
25663 
25664     @Override
25665     public String toString() {
25666       StringBuilder sb = new StringBuilder("deleteAll_result(");
25667       boolean first = true;
25668 
25669       sb.append("io:");
25670       if (this.io == null) {
25671         sb.append("null");
25672       } else {
25673         sb.append(this.io);
25674       }
25675       first = false;
25676       sb.append(")");
25677       return sb.toString();
25678     }
25679 
25680     public void validate() throws TException {
25681       // check for required fields
25682     }
25683 
25684   }
25685 
25686   public static class deleteAllTs_args implements TBase<deleteAllTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_args>   {
25687     private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_args");
25688 
25689     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
25690     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
25691     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
25692     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
25693 
25694     /**
25695      * name of table
25696      */
25697     public byte[] tableName;
25698     /**
25699      * Row to update
25700      */
25701     public byte[] row;
25702     /**
25703      * name of column whose value is to be deleted
25704      */
25705     public byte[] column;
25706     /**
25707      * timestamp
25708      */
25709     public long timestamp;
25710 
25711     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
25712     public enum _Fields implements TFieldIdEnum {
25713       /**
25714        * name of table
25715        */
25716       TABLE_NAME((short)1, "tableName"),
25717       /**
25718        * Row to update
25719        */
25720       ROW((short)2, "row"),
25721       /**
25722        * name of column whose value is to be deleted
25723        */
25724       COLUMN((short)3, "column"),
25725       /**
25726        * timestamp
25727        */
25728       TIMESTAMP((short)4, "timestamp");
25729 
25730       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
25731       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
25732 
25733       static {
25734         for (_Fields field : EnumSet.allOf(_Fields.class)) {
25735           byId.put((int)field._thriftId, field);
25736           byName.put(field.getFieldName(), field);
25737         }
25738       }
25739 
25740       /**
25741        * Find the _Fields constant that matches fieldId, or null if its not found.
25742        */
25743       public static _Fields findByThriftId(int fieldId) {
25744         return byId.get(fieldId);
25745       }
25746 
25747       /**
25748        * Find the _Fields constant that matches fieldId, throwing an exception
25749        * if it is not found.
25750        */
25751       public static _Fields findByThriftIdOrThrow(int fieldId) {
25752         _Fields fields = findByThriftId(fieldId);
25753         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
25754         return fields;
25755       }
25756 
25757       /**
25758        * Find the _Fields constant that matches name, or null if its not found.
25759        */
25760       public static _Fields findByName(String name) {
25761         return byName.get(name);
25762       }
25763 
25764       private final short _thriftId;
25765       private final String _fieldName;
25766 
25767       _Fields(short thriftId, String fieldName) {
25768         _thriftId = thriftId;
25769         _fieldName = fieldName;
25770       }
25771 
25772       public short getThriftFieldId() {
25773         return _thriftId;
25774       }
25775 
25776       public String getFieldName() {
25777         return _fieldName;
25778       }
25779     }
25780 
25781     // isset id assignments
25782     private static final int __TIMESTAMP_ISSET_ID = 0;
25783     private BitSet __isset_bit_vector = new BitSet(1);
25784 
25785     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
25786       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
25787           new FieldValueMetaData(TType.STRING)));
25788       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
25789           new FieldValueMetaData(TType.STRING)));
25790       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
25791           new FieldValueMetaData(TType.STRING)));
25792       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
25793           new FieldValueMetaData(TType.I64)));
25794     }});
25795 
25796     static {
25797       FieldMetaData.addStructMetaDataMap(deleteAllTs_args.class, metaDataMap);
25798     }
25799 
25800     public deleteAllTs_args() {
25801     }
25802 
25803     public deleteAllTs_args(
25804       byte[] tableName,
25805       byte[] row,
25806       byte[] column,
25807       long timestamp)
25808     {
25809       this();
25810       this.tableName = tableName;
25811       this.row = row;
25812       this.column = column;
25813       this.timestamp = timestamp;
25814       setTimestampIsSet(true);
25815     }
25816 
25817     /**
25818      * Performs a deep copy on <i>other</i>.
25819      */
25820     public deleteAllTs_args(deleteAllTs_args other) {
25821       __isset_bit_vector.clear();
25822       __isset_bit_vector.or(other.__isset_bit_vector);
25823       if (other.isSetTableName()) {
25824         this.tableName = other.tableName;
25825       }
25826       if (other.isSetRow()) {
25827         this.row = other.row;
25828       }
25829       if (other.isSetColumn()) {
25830         this.column = other.column;
25831       }
25832       this.timestamp = other.timestamp;
25833     }
25834 
25835     public deleteAllTs_args deepCopy() {
25836       return new deleteAllTs_args(this);
25837     }
25838 
25839     @Deprecated
25840     public deleteAllTs_args clone() {
25841       return new deleteAllTs_args(this);
25842     }
25843 
25844     /**
25845      * name of table
25846      */
25847     public byte[] getTableName() {
25848       return this.tableName;
25849     }
25850 
25851     /**
25852      * name of table
25853      */
25854     public deleteAllTs_args setTableName(byte[] tableName) {
25855       this.tableName = tableName;
25856       return this;
25857     }
25858 
25859     public void unsetTableName() {
25860       this.tableName = null;
25861     }
25862 
25863     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
25864     public boolean isSetTableName() {
25865       return this.tableName != null;
25866     }
25867 
25868     public void setTableNameIsSet(boolean value) {
25869       if (!value) {
25870         this.tableName = null;
25871       }
25872     }
25873 
25874     /**
25875      * Row to update
25876      */
25877     public byte[] getRow() {
25878       return this.row;
25879     }
25880 
25881     /**
25882      * Row to update
25883      */
25884     public deleteAllTs_args setRow(byte[] row) {
25885       this.row = row;
25886       return this;
25887     }
25888 
25889     public void unsetRow() {
25890       this.row = null;
25891     }
25892 
25893     /** Returns true if field row is set (has been asigned a value) and false otherwise */
25894     public boolean isSetRow() {
25895       return this.row != null;
25896     }
25897 
25898     public void setRowIsSet(boolean value) {
25899       if (!value) {
25900         this.row = null;
25901       }
25902     }
25903 
25904     /**
25905      * name of column whose value is to be deleted
25906      */
25907     public byte[] getColumn() {
25908       return this.column;
25909     }
25910 
25911     /**
25912      * name of column whose value is to be deleted
25913      */
25914     public deleteAllTs_args setColumn(byte[] column) {
25915       this.column = column;
25916       return this;
25917     }
25918 
25919     public void unsetColumn() {
25920       this.column = null;
25921     }
25922 
25923     /** Returns true if field column is set (has been asigned a value) and false otherwise */
25924     public boolean isSetColumn() {
25925       return this.column != null;
25926     }
25927 
25928     public void setColumnIsSet(boolean value) {
25929       if (!value) {
25930         this.column = null;
25931       }
25932     }
25933 
25934     /**
25935      * timestamp
25936      */
25937     public long getTimestamp() {
25938       return this.timestamp;
25939     }
25940 
25941     /**
25942      * timestamp
25943      */
25944     public deleteAllTs_args setTimestamp(long timestamp) {
25945       this.timestamp = timestamp;
25946       setTimestampIsSet(true);
25947       return this;
25948     }
25949 
25950     public void unsetTimestamp() {
25951       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
25952     }
25953 
25954     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
25955     public boolean isSetTimestamp() {
25956       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
25957     }
25958 
25959     public void setTimestampIsSet(boolean value) {
25960       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
25961     }
25962 
25963     public void setFieldValue(_Fields field, Object value) {
25964       switch (field) {
25965       case TABLE_NAME:
25966         if (value == null) {
25967           unsetTableName();
25968         } else {
25969           setTableName((byte[])value);
25970         }
25971         break;
25972 
25973       case ROW:
25974         if (value == null) {
25975           unsetRow();
25976         } else {
25977           setRow((byte[])value);
25978         }
25979         break;
25980 
25981       case COLUMN:
25982         if (value == null) {
25983           unsetColumn();
25984         } else {
25985           setColumn((byte[])value);
25986         }
25987         break;
25988 
25989       case TIMESTAMP:
25990         if (value == null) {
25991           unsetTimestamp();
25992         } else {
25993           setTimestamp((Long)value);
25994         }
25995         break;
25996 
25997       }
25998     }
25999 
26000     public void setFieldValue(int fieldID, Object value) {
26001       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26002     }
26003 
26004     public Object getFieldValue(_Fields field) {
26005       switch (field) {
26006       case TABLE_NAME:
26007         return getTableName();
26008 
26009       case ROW:
26010         return getRow();
26011 
26012       case COLUMN:
26013         return getColumn();
26014 
26015       case TIMESTAMP:
26016         return new Long(getTimestamp());
26017 
26018       }
26019       throw new IllegalStateException();
26020     }
26021 
26022     public Object getFieldValue(int fieldId) {
26023       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26024     }
26025 
26026     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
26027     public boolean isSet(_Fields field) {
26028       switch (field) {
26029       case TABLE_NAME:
26030         return isSetTableName();
26031       case ROW:
26032         return isSetRow();
26033       case COLUMN:
26034         return isSetColumn();
26035       case TIMESTAMP:
26036         return isSetTimestamp();
26037       }
26038       throw new IllegalStateException();
26039     }
26040 
26041     public boolean isSet(int fieldID) {
26042       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26043     }
26044 
26045     @Override
26046     public boolean equals(Object that) {
26047       if (that == null)
26048         return false;
26049       if (that instanceof deleteAllTs_args)
26050         return this.equals((deleteAllTs_args)that);
26051       return false;
26052     }
26053 
26054     public boolean equals(deleteAllTs_args that) {
26055       if (that == null)
26056         return false;
26057 
26058       boolean this_present_tableName = true && this.isSetTableName();
26059       boolean that_present_tableName = true && that.isSetTableName();
26060       if (this_present_tableName || that_present_tableName) {
26061         if (!(this_present_tableName && that_present_tableName))
26062           return false;
26063         if (!java.util.Arrays.equals(this.tableName, that.tableName))
26064           return false;
26065       }
26066 
26067       boolean this_present_row = true && this.isSetRow();
26068       boolean that_present_row = true && that.isSetRow();
26069       if (this_present_row || that_present_row) {
26070         if (!(this_present_row && that_present_row))
26071           return false;
26072         if (!java.util.Arrays.equals(this.row, that.row))
26073           return false;
26074       }
26075 
26076       boolean this_present_column = true && this.isSetColumn();
26077       boolean that_present_column = true && that.isSetColumn();
26078       if (this_present_column || that_present_column) {
26079         if (!(this_present_column && that_present_column))
26080           return false;
26081         if (!java.util.Arrays.equals(this.column, that.column))
26082           return false;
26083       }
26084 
26085       boolean this_present_timestamp = true;
26086       boolean that_present_timestamp = true;
26087       if (this_present_timestamp || that_present_timestamp) {
26088         if (!(this_present_timestamp && that_present_timestamp))
26089           return false;
26090         if (this.timestamp != that.timestamp)
26091           return false;
26092       }
26093 
26094       return true;
26095     }
26096 
26097     @Override
26098     public int hashCode() {
26099       HashCodeBuilder builder = new HashCodeBuilder();
26100 
26101       boolean present_tableName = true && (isSetTableName());
26102       builder.append(present_tableName);
26103       if (present_tableName)
26104         builder.append(tableName);
26105 
26106       boolean present_row = true && (isSetRow());
26107       builder.append(present_row);
26108       if (present_row)
26109         builder.append(row);
26110 
26111       boolean present_column = true && (isSetColumn());
26112       builder.append(present_column);
26113       if (present_column)
26114         builder.append(column);
26115 
26116       boolean present_timestamp = true;
26117       builder.append(present_timestamp);
26118       if (present_timestamp)
26119         builder.append(timestamp);
26120 
26121       return builder.toHashCode();
26122     }
26123 
26124     public int compareTo(deleteAllTs_args other) {
26125       if (!getClass().equals(other.getClass())) {
26126         return getClass().getName().compareTo(other.getClass().getName());
26127       }
26128 
26129       int lastComparison = 0;
26130       deleteAllTs_args typedOther = (deleteAllTs_args)other;
26131 
26132       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
26133       if (lastComparison != 0) {
26134         return lastComparison;
26135       }
26136       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
26137       if (lastComparison != 0) {
26138         return lastComparison;
26139       }
26140       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
26141       if (lastComparison != 0) {
26142         return lastComparison;
26143       }
26144       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
26145       if (lastComparison != 0) {
26146         return lastComparison;
26147       }
26148       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
26149       if (lastComparison != 0) {
26150         return lastComparison;
26151       }
26152       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
26153       if (lastComparison != 0) {
26154         return lastComparison;
26155       }
26156       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
26157       if (lastComparison != 0) {
26158         return lastComparison;
26159       }
26160       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
26161       if (lastComparison != 0) {
26162         return lastComparison;
26163       }
26164       return 0;
26165     }
26166 
26167     public void read(TProtocol iprot) throws TException {
26168       TField field;
26169       iprot.readStructBegin();
26170       while (true)
26171       {
26172         field = iprot.readFieldBegin();
26173         if (field.type == TType.STOP) {
26174           break;
26175         }
26176         _Fields fieldId = _Fields.findByThriftId(field.id);
26177         if (fieldId == null) {
26178           TProtocolUtil.skip(iprot, field.type);
26179         } else {
26180           switch (fieldId) {
26181             case TABLE_NAME:
26182               if (field.type == TType.STRING) {
26183                 this.tableName = iprot.readBinary();
26184               } else {
26185                 TProtocolUtil.skip(iprot, field.type);
26186               }
26187               break;
26188             case ROW:
26189               if (field.type == TType.STRING) {
26190                 this.row = iprot.readBinary();
26191               } else {
26192                 TProtocolUtil.skip(iprot, field.type);
26193               }
26194               break;
26195             case COLUMN:
26196               if (field.type == TType.STRING) {
26197                 this.column = iprot.readBinary();
26198               } else {
26199                 TProtocolUtil.skip(iprot, field.type);
26200               }
26201               break;
26202             case TIMESTAMP:
26203               if (field.type == TType.I64) {
26204                 this.timestamp = iprot.readI64();
26205                 setTimestampIsSet(true);
26206               } else {
26207                 TProtocolUtil.skip(iprot, field.type);
26208               }
26209               break;
26210           }
26211           iprot.readFieldEnd();
26212         }
26213       }
26214       iprot.readStructEnd();
26215 
26216       // check for required fields of primitive type, which can't be checked in the validate method
26217       validate();
26218     }
26219 
26220     public void write(TProtocol oprot) throws TException {
26221       validate();
26222 
26223       oprot.writeStructBegin(STRUCT_DESC);
26224       if (this.tableName != null) {
26225         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
26226         oprot.writeBinary(this.tableName);
26227         oprot.writeFieldEnd();
26228       }
26229       if (this.row != null) {
26230         oprot.writeFieldBegin(ROW_FIELD_DESC);
26231         oprot.writeBinary(this.row);
26232         oprot.writeFieldEnd();
26233       }
26234       if (this.column != null) {
26235         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
26236         oprot.writeBinary(this.column);
26237         oprot.writeFieldEnd();
26238       }
26239       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
26240       oprot.writeI64(this.timestamp);
26241       oprot.writeFieldEnd();
26242       oprot.writeFieldStop();
26243       oprot.writeStructEnd();
26244     }
26245 
26246     @Override
26247     public String toString() {
26248       StringBuilder sb = new StringBuilder("deleteAllTs_args(");
26249       boolean first = true;
26250 
26251       sb.append("tableName:");
26252       if (this.tableName == null) {
26253         sb.append("null");
26254       } else {
26255         sb.append(this.tableName);
26256       }
26257       first = false;
26258       if (!first) sb.append(", ");
26259       sb.append("row:");
26260       if (this.row == null) {
26261         sb.append("null");
26262       } else {
26263         sb.append(this.row);
26264       }
26265       first = false;
26266       if (!first) sb.append(", ");
26267       sb.append("column:");
26268       if (this.column == null) {
26269         sb.append("null");
26270       } else {
26271         sb.append(this.column);
26272       }
26273       first = false;
26274       if (!first) sb.append(", ");
26275       sb.append("timestamp:");
26276       sb.append(this.timestamp);
26277       first = false;
26278       sb.append(")");
26279       return sb.toString();
26280     }
26281 
26282     public void validate() throws TException {
26283       // check for required fields
26284     }
26285 
26286   }
26287 
26288   public static class deleteAllTs_result implements TBase<deleteAllTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_result>   {
26289     private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_result");
26290 
26291     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
26292 
26293     public IOError io;
26294 
26295     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
26296     public enum _Fields implements TFieldIdEnum {
26297       IO((short)1, "io");
26298 
26299       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26300       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26301 
26302       static {
26303         for (_Fields field : EnumSet.allOf(_Fields.class)) {
26304           byId.put((int)field._thriftId, field);
26305           byName.put(field.getFieldName(), field);
26306         }
26307       }
26308 
26309       /**
26310        * Find the _Fields constant that matches fieldId, or null if its not found.
26311        */
26312       public static _Fields findByThriftId(int fieldId) {
26313         return byId.get(fieldId);
26314       }
26315 
26316       /**
26317        * Find the _Fields constant that matches fieldId, throwing an exception
26318        * if it is not found.
26319        */
26320       public static _Fields findByThriftIdOrThrow(int fieldId) {
26321         _Fields fields = findByThriftId(fieldId);
26322         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
26323         return fields;
26324       }
26325 
26326       /**
26327        * Find the _Fields constant that matches name, or null if its not found.
26328        */
26329       public static _Fields findByName(String name) {
26330         return byName.get(name);
26331       }
26332 
26333       private final short _thriftId;
26334       private final String _fieldName;
26335 
26336       _Fields(short thriftId, String fieldName) {
26337         _thriftId = thriftId;
26338         _fieldName = fieldName;
26339       }
26340 
26341       public short getThriftFieldId() {
26342         return _thriftId;
26343       }
26344 
26345       public String getFieldName() {
26346         return _fieldName;
26347       }
26348     }
26349 
26350     // isset id assignments
26351 
26352     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26353       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
26354           new FieldValueMetaData(TType.STRUCT)));
26355     }});
26356 
26357     static {
26358       FieldMetaData.addStructMetaDataMap(deleteAllTs_result.class, metaDataMap);
26359     }
26360 
26361     public deleteAllTs_result() {
26362     }
26363 
26364     public deleteAllTs_result(
26365       IOError io)
26366     {
26367       this();
26368       this.io = io;
26369     }
26370 
26371     /**
26372      * Performs a deep copy on <i>other</i>.
26373      */
26374     public deleteAllTs_result(deleteAllTs_result other) {
26375       if (other.isSetIo()) {
26376         this.io = new IOError(other.io);
26377       }
26378     }
26379 
26380     public deleteAllTs_result deepCopy() {
26381       return new deleteAllTs_result(this);
26382     }
26383 
26384     @Deprecated
26385     public deleteAllTs_result clone() {
26386       return new deleteAllTs_result(this);
26387     }
26388 
26389     public IOError getIo() {
26390       return this.io;
26391     }
26392 
26393     public deleteAllTs_result setIo(IOError io) {
26394       this.io = io;
26395       return this;
26396     }
26397 
26398     public void unsetIo() {
26399       this.io = null;
26400     }
26401 
26402     /** Returns true if field io is set (has been asigned a value) and false otherwise */
26403     public boolean isSetIo() {
26404       return this.io != null;
26405     }
26406 
26407     public void setIoIsSet(boolean value) {
26408       if (!value) {
26409         this.io = null;
26410       }
26411     }
26412 
26413     public void setFieldValue(_Fields field, Object value) {
26414       switch (field) {
26415       case IO:
26416         if (value == null) {
26417           unsetIo();
26418         } else {
26419           setIo((IOError)value);
26420         }
26421         break;
26422 
26423       }
26424     }
26425 
26426     public void setFieldValue(int fieldID, Object value) {
26427       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26428     }
26429 
26430     public Object getFieldValue(_Fields field) {
26431       switch (field) {
26432       case IO:
26433         return getIo();
26434 
26435       }
26436       throw new IllegalStateException();
26437     }
26438 
26439     public Object getFieldValue(int fieldId) {
26440       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26441     }
26442 
26443     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
26444     public boolean isSet(_Fields field) {
26445       switch (field) {
26446       case IO:
26447         return isSetIo();
26448       }
26449       throw new IllegalStateException();
26450     }
26451 
26452     public boolean isSet(int fieldID) {
26453       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26454     }
26455 
26456     @Override
26457     public boolean equals(Object that) {
26458       if (that == null)
26459         return false;
26460       if (that instanceof deleteAllTs_result)
26461         return this.equals((deleteAllTs_result)that);
26462       return false;
26463     }
26464 
26465     public boolean equals(deleteAllTs_result that) {
26466       if (that == null)
26467         return false;
26468 
26469       boolean this_present_io = true && this.isSetIo();
26470       boolean that_present_io = true && that.isSetIo();
26471       if (this_present_io || that_present_io) {
26472         if (!(this_present_io && that_present_io))
26473           return false;
26474         if (!this.io.equals(that.io))
26475           return false;
26476       }
26477 
26478       return true;
26479     }
26480 
26481     @Override
26482     public int hashCode() {
26483       HashCodeBuilder builder = new HashCodeBuilder();
26484 
26485       boolean present_io = true && (isSetIo());
26486       builder.append(present_io);
26487       if (present_io)
26488         builder.append(io);
26489 
26490       return builder.toHashCode();
26491     }
26492 
26493     public int compareTo(deleteAllTs_result other) {
26494       if (!getClass().equals(other.getClass())) {
26495         return getClass().getName().compareTo(other.getClass().getName());
26496       }
26497 
26498       int lastComparison = 0;
26499       deleteAllTs_result typedOther = (deleteAllTs_result)other;
26500 
26501       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
26502       if (lastComparison != 0) {
26503         return lastComparison;
26504       }
26505       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
26506       if (lastComparison != 0) {
26507         return lastComparison;
26508       }
26509       return 0;
26510     }
26511 
26512     public void read(TProtocol iprot) throws TException {
26513       TField field;
26514       iprot.readStructBegin();
26515       while (true)
26516       {
26517         field = iprot.readFieldBegin();
26518         if (field.type == TType.STOP) {
26519           break;
26520         }
26521         _Fields fieldId = _Fields.findByThriftId(field.id);
26522         if (fieldId == null) {
26523           TProtocolUtil.skip(iprot, field.type);
26524         } else {
26525           switch (fieldId) {
26526             case IO:
26527               if (field.type == TType.STRUCT) {
26528                 this.io = new IOError();
26529                 this.io.read(iprot);
26530               } else {
26531                 TProtocolUtil.skip(iprot, field.type);
26532               }
26533               break;
26534           }
26535           iprot.readFieldEnd();
26536         }
26537       }
26538       iprot.readStructEnd();
26539 
26540       // check for required fields of primitive type, which can't be checked in the validate method
26541       validate();
26542     }
26543 
26544     public void write(TProtocol oprot) throws TException {
26545       oprot.writeStructBegin(STRUCT_DESC);
26546 
26547       if (this.isSetIo()) {
26548         oprot.writeFieldBegin(IO_FIELD_DESC);
26549         this.io.write(oprot);
26550         oprot.writeFieldEnd();
26551       }
26552       oprot.writeFieldStop();
26553       oprot.writeStructEnd();
26554     }
26555 
26556     @Override
26557     public String toString() {
26558       StringBuilder sb = new StringBuilder("deleteAllTs_result(");
26559       boolean first = true;
26560 
26561       sb.append("io:");
26562       if (this.io == null) {
26563         sb.append("null");
26564       } else {
26565         sb.append(this.io);
26566       }
26567       first = false;
26568       sb.append(")");
26569       return sb.toString();
26570     }
26571 
26572     public void validate() throws TException {
26573       // check for required fields
26574     }
26575 
26576   }
26577 
26578   public static class deleteAllRow_args implements TBase<deleteAllRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_args>   {
26579     private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_args");
26580 
26581     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
26582     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
26583 
26584     /**
26585      * name of table
26586      */
26587     public byte[] tableName;
26588     /**
26589      * key of the row to be completely deleted.
26590      */
26591     public byte[] row;
26592 
26593     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
26594     public enum _Fields implements TFieldIdEnum {
26595       /**
26596        * name of table
26597        */
26598       TABLE_NAME((short)1, "tableName"),
26599       /**
26600        * key of the row to be completely deleted.
26601        */
26602       ROW((short)2, "row");
26603 
26604       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26605       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26606 
26607       static {
26608         for (_Fields field : EnumSet.allOf(_Fields.class)) {
26609           byId.put((int)field._thriftId, field);
26610           byName.put(field.getFieldName(), field);
26611         }
26612       }
26613 
26614       /**
26615        * Find the _Fields constant that matches fieldId, or null if its not found.
26616        */
26617       public static _Fields findByThriftId(int fieldId) {
26618         return byId.get(fieldId);
26619       }
26620 
26621       /**
26622        * Find the _Fields constant that matches fieldId, throwing an exception
26623        * if it is not found.
26624        */
26625       public static _Fields findByThriftIdOrThrow(int fieldId) {
26626         _Fields fields = findByThriftId(fieldId);
26627         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
26628         return fields;
26629       }
26630 
26631       /**
26632        * Find the _Fields constant that matches name, or null if its not found.
26633        */
26634       public static _Fields findByName(String name) {
26635         return byName.get(name);
26636       }
26637 
26638       private final short _thriftId;
26639       private final String _fieldName;
26640 
26641       _Fields(short thriftId, String fieldName) {
26642         _thriftId = thriftId;
26643         _fieldName = fieldName;
26644       }
26645 
26646       public short getThriftFieldId() {
26647         return _thriftId;
26648       }
26649 
26650       public String getFieldName() {
26651         return _fieldName;
26652       }
26653     }
26654 
26655     // isset id assignments
26656 
26657     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26658       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
26659           new FieldValueMetaData(TType.STRING)));
26660       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
26661           new FieldValueMetaData(TType.STRING)));
26662     }});
26663 
26664     static {
26665       FieldMetaData.addStructMetaDataMap(deleteAllRow_args.class, metaDataMap);
26666     }
26667 
26668     public deleteAllRow_args() {
26669     }
26670 
26671     public deleteAllRow_args(
26672       byte[] tableName,
26673       byte[] row)
26674     {
26675       this();
26676       this.tableName = tableName;
26677       this.row = row;
26678     }
26679 
26680     /**
26681      * Performs a deep copy on <i>other</i>.
26682      */
26683     public deleteAllRow_args(deleteAllRow_args other) {
26684       if (other.isSetTableName()) {
26685         this.tableName = other.tableName;
26686       }
26687       if (other.isSetRow()) {
26688         this.row = other.row;
26689       }
26690     }
26691 
26692     public deleteAllRow_args deepCopy() {
26693       return new deleteAllRow_args(this);
26694     }
26695 
26696     @Deprecated
26697     public deleteAllRow_args clone() {
26698       return new deleteAllRow_args(this);
26699     }
26700 
26701     /**
26702      * name of table
26703      */
26704     public byte[] getTableName() {
26705       return this.tableName;
26706     }
26707 
26708     /**
26709      * name of table
26710      */
26711     public deleteAllRow_args setTableName(byte[] tableName) {
26712       this.tableName = tableName;
26713       return this;
26714     }
26715 
26716     public void unsetTableName() {
26717       this.tableName = null;
26718     }
26719 
26720     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
26721     public boolean isSetTableName() {
26722       return this.tableName != null;
26723     }
26724 
26725     public void setTableNameIsSet(boolean value) {
26726       if (!value) {
26727         this.tableName = null;
26728       }
26729     }
26730 
26731     /**
26732      * key of the row to be completely deleted.
26733      */
26734     public byte[] getRow() {
26735       return this.row;
26736     }
26737 
26738     /**
26739      * key of the row to be completely deleted.
26740      */
26741     public deleteAllRow_args setRow(byte[] row) {
26742       this.row = row;
26743       return this;
26744     }
26745 
26746     public void unsetRow() {
26747       this.row = null;
26748     }
26749 
26750     /** Returns true if field row is set (has been asigned a value) and false otherwise */
26751     public boolean isSetRow() {
26752       return this.row != null;
26753     }
26754 
26755     public void setRowIsSet(boolean value) {
26756       if (!value) {
26757         this.row = null;
26758       }
26759     }
26760 
26761     public void setFieldValue(_Fields field, Object value) {
26762       switch (field) {
26763       case TABLE_NAME:
26764         if (value == null) {
26765           unsetTableName();
26766         } else {
26767           setTableName((byte[])value);
26768         }
26769         break;
26770 
26771       case ROW:
26772         if (value == null) {
26773           unsetRow();
26774         } else {
26775           setRow((byte[])value);
26776         }
26777         break;
26778 
26779       }
26780     }
26781 
26782     public void setFieldValue(int fieldID, Object value) {
26783       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26784     }
26785 
26786     public Object getFieldValue(_Fields field) {
26787       switch (field) {
26788       case TABLE_NAME:
26789         return getTableName();
26790 
26791       case ROW:
26792         return getRow();
26793 
26794       }
26795       throw new IllegalStateException();
26796     }
26797 
26798     public Object getFieldValue(int fieldId) {
26799       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26800     }
26801 
26802     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
26803     public boolean isSet(_Fields field) {
26804       switch (field) {
26805       case TABLE_NAME:
26806         return isSetTableName();
26807       case ROW:
26808         return isSetRow();
26809       }
26810       throw new IllegalStateException();
26811     }
26812 
26813     public boolean isSet(int fieldID) {
26814       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26815     }
26816 
26817     @Override
26818     public boolean equals(Object that) {
26819       if (that == null)
26820         return false;
26821       if (that instanceof deleteAllRow_args)
26822         return this.equals((deleteAllRow_args)that);
26823       return false;
26824     }
26825 
26826     public boolean equals(deleteAllRow_args that) {
26827       if (that == null)
26828         return false;
26829 
26830       boolean this_present_tableName = true && this.isSetTableName();
26831       boolean that_present_tableName = true && that.isSetTableName();
26832       if (this_present_tableName || that_present_tableName) {
26833         if (!(this_present_tableName && that_present_tableName))
26834           return false;
26835         if (!java.util.Arrays.equals(this.tableName, that.tableName))
26836           return false;
26837       }
26838 
26839       boolean this_present_row = true && this.isSetRow();
26840       boolean that_present_row = true && that.isSetRow();
26841       if (this_present_row || that_present_row) {
26842         if (!(this_present_row && that_present_row))
26843           return false;
26844         if (!java.util.Arrays.equals(this.row, that.row))
26845           return false;
26846       }
26847 
26848       return true;
26849     }
26850 
26851     @Override
26852     public int hashCode() {
26853       HashCodeBuilder builder = new HashCodeBuilder();
26854 
26855       boolean present_tableName = true && (isSetTableName());
26856       builder.append(present_tableName);
26857       if (present_tableName)
26858         builder.append(tableName);
26859 
26860       boolean present_row = true && (isSetRow());
26861       builder.append(present_row);
26862       if (present_row)
26863         builder.append(row);
26864 
26865       return builder.toHashCode();
26866     }
26867 
26868     public int compareTo(deleteAllRow_args other) {
26869       if (!getClass().equals(other.getClass())) {
26870         return getClass().getName().compareTo(other.getClass().getName());
26871       }
26872 
26873       int lastComparison = 0;
26874       deleteAllRow_args typedOther = (deleteAllRow_args)other;
26875 
26876       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
26877       if (lastComparison != 0) {
26878         return lastComparison;
26879       }
26880       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
26881       if (lastComparison != 0) {
26882         return lastComparison;
26883       }
26884       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
26885       if (lastComparison != 0) {
26886         return lastComparison;
26887       }
26888       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
26889       if (lastComparison != 0) {
26890         return lastComparison;
26891       }
26892       return 0;
26893     }
26894 
26895     public void read(TProtocol iprot) throws TException {
26896       TField field;
26897       iprot.readStructBegin();
26898       while (true)
26899       {
26900         field = iprot.readFieldBegin();
26901         if (field.type == TType.STOP) {
26902           break;
26903         }
26904         _Fields fieldId = _Fields.findByThriftId(field.id);
26905         if (fieldId == null) {
26906           TProtocolUtil.skip(iprot, field.type);
26907         } else {
26908           switch (fieldId) {
26909             case TABLE_NAME:
26910               if (field.type == TType.STRING) {
26911                 this.tableName = iprot.readBinary();
26912               } else {
26913                 TProtocolUtil.skip(iprot, field.type);
26914               }
26915               break;
26916             case ROW:
26917               if (field.type == TType.STRING) {
26918                 this.row = iprot.readBinary();
26919               } else {
26920                 TProtocolUtil.skip(iprot, field.type);
26921               }
26922               break;
26923           }
26924           iprot.readFieldEnd();
26925         }
26926       }
26927       iprot.readStructEnd();
26928 
26929       // check for required fields of primitive type, which can't be checked in the validate method
26930       validate();
26931     }
26932 
26933     public void write(TProtocol oprot) throws TException {
26934       validate();
26935 
26936       oprot.writeStructBegin(STRUCT_DESC);
26937       if (this.tableName != null) {
26938         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
26939         oprot.writeBinary(this.tableName);
26940         oprot.writeFieldEnd();
26941       }
26942       if (this.row != null) {
26943         oprot.writeFieldBegin(ROW_FIELD_DESC);
26944         oprot.writeBinary(this.row);
26945         oprot.writeFieldEnd();
26946       }
26947       oprot.writeFieldStop();
26948       oprot.writeStructEnd();
26949     }
26950 
26951     @Override
26952     public String toString() {
26953       StringBuilder sb = new StringBuilder("deleteAllRow_args(");
26954       boolean first = true;
26955 
26956       sb.append("tableName:");
26957       if (this.tableName == null) {
26958         sb.append("null");
26959       } else {
26960         sb.append(this.tableName);
26961       }
26962       first = false;
26963       if (!first) sb.append(", ");
26964       sb.append("row:");
26965       if (this.row == null) {
26966         sb.append("null");
26967       } else {
26968         sb.append(this.row);
26969       }
26970       first = false;
26971       sb.append(")");
26972       return sb.toString();
26973     }
26974 
26975     public void validate() throws TException {
26976       // check for required fields
26977     }
26978 
26979   }
26980 
26981   public static class deleteAllRow_result implements TBase<deleteAllRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_result>   {
26982     private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_result");
26983 
26984     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
26985 
26986     public IOError io;
26987 
26988     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
26989     public enum _Fields implements TFieldIdEnum {
26990       IO((short)1, "io");
26991 
26992       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26993       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26994 
26995       static {
26996         for (_Fields field : EnumSet.allOf(_Fields.class)) {
26997           byId.put((int)field._thriftId, field);
26998           byName.put(field.getFieldName(), field);
26999         }
27000       }
27001 
27002       /**
27003        * Find the _Fields constant that matches fieldId, or null if its not found.
27004        */
27005       public static _Fields findByThriftId(int fieldId) {
27006         return byId.get(fieldId);
27007       }
27008 
27009       /**
27010        * Find the _Fields constant that matches fieldId, throwing an exception
27011        * if it is not found.
27012        */
27013       public static _Fields findByThriftIdOrThrow(int fieldId) {
27014         _Fields fields = findByThriftId(fieldId);
27015         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27016         return fields;
27017       }
27018 
27019       /**
27020        * Find the _Fields constant that matches name, or null if its not found.
27021        */
27022       public static _Fields findByName(String name) {
27023         return byName.get(name);
27024       }
27025 
27026       private final short _thriftId;
27027       private final String _fieldName;
27028 
27029       _Fields(short thriftId, String fieldName) {
27030         _thriftId = thriftId;
27031         _fieldName = fieldName;
27032       }
27033 
27034       public short getThriftFieldId() {
27035         return _thriftId;
27036       }
27037 
27038       public String getFieldName() {
27039         return _fieldName;
27040       }
27041     }
27042 
27043     // isset id assignments
27044 
27045     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27046       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
27047           new FieldValueMetaData(TType.STRUCT)));
27048     }});
27049 
27050     static {
27051       FieldMetaData.addStructMetaDataMap(deleteAllRow_result.class, metaDataMap);
27052     }
27053 
27054     public deleteAllRow_result() {
27055     }
27056 
27057     public deleteAllRow_result(
27058       IOError io)
27059     {
27060       this();
27061       this.io = io;
27062     }
27063 
27064     /**
27065      * Performs a deep copy on <i>other</i>.
27066      */
27067     public deleteAllRow_result(deleteAllRow_result other) {
27068       if (other.isSetIo()) {
27069         this.io = new IOError(other.io);
27070       }
27071     }
27072 
27073     public deleteAllRow_result deepCopy() {
27074       return new deleteAllRow_result(this);
27075     }
27076 
27077     @Deprecated
27078     public deleteAllRow_result clone() {
27079       return new deleteAllRow_result(this);
27080     }
27081 
27082     public IOError getIo() {
27083       return this.io;
27084     }
27085 
27086     public deleteAllRow_result setIo(IOError io) {
27087       this.io = io;
27088       return this;
27089     }
27090 
27091     public void unsetIo() {
27092       this.io = null;
27093     }
27094 
27095     /** Returns true if field io is set (has been asigned a value) and false otherwise */
27096     public boolean isSetIo() {
27097       return this.io != null;
27098     }
27099 
27100     public void setIoIsSet(boolean value) {
27101       if (!value) {
27102         this.io = null;
27103       }
27104     }
27105 
27106     public void setFieldValue(_Fields field, Object value) {
27107       switch (field) {
27108       case IO:
27109         if (value == null) {
27110           unsetIo();
27111         } else {
27112           setIo((IOError)value);
27113         }
27114         break;
27115 
27116       }
27117     }
27118 
27119     public void setFieldValue(int fieldID, Object value) {
27120       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27121     }
27122 
27123     public Object getFieldValue(_Fields field) {
27124       switch (field) {
27125       case IO:
27126         return getIo();
27127 
27128       }
27129       throw new IllegalStateException();
27130     }
27131 
27132     public Object getFieldValue(int fieldId) {
27133       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27134     }
27135 
27136     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
27137     public boolean isSet(_Fields field) {
27138       switch (field) {
27139       case IO:
27140         return isSetIo();
27141       }
27142       throw new IllegalStateException();
27143     }
27144 
27145     public boolean isSet(int fieldID) {
27146       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27147     }
27148 
27149     @Override
27150     public boolean equals(Object that) {
27151       if (that == null)
27152         return false;
27153       if (that instanceof deleteAllRow_result)
27154         return this.equals((deleteAllRow_result)that);
27155       return false;
27156     }
27157 
27158     public boolean equals(deleteAllRow_result that) {
27159       if (that == null)
27160         return false;
27161 
27162       boolean this_present_io = true && this.isSetIo();
27163       boolean that_present_io = true && that.isSetIo();
27164       if (this_present_io || that_present_io) {
27165         if (!(this_present_io && that_present_io))
27166           return false;
27167         if (!this.io.equals(that.io))
27168           return false;
27169       }
27170 
27171       return true;
27172     }
27173 
27174     @Override
27175     public int hashCode() {
27176       HashCodeBuilder builder = new HashCodeBuilder();
27177 
27178       boolean present_io = true && (isSetIo());
27179       builder.append(present_io);
27180       if (present_io)
27181         builder.append(io);
27182 
27183       return builder.toHashCode();
27184     }
27185 
27186     public int compareTo(deleteAllRow_result other) {
27187       if (!getClass().equals(other.getClass())) {
27188         return getClass().getName().compareTo(other.getClass().getName());
27189       }
27190 
27191       int lastComparison = 0;
27192       deleteAllRow_result typedOther = (deleteAllRow_result)other;
27193 
27194       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
27195       if (lastComparison != 0) {
27196         return lastComparison;
27197       }
27198       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
27199       if (lastComparison != 0) {
27200         return lastComparison;
27201       }
27202       return 0;
27203     }
27204 
27205     public void read(TProtocol iprot) throws TException {
27206       TField field;
27207       iprot.readStructBegin();
27208       while (true)
27209       {
27210         field = iprot.readFieldBegin();
27211         if (field.type == TType.STOP) {
27212           break;
27213         }
27214         _Fields fieldId = _Fields.findByThriftId(field.id);
27215         if (fieldId == null) {
27216           TProtocolUtil.skip(iprot, field.type);
27217         } else {
27218           switch (fieldId) {
27219             case IO:
27220               if (field.type == TType.STRUCT) {
27221                 this.io = new IOError();
27222                 this.io.read(iprot);
27223               } else {
27224                 TProtocolUtil.skip(iprot, field.type);
27225               }
27226               break;
27227           }
27228           iprot.readFieldEnd();
27229         }
27230       }
27231       iprot.readStructEnd();
27232 
27233       // check for required fields of primitive type, which can't be checked in the validate method
27234       validate();
27235     }
27236 
27237     public void write(TProtocol oprot) throws TException {
27238       oprot.writeStructBegin(STRUCT_DESC);
27239 
27240       if (this.isSetIo()) {
27241         oprot.writeFieldBegin(IO_FIELD_DESC);
27242         this.io.write(oprot);
27243         oprot.writeFieldEnd();
27244       }
27245       oprot.writeFieldStop();
27246       oprot.writeStructEnd();
27247     }
27248 
27249     @Override
27250     public String toString() {
27251       StringBuilder sb = new StringBuilder("deleteAllRow_result(");
27252       boolean first = true;
27253 
27254       sb.append("io:");
27255       if (this.io == null) {
27256         sb.append("null");
27257       } else {
27258         sb.append(this.io);
27259       }
27260       first = false;
27261       sb.append(")");
27262       return sb.toString();
27263     }
27264 
27265     public void validate() throws TException {
27266       // check for required fields
27267     }
27268 
27269   }
27270 
27271   public static class deleteAllRowTs_args implements TBase<deleteAllRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_args>   {
27272     private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_args");
27273 
27274     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
27275     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
27276     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
27277 
27278     /**
27279      * name of table
27280      */
27281     public byte[] tableName;
27282     /**
27283      * key of the row to be completely deleted.
27284      */
27285     public byte[] row;
27286     /**
27287      * timestamp
27288      */
27289     public long timestamp;
27290 
27291     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
27292     public enum _Fields implements TFieldIdEnum {
27293       /**
27294        * name of table
27295        */
27296       TABLE_NAME((short)1, "tableName"),
27297       /**
27298        * key of the row to be completely deleted.
27299        */
27300       ROW((short)2, "row"),
27301       /**
27302        * timestamp
27303        */
27304       TIMESTAMP((short)3, "timestamp");
27305 
27306       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
27307       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
27308 
27309       static {
27310         for (_Fields field : EnumSet.allOf(_Fields.class)) {
27311           byId.put((int)field._thriftId, field);
27312           byName.put(field.getFieldName(), field);
27313         }
27314       }
27315 
27316       /**
27317        * Find the _Fields constant that matches fieldId, or null if its not found.
27318        */
27319       public static _Fields findByThriftId(int fieldId) {
27320         return byId.get(fieldId);
27321       }
27322 
27323       /**
27324        * Find the _Fields constant that matches fieldId, throwing an exception
27325        * if it is not found.
27326        */
27327       public static _Fields findByThriftIdOrThrow(int fieldId) {
27328         _Fields fields = findByThriftId(fieldId);
27329         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27330         return fields;
27331       }
27332 
27333       /**
27334        * Find the _Fields constant that matches name, or null if its not found.
27335        */
27336       public static _Fields findByName(String name) {
27337         return byName.get(name);
27338       }
27339 
27340       private final short _thriftId;
27341       private final String _fieldName;
27342 
27343       _Fields(short thriftId, String fieldName) {
27344         _thriftId = thriftId;
27345         _fieldName = fieldName;
27346       }
27347 
27348       public short getThriftFieldId() {
27349         return _thriftId;
27350       }
27351 
27352       public String getFieldName() {
27353         return _fieldName;
27354       }
27355     }
27356 
27357     // isset id assignments
27358     private static final int __TIMESTAMP_ISSET_ID = 0;
27359     private BitSet __isset_bit_vector = new BitSet(1);
27360 
27361     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27362       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
27363           new FieldValueMetaData(TType.STRING)));
27364       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
27365           new FieldValueMetaData(TType.STRING)));
27366       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
27367           new FieldValueMetaData(TType.I64)));
27368     }});
27369 
27370     static {
27371       FieldMetaData.addStructMetaDataMap(deleteAllRowTs_args.class, metaDataMap);
27372     }
27373 
27374     public deleteAllRowTs_args() {
27375     }
27376 
27377     public deleteAllRowTs_args(
27378       byte[] tableName,
27379       byte[] row,
27380       long timestamp)
27381     {
27382       this();
27383       this.tableName = tableName;
27384       this.row = row;
27385       this.timestamp = timestamp;
27386       setTimestampIsSet(true);
27387     }
27388 
27389     /**
27390      * Performs a deep copy on <i>other</i>.
27391      */
27392     public deleteAllRowTs_args(deleteAllRowTs_args other) {
27393       __isset_bit_vector.clear();
27394       __isset_bit_vector.or(other.__isset_bit_vector);
27395       if (other.isSetTableName()) {
27396         this.tableName = other.tableName;
27397       }
27398       if (other.isSetRow()) {
27399         this.row = other.row;
27400       }
27401       this.timestamp = other.timestamp;
27402     }
27403 
27404     public deleteAllRowTs_args deepCopy() {
27405       return new deleteAllRowTs_args(this);
27406     }
27407 
27408     @Deprecated
27409     public deleteAllRowTs_args clone() {
27410       return new deleteAllRowTs_args(this);
27411     }
27412 
27413     /**
27414      * name of table
27415      */
27416     public byte[] getTableName() {
27417       return this.tableName;
27418     }
27419 
27420     /**
27421      * name of table
27422      */
27423     public deleteAllRowTs_args setTableName(byte[] tableName) {
27424       this.tableName = tableName;
27425       return this;
27426     }
27427 
27428     public void unsetTableName() {
27429       this.tableName = null;
27430     }
27431 
27432     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
27433     public boolean isSetTableName() {
27434       return this.tableName != null;
27435     }
27436 
27437     public void setTableNameIsSet(boolean value) {
27438       if (!value) {
27439         this.tableName = null;
27440       }
27441     }
27442 
27443     /**
27444      * key of the row to be completely deleted.
27445      */
27446     public byte[] getRow() {
27447       return this.row;
27448     }
27449 
27450     /**
27451      * key of the row to be completely deleted.
27452      */
27453     public deleteAllRowTs_args setRow(byte[] row) {
27454       this.row = row;
27455       return this;
27456     }
27457 
27458     public void unsetRow() {
27459       this.row = null;
27460     }
27461 
27462     /** Returns true if field row is set (has been asigned a value) and false otherwise */
27463     public boolean isSetRow() {
27464       return this.row != null;
27465     }
27466 
27467     public void setRowIsSet(boolean value) {
27468       if (!value) {
27469         this.row = null;
27470       }
27471     }
27472 
27473     /**
27474      * timestamp
27475      */
27476     public long getTimestamp() {
27477       return this.timestamp;
27478     }
27479 
27480     /**
27481      * timestamp
27482      */
27483     public deleteAllRowTs_args setTimestamp(long timestamp) {
27484       this.timestamp = timestamp;
27485       setTimestampIsSet(true);
27486       return this;
27487     }
27488 
27489     public void unsetTimestamp() {
27490       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
27491     }
27492 
27493     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
27494     public boolean isSetTimestamp() {
27495       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
27496     }
27497 
27498     public void setTimestampIsSet(boolean value) {
27499       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
27500     }
27501 
27502     public void setFieldValue(_Fields field, Object value) {
27503       switch (field) {
27504       case TABLE_NAME:
27505         if (value == null) {
27506           unsetTableName();
27507         } else {
27508           setTableName((byte[])value);
27509         }
27510         break;
27511 
27512       case ROW:
27513         if (value == null) {
27514           unsetRow();
27515         } else {
27516           setRow((byte[])value);
27517         }
27518         break;
27519 
27520       case TIMESTAMP:
27521         if (value == null) {
27522           unsetTimestamp();
27523         } else {
27524           setTimestamp((Long)value);
27525         }
27526         break;
27527 
27528       }
27529     }
27530 
27531     public void setFieldValue(int fieldID, Object value) {
27532       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27533     }
27534 
27535     public Object getFieldValue(_Fields field) {
27536       switch (field) {
27537       case TABLE_NAME:
27538         return getTableName();
27539 
27540       case ROW:
27541         return getRow();
27542 
27543       case TIMESTAMP:
27544         return new Long(getTimestamp());
27545 
27546       }
27547       throw new IllegalStateException();
27548     }
27549 
27550     public Object getFieldValue(int fieldId) {
27551       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27552     }
27553 
27554     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
27555     public boolean isSet(_Fields field) {
27556       switch (field) {
27557       case TABLE_NAME:
27558         return isSetTableName();
27559       case ROW:
27560         return isSetRow();
27561       case TIMESTAMP:
27562         return isSetTimestamp();
27563       }
27564       throw new IllegalStateException();
27565     }
27566 
27567     public boolean isSet(int fieldID) {
27568       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27569     }
27570 
27571     @Override
27572     public boolean equals(Object that) {
27573       if (that == null)
27574         return false;
27575       if (that instanceof deleteAllRowTs_args)
27576         return this.equals((deleteAllRowTs_args)that);
27577       return false;
27578     }
27579 
27580     public boolean equals(deleteAllRowTs_args that) {
27581       if (that == null)
27582         return false;
27583 
27584       boolean this_present_tableName = true && this.isSetTableName();
27585       boolean that_present_tableName = true && that.isSetTableName();
27586       if (this_present_tableName || that_present_tableName) {
27587         if (!(this_present_tableName && that_present_tableName))
27588           return false;
27589         if (!java.util.Arrays.equals(this.tableName, that.tableName))
27590           return false;
27591       }
27592 
27593       boolean this_present_row = true && this.isSetRow();
27594       boolean that_present_row = true && that.isSetRow();
27595       if (this_present_row || that_present_row) {
27596         if (!(this_present_row && that_present_row))
27597           return false;
27598         if (!java.util.Arrays.equals(this.row, that.row))
27599           return false;
27600       }
27601 
27602       boolean this_present_timestamp = true;
27603       boolean that_present_timestamp = true;
27604       if (this_present_timestamp || that_present_timestamp) {
27605         if (!(this_present_timestamp && that_present_timestamp))
27606           return false;
27607         if (this.timestamp != that.timestamp)
27608           return false;
27609       }
27610 
27611       return true;
27612     }
27613 
27614     @Override
27615     public int hashCode() {
27616       HashCodeBuilder builder = new HashCodeBuilder();
27617 
27618       boolean present_tableName = true && (isSetTableName());
27619       builder.append(present_tableName);
27620       if (present_tableName)
27621         builder.append(tableName);
27622 
27623       boolean present_row = true && (isSetRow());
27624       builder.append(present_row);
27625       if (present_row)
27626         builder.append(row);
27627 
27628       boolean present_timestamp = true;
27629       builder.append(present_timestamp);
27630       if (present_timestamp)
27631         builder.append(timestamp);
27632 
27633       return builder.toHashCode();
27634     }
27635 
27636     public int compareTo(deleteAllRowTs_args other) {
27637       if (!getClass().equals(other.getClass())) {
27638         return getClass().getName().compareTo(other.getClass().getName());
27639       }
27640 
27641       int lastComparison = 0;
27642       deleteAllRowTs_args typedOther = (deleteAllRowTs_args)other;
27643 
27644       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
27645       if (lastComparison != 0) {
27646         return lastComparison;
27647       }
27648       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
27649       if (lastComparison != 0) {
27650         return lastComparison;
27651       }
27652       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
27653       if (lastComparison != 0) {
27654         return lastComparison;
27655       }
27656       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
27657       if (lastComparison != 0) {
27658         return lastComparison;
27659       }
27660       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
27661       if (lastComparison != 0) {
27662         return lastComparison;
27663       }
27664       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
27665       if (lastComparison != 0) {
27666         return lastComparison;
27667       }
27668       return 0;
27669     }
27670 
27671     public void read(TProtocol iprot) throws TException {
27672       TField field;
27673       iprot.readStructBegin();
27674       while (true)
27675       {
27676         field = iprot.readFieldBegin();
27677         if (field.type == TType.STOP) {
27678           break;
27679         }
27680         _Fields fieldId = _Fields.findByThriftId(field.id);
27681         if (fieldId == null) {
27682           TProtocolUtil.skip(iprot, field.type);
27683         } else {
27684           switch (fieldId) {
27685             case TABLE_NAME:
27686               if (field.type == TType.STRING) {
27687                 this.tableName = iprot.readBinary();
27688               } else {
27689                 TProtocolUtil.skip(iprot, field.type);
27690               }
27691               break;
27692             case ROW:
27693               if (field.type == TType.STRING) {
27694                 this.row = iprot.readBinary();
27695               } else {
27696                 TProtocolUtil.skip(iprot, field.type);
27697               }
27698               break;
27699             case TIMESTAMP:
27700               if (field.type == TType.I64) {
27701                 this.timestamp = iprot.readI64();
27702                 setTimestampIsSet(true);
27703               } else {
27704                 TProtocolUtil.skip(iprot, field.type);
27705               }
27706               break;
27707           }
27708           iprot.readFieldEnd();
27709         }
27710       }
27711       iprot.readStructEnd();
27712 
27713       // check for required fields of primitive type, which can't be checked in the validate method
27714       validate();
27715     }
27716 
27717     public void write(TProtocol oprot) throws TException {
27718       validate();
27719 
27720       oprot.writeStructBegin(STRUCT_DESC);
27721       if (this.tableName != null) {
27722         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
27723         oprot.writeBinary(this.tableName);
27724         oprot.writeFieldEnd();
27725       }
27726       if (this.row != null) {
27727         oprot.writeFieldBegin(ROW_FIELD_DESC);
27728         oprot.writeBinary(this.row);
27729         oprot.writeFieldEnd();
27730       }
27731       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
27732       oprot.writeI64(this.timestamp);
27733       oprot.writeFieldEnd();
27734       oprot.writeFieldStop();
27735       oprot.writeStructEnd();
27736     }
27737 
27738     @Override
27739     public String toString() {
27740       StringBuilder sb = new StringBuilder("deleteAllRowTs_args(");
27741       boolean first = true;
27742 
27743       sb.append("tableName:");
27744       if (this.tableName == null) {
27745         sb.append("null");
27746       } else {
27747         sb.append(this.tableName);
27748       }
27749       first = false;
27750       if (!first) sb.append(", ");
27751       sb.append("row:");
27752       if (this.row == null) {
27753         sb.append("null");
27754       } else {
27755         sb.append(this.row);
27756       }
27757       first = false;
27758       if (!first) sb.append(", ");
27759       sb.append("timestamp:");
27760       sb.append(this.timestamp);
27761       first = false;
27762       sb.append(")");
27763       return sb.toString();
27764     }
27765 
27766     public void validate() throws TException {
27767       // check for required fields
27768     }
27769 
27770   }
27771 
27772   public static class deleteAllRowTs_result implements TBase<deleteAllRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_result>   {
27773     private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_result");
27774 
27775     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
27776 
27777     public IOError io;
27778 
27779     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
27780     public enum _Fields implements TFieldIdEnum {
27781       IO((short)1, "io");
27782 
27783       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
27784       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
27785 
27786       static {
27787         for (_Fields field : EnumSet.allOf(_Fields.class)) {
27788           byId.put((int)field._thriftId, field);
27789           byName.put(field.getFieldName(), field);
27790         }
27791       }
27792 
27793       /**
27794        * Find the _Fields constant that matches fieldId, or null if its not found.
27795        */
27796       public static _Fields findByThriftId(int fieldId) {
27797         return byId.get(fieldId);
27798       }
27799 
27800       /**
27801        * Find the _Fields constant that matches fieldId, throwing an exception
27802        * if it is not found.
27803        */
27804       public static _Fields findByThriftIdOrThrow(int fieldId) {
27805         _Fields fields = findByThriftId(fieldId);
27806         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27807         return fields;
27808       }
27809 
27810       /**
27811        * Find the _Fields constant that matches name, or null if its not found.
27812        */
27813       public static _Fields findByName(String name) {
27814         return byName.get(name);
27815       }
27816 
27817       private final short _thriftId;
27818       private final String _fieldName;
27819 
27820       _Fields(short thriftId, String fieldName) {
27821         _thriftId = thriftId;
27822         _fieldName = fieldName;
27823       }
27824 
27825       public short getThriftFieldId() {
27826         return _thriftId;
27827       }
27828 
27829       public String getFieldName() {
27830         return _fieldName;
27831       }
27832     }
27833 
27834     // isset id assignments
27835 
27836     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27837       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
27838           new FieldValueMetaData(TType.STRUCT)));
27839     }});
27840 
27841     static {
27842       FieldMetaData.addStructMetaDataMap(deleteAllRowTs_result.class, metaDataMap);
27843     }
27844 
27845     public deleteAllRowTs_result() {
27846     }
27847 
27848     public deleteAllRowTs_result(
27849       IOError io)
27850     {
27851       this();
27852       this.io = io;
27853     }
27854 
27855     /**
27856      * Performs a deep copy on <i>other</i>.
27857      */
27858     public deleteAllRowTs_result(deleteAllRowTs_result other) {
27859       if (other.isSetIo()) {
27860         this.io = new IOError(other.io);
27861       }
27862     }
27863 
27864     public deleteAllRowTs_result deepCopy() {
27865       return new deleteAllRowTs_result(this);
27866     }
27867 
27868     @Deprecated
27869     public deleteAllRowTs_result clone() {
27870       return new deleteAllRowTs_result(this);
27871     }
27872 
27873     public IOError getIo() {
27874       return this.io;
27875     }
27876 
27877     public deleteAllRowTs_result setIo(IOError io) {
27878       this.io = io;
27879       return this;
27880     }
27881 
27882     public void unsetIo() {
27883       this.io = null;
27884     }
27885 
27886     /** Returns true if field io is set (has been asigned a value) and false otherwise */
27887     public boolean isSetIo() {
27888       return this.io != null;
27889     }
27890 
27891     public void setIoIsSet(boolean value) {
27892       if (!value) {
27893         this.io = null;
27894       }
27895     }
27896 
27897     public void setFieldValue(_Fields field, Object value) {
27898       switch (field) {
27899       case IO:
27900         if (value == null) {
27901           unsetIo();
27902         } else {
27903           setIo((IOError)value);
27904         }
27905         break;
27906 
27907       }
27908     }
27909 
27910     public void setFieldValue(int fieldID, Object value) {
27911       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27912     }
27913 
27914     public Object getFieldValue(_Fields field) {
27915       switch (field) {
27916       case IO:
27917         return getIo();
27918 
27919       }
27920       throw new IllegalStateException();
27921     }
27922 
27923     public Object getFieldValue(int fieldId) {
27924       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27925     }
27926 
27927     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
27928     public boolean isSet(_Fields field) {
27929       switch (field) {
27930       case IO:
27931         return isSetIo();
27932       }
27933       throw new IllegalStateException();
27934     }
27935 
27936     public boolean isSet(int fieldID) {
27937       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27938     }
27939 
27940     @Override
27941     public boolean equals(Object that) {
27942       if (that == null)
27943         return false;
27944       if (that instanceof deleteAllRowTs_result)
27945         return this.equals((deleteAllRowTs_result)that);
27946       return false;
27947     }
27948 
27949     public boolean equals(deleteAllRowTs_result that) {
27950       if (that == null)
27951         return false;
27952 
27953       boolean this_present_io = true && this.isSetIo();
27954       boolean that_present_io = true && that.isSetIo();
27955       if (this_present_io || that_present_io) {
27956         if (!(this_present_io && that_present_io))
27957           return false;
27958         if (!this.io.equals(that.io))
27959           return false;
27960       }
27961 
27962       return true;
27963     }
27964 
27965     @Override
27966     public int hashCode() {
27967       HashCodeBuilder builder = new HashCodeBuilder();
27968 
27969       boolean present_io = true && (isSetIo());
27970       builder.append(present_io);
27971       if (present_io)
27972         builder.append(io);
27973 
27974       return builder.toHashCode();
27975     }
27976 
27977     public int compareTo(deleteAllRowTs_result other) {
27978       if (!getClass().equals(other.getClass())) {
27979         return getClass().getName().compareTo(other.getClass().getName());
27980       }
27981 
27982       int lastComparison = 0;
27983       deleteAllRowTs_result typedOther = (deleteAllRowTs_result)other;
27984 
27985       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
27986       if (lastComparison != 0) {
27987         return lastComparison;
27988       }
27989       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
27990       if (lastComparison != 0) {
27991         return lastComparison;
27992       }
27993       return 0;
27994     }
27995 
27996     public void read(TProtocol iprot) throws TException {
27997       TField field;
27998       iprot.readStructBegin();
27999       while (true)
28000       {
28001         field = iprot.readFieldBegin();
28002         if (field.type == TType.STOP) {
28003           break;
28004         }
28005         _Fields fieldId = _Fields.findByThriftId(field.id);
28006         if (fieldId == null) {
28007           TProtocolUtil.skip(iprot, field.type);
28008         } else {
28009           switch (fieldId) {
28010             case IO:
28011               if (field.type == TType.STRUCT) {
28012                 this.io = new IOError();
28013                 this.io.read(iprot);
28014               } else {
28015                 TProtocolUtil.skip(iprot, field.type);
28016               }
28017               break;
28018           }
28019           iprot.readFieldEnd();
28020         }
28021       }
28022       iprot.readStructEnd();
28023 
28024       // check for required fields of primitive type, which can't be checked in the validate method
28025       validate();
28026     }
28027 
28028     public void write(TProtocol oprot) throws TException {
28029       oprot.writeStructBegin(STRUCT_DESC);
28030 
28031       if (this.isSetIo()) {
28032         oprot.writeFieldBegin(IO_FIELD_DESC);
28033         this.io.write(oprot);
28034         oprot.writeFieldEnd();
28035       }
28036       oprot.writeFieldStop();
28037       oprot.writeStructEnd();
28038     }
28039 
28040     @Override
28041     public String toString() {
28042       StringBuilder sb = new StringBuilder("deleteAllRowTs_result(");
28043       boolean first = true;
28044 
28045       sb.append("io:");
28046       if (this.io == null) {
28047         sb.append("null");
28048       } else {
28049         sb.append(this.io);
28050       }
28051       first = false;
28052       sb.append(")");
28053       return sb.toString();
28054     }
28055 
28056     public void validate() throws TException {
28057       // check for required fields
28058     }
28059 
28060   }
28061 
28062   public static class scannerOpen_args implements TBase<scannerOpen_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_args>   {
28063     private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_args");
28064 
28065     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
28066     private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
28067     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
28068 
28069     /**
28070      * name of table
28071      */
28072     public byte[] tableName;
28073     /**
28074      * Starting row in table to scan.
28075      * Send "" (empty string) to start at the first row.
28076      */
28077     public byte[] startRow;
28078     /**
28079      * columns to scan. If column name is a column family, all
28080      * columns of the specified column family are returned. It's also possible
28081      * to pass a regex in the column qualifier.
28082      */
28083     public List<byte[]> columns;
28084 
28085     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
28086     public enum _Fields implements TFieldIdEnum {
28087       /**
28088        * name of table
28089        */
28090       TABLE_NAME((short)1, "tableName"),
28091       /**
28092        * Starting row in table to scan.
28093        * Send "" (empty string) to start at the first row.
28094        */
28095       START_ROW((short)2, "startRow"),
28096       /**
28097        * columns to scan. If column name is a column family, all
28098        * columns of the specified column family are returned. It's also possible
28099        * to pass a regex in the column qualifier.
28100        */
28101       COLUMNS((short)3, "columns");
28102 
28103       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
28104       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
28105 
28106       static {
28107         for (_Fields field : EnumSet.allOf(_Fields.class)) {
28108           byId.put((int)field._thriftId, field);
28109           byName.put(field.getFieldName(), field);
28110         }
28111       }
28112 
28113       /**
28114        * Find the _Fields constant that matches fieldId, or null if its not found.
28115        */
28116       public static _Fields findByThriftId(int fieldId) {
28117         return byId.get(fieldId);
28118       }
28119 
28120       /**
28121        * Find the _Fields constant that matches fieldId, throwing an exception
28122        * if it is not found.
28123        */
28124       public static _Fields findByThriftIdOrThrow(int fieldId) {
28125         _Fields fields = findByThriftId(fieldId);
28126         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
28127         return fields;
28128       }
28129 
28130       /**
28131        * Find the _Fields constant that matches name, or null if its not found.
28132        */
28133       public static _Fields findByName(String name) {
28134         return byName.get(name);
28135       }
28136 
28137       private final short _thriftId;
28138       private final String _fieldName;
28139 
28140       _Fields(short thriftId, String fieldName) {
28141         _thriftId = thriftId;
28142         _fieldName = fieldName;
28143       }
28144 
28145       public short getThriftFieldId() {
28146         return _thriftId;
28147       }
28148 
28149       public String getFieldName() {
28150         return _fieldName;
28151       }
28152     }
28153 
28154     // isset id assignments
28155 
28156     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
28157       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
28158           new FieldValueMetaData(TType.STRING)));
28159       put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
28160           new FieldValueMetaData(TType.STRING)));
28161       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
28162           new ListMetaData(TType.LIST,
28163               new FieldValueMetaData(TType.STRING))));
28164     }});
28165 
28166     static {
28167       FieldMetaData.addStructMetaDataMap(scannerOpen_args.class, metaDataMap);
28168     }
28169 
28170     public scannerOpen_args() {
28171     }
28172 
28173     public scannerOpen_args(
28174       byte[] tableName,
28175       byte[] startRow,
28176       List<byte[]> columns)
28177     {
28178       this();
28179       this.tableName = tableName;
28180       this.startRow = startRow;
28181       this.columns = columns;
28182     }
28183 
28184     /**
28185      * Performs a deep copy on <i>other</i>.
28186      */
28187     public scannerOpen_args(scannerOpen_args other) {
28188       if (other.isSetTableName()) {
28189         this.tableName = other.tableName;
28190       }
28191       if (other.isSetStartRow()) {
28192         this.startRow = other.startRow;
28193       }
28194       if (other.isSetColumns()) {
28195         List<byte[]> __this__columns = new ArrayList<byte[]>();
28196         for (byte[] other_element : other.columns) {
28197           __this__columns.add(other_element);
28198         }
28199         this.columns = __this__columns;
28200       }
28201     }
28202 
28203     public scannerOpen_args deepCopy() {
28204       return new scannerOpen_args(this);
28205     }
28206 
28207     @Deprecated
28208     public scannerOpen_args clone() {
28209       return new scannerOpen_args(this);
28210     }
28211 
28212     /**
28213      * name of table
28214      */
28215     public byte[] getTableName() {
28216       return this.tableName;
28217     }
28218 
28219     /**
28220      * name of table
28221      */
28222     public scannerOpen_args setTableName(byte[] tableName) {
28223       this.tableName = tableName;
28224       return this;
28225     }
28226 
28227     public void unsetTableName() {
28228       this.tableName = null;
28229     }
28230 
28231     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
28232     public boolean isSetTableName() {
28233       return this.tableName != null;
28234     }
28235 
28236     public void setTableNameIsSet(boolean value) {
28237       if (!value) {
28238         this.tableName = null;
28239       }
28240     }
28241 
28242     /**
28243      * Starting row in table to scan.
28244      * Send "" (empty string) to start at the first row.
28245      */
28246     public byte[] getStartRow() {
28247       return this.startRow;
28248     }
28249 
28250     /**
28251      * Starting row in table to scan.
28252      * Send "" (empty string) to start at the first row.
28253      */
28254     public scannerOpen_args setStartRow(byte[] startRow) {
28255       this.startRow = startRow;
28256       return this;
28257     }
28258 
28259     public void unsetStartRow() {
28260       this.startRow = null;
28261     }
28262 
28263     /** Returns true if field startRow is set (has been asigned a value) and false otherwise */
28264     public boolean isSetStartRow() {
28265       return this.startRow != null;
28266     }
28267 
28268     public void setStartRowIsSet(boolean value) {
28269       if (!value) {
28270         this.startRow = null;
28271       }
28272     }
28273 
28274     public int getColumnsSize() {
28275       return (this.columns == null) ? 0 : this.columns.size();
28276     }
28277 
28278     public java.util.Iterator<byte[]> getColumnsIterator() {
28279       return (this.columns == null) ? null : this.columns.iterator();
28280     }
28281 
28282     public void addToColumns(byte[] elem) {
28283       if (this.columns == null) {
28284         this.columns = new ArrayList<byte[]>();
28285       }
28286       this.columns.add(elem);
28287     }
28288 
28289     /**
28290      * columns to scan. If column name is a column family, all
28291      * columns of the specified column family are returned. It's also possible
28292      * to pass a regex in the column qualifier.
28293      */
28294     public List<byte[]> getColumns() {
28295       return this.columns;
28296     }
28297 
28298     /**
28299      * columns to scan. If column name is a column family, all
28300      * columns of the specified column family are returned. It's also possible
28301      * to pass a regex in the column qualifier.
28302      */
28303     public scannerOpen_args setColumns(List<byte[]> columns) {
28304       this.columns = columns;
28305       return this;
28306     }
28307 
28308     public void unsetColumns() {
28309       this.columns = null;
28310     }
28311 
28312     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
28313     public boolean isSetColumns() {
28314       return this.columns != null;
28315     }
28316 
28317     public void setColumnsIsSet(boolean value) {
28318       if (!value) {
28319         this.columns = null;
28320       }
28321     }
28322 
28323     public void setFieldValue(_Fields field, Object value) {
28324       switch (field) {
28325       case TABLE_NAME:
28326         if (value == null) {
28327           unsetTableName();
28328         } else {
28329           setTableName((byte[])value);
28330         }
28331         break;
28332 
28333       case START_ROW:
28334         if (value == null) {
28335           unsetStartRow();
28336         } else {
28337           setStartRow((byte[])value);
28338         }
28339         break;
28340 
28341       case COLUMNS:
28342         if (value == null) {
28343           unsetColumns();
28344         } else {
28345           setColumns((List<byte[]>)value);
28346         }
28347         break;
28348 
28349       }
28350     }
28351 
28352     public void setFieldValue(int fieldID, Object value) {
28353       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
28354     }
28355 
28356     public Object getFieldValue(_Fields field) {
28357       switch (field) {
28358       case TABLE_NAME:
28359         return getTableName();
28360 
28361       case START_ROW:
28362         return getStartRow();
28363 
28364       case COLUMNS:
28365         return getColumns();
28366 
28367       }
28368       throw new IllegalStateException();
28369     }
28370 
28371     public Object getFieldValue(int fieldId) {
28372       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
28373     }
28374 
28375     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
28376     public boolean isSet(_Fields field) {
28377       switch (field) {
28378       case TABLE_NAME:
28379         return isSetTableName();
28380       case START_ROW:
28381         return isSetStartRow();
28382       case COLUMNS:
28383         return isSetColumns();
28384       }
28385       throw new IllegalStateException();
28386     }
28387 
28388     public boolean isSet(int fieldID) {
28389       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
28390     }
28391 
28392     @Override
28393     public boolean equals(Object that) {
28394       if (that == null)
28395         return false;
28396       if (that instanceof scannerOpen_args)
28397         return this.equals((scannerOpen_args)that);
28398       return false;
28399     }
28400 
28401     public boolean equals(scannerOpen_args that) {
28402       if (that == null)
28403         return false;
28404 
28405       boolean this_present_tableName = true && this.isSetTableName();
28406       boolean that_present_tableName = true && that.isSetTableName();
28407       if (this_present_tableName || that_present_tableName) {
28408         if (!(this_present_tableName && that_present_tableName))
28409           return false;
28410         if (!java.util.Arrays.equals(this.tableName, that.tableName))
28411           return false;
28412       }
28413 
28414       boolean this_present_startRow = true && this.isSetStartRow();
28415       boolean that_present_startRow = true && that.isSetStartRow();
28416       if (this_present_startRow || that_present_startRow) {
28417         if (!(this_present_startRow && that_present_startRow))
28418           return false;
28419         if (!java.util.Arrays.equals(this.startRow, that.startRow))
28420           return false;
28421       }
28422 
28423       boolean this_present_columns = true && this.isSetColumns();
28424       boolean that_present_columns = true && that.isSetColumns();
28425       if (this_present_columns || that_present_columns) {
28426         if (!(this_present_columns && that_present_columns))
28427           return false;
28428         if (!this.columns.equals(that.columns))
28429           return false;
28430       }
28431 
28432       return true;
28433     }
28434 
28435     @Override
28436     public int hashCode() {
28437       HashCodeBuilder builder = new HashCodeBuilder();
28438 
28439       boolean present_tableName = true && (isSetTableName());
28440       builder.append(present_tableName);
28441       if (present_tableName)
28442         builder.append(tableName);
28443 
28444       boolean present_startRow = true && (isSetStartRow());
28445       builder.append(present_startRow);
28446       if (present_startRow)
28447         builder.append(startRow);
28448 
28449       boolean present_columns = true && (isSetColumns());
28450       builder.append(present_columns);
28451       if (present_columns)
28452         builder.append(columns);
28453 
28454       return builder.toHashCode();
28455     }
28456 
28457     public int compareTo(scannerOpen_args other) {
28458       if (!getClass().equals(other.getClass())) {
28459         return getClass().getName().compareTo(other.getClass().getName());
28460       }
28461 
28462       int lastComparison = 0;
28463       scannerOpen_args typedOther = (scannerOpen_args)other;
28464 
28465       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
28466       if (lastComparison != 0) {
28467         return lastComparison;
28468       }
28469       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
28470       if (lastComparison != 0) {
28471         return lastComparison;
28472       }
28473       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
28474       if (lastComparison != 0) {
28475         return lastComparison;
28476       }
28477       lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
28478       if (lastComparison != 0) {
28479         return lastComparison;
28480       }
28481       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
28482       if (lastComparison != 0) {
28483         return lastComparison;
28484       }
28485       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
28486       if (lastComparison != 0) {
28487         return lastComparison;
28488       }
28489       return 0;
28490     }
28491 
28492     public void read(TProtocol iprot) throws TException {
28493       TField field;
28494       iprot.readStructBegin();
28495       while (true)
28496       {
28497         field = iprot.readFieldBegin();
28498         if (field.type == TType.STOP) {
28499           break;
28500         }
28501         _Fields fieldId = _Fields.findByThriftId(field.id);
28502         if (fieldId == null) {
28503           TProtocolUtil.skip(iprot, field.type);
28504         } else {
28505           switch (fieldId) {
28506             case TABLE_NAME:
28507               if (field.type == TType.STRING) {
28508                 this.tableName = iprot.readBinary();
28509               } else {
28510                 TProtocolUtil.skip(iprot, field.type);
28511               }
28512               break;
28513             case START_ROW:
28514               if (field.type == TType.STRING) {
28515                 this.startRow = iprot.readBinary();
28516               } else {
28517                 TProtocolUtil.skip(iprot, field.type);
28518               }
28519               break;
28520             case COLUMNS:
28521               if (field.type == TType.LIST) {
28522                 {
28523                   TList _list118 = iprot.readListBegin();
28524                   this.columns = new ArrayList<byte[]>(_list118.size);
28525                   for (int _i119 = 0; _i119 < _list118.size; ++_i119)
28526                   {
28527                     byte[] _elem120;
28528                     _elem120 = iprot.readBinary();
28529                     this.columns.add(_elem120);
28530                   }
28531                   iprot.readListEnd();
28532                 }
28533               } else {
28534                 TProtocolUtil.skip(iprot, field.type);
28535               }
28536               break;
28537           }
28538           iprot.readFieldEnd();
28539         }
28540       }
28541       iprot.readStructEnd();
28542 
28543       // check for required fields of primitive type, which can't be checked in the validate method
28544       validate();
28545     }
28546 
28547     public void write(TProtocol oprot) throws TException {
28548       validate();
28549 
28550       oprot.writeStructBegin(STRUCT_DESC);
28551       if (this.tableName != null) {
28552         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
28553         oprot.writeBinary(this.tableName);
28554         oprot.writeFieldEnd();
28555       }
28556       if (this.startRow != null) {
28557         oprot.writeFieldBegin(START_ROW_FIELD_DESC);
28558         oprot.writeBinary(this.startRow);
28559         oprot.writeFieldEnd();
28560       }
28561       if (this.columns != null) {
28562         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
28563         {
28564           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
28565           for (byte[] _iter121 : this.columns)
28566           {
28567             oprot.writeBinary(_iter121);
28568           }
28569           oprot.writeListEnd();
28570         }
28571         oprot.writeFieldEnd();
28572       }
28573       oprot.writeFieldStop();
28574       oprot.writeStructEnd();
28575     }
28576 
28577     @Override
28578     public String toString() {
28579       StringBuilder sb = new StringBuilder("scannerOpen_args(");
28580       boolean first = true;
28581 
28582       sb.append("tableName:");
28583       if (this.tableName == null) {
28584         sb.append("null");
28585       } else {
28586         sb.append(this.tableName);
28587       }
28588       first = false;
28589       if (!first) sb.append(", ");
28590       sb.append("startRow:");
28591       if (this.startRow == null) {
28592         sb.append("null");
28593       } else {
28594         sb.append(this.startRow);
28595       }
28596       first = false;
28597       if (!first) sb.append(", ");
28598       sb.append("columns:");
28599       if (this.columns == null) {
28600         sb.append("null");
28601       } else {
28602         sb.append(this.columns);
28603       }
28604       first = false;
28605       sb.append(")");
28606       return sb.toString();
28607     }
28608 
28609     public void validate() throws TException {
28610       // check for required fields
28611     }
28612 
28613   }
28614 
28615   public static class scannerOpen_result implements TBase<scannerOpen_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_result>   {
28616     private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_result");
28617 
28618     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
28619     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
28620 
28621     public int success;
28622     public IOError io;
28623 
28624     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
28625     public enum _Fields implements TFieldIdEnum {
28626       SUCCESS((short)0, "success"),
28627       IO((short)1, "io");
28628 
28629       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
28630       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
28631 
28632       static {
28633         for (_Fields field : EnumSet.allOf(_Fields.class)) {
28634           byId.put((int)field._thriftId, field);
28635           byName.put(field.getFieldName(), field);
28636         }
28637       }
28638 
28639       /**
28640        * Find the _Fields constant that matches fieldId, or null if its not found.
28641        */
28642       public static _Fields findByThriftId(int fieldId) {
28643         return byId.get(fieldId);
28644       }
28645 
28646       /**
28647        * Find the _Fields constant that matches fieldId, throwing an exception
28648        * if it is not found.
28649        */
28650       public static _Fields findByThriftIdOrThrow(int fieldId) {
28651         _Fields fields = findByThriftId(fieldId);
28652         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
28653         return fields;
28654       }
28655 
28656       /**
28657        * Find the _Fields constant that matches name, or null if its not found.
28658        */
28659       public static _Fields findByName(String name) {
28660         return byName.get(name);
28661       }
28662 
28663       private final short _thriftId;
28664       private final String _fieldName;
28665 
28666       _Fields(short thriftId, String fieldName) {
28667         _thriftId = thriftId;
28668         _fieldName = fieldName;
28669       }
28670 
28671       public short getThriftFieldId() {
28672         return _thriftId;
28673       }
28674 
28675       public String getFieldName() {
28676         return _fieldName;
28677       }
28678     }
28679 
28680     // isset id assignments
28681     private static final int __SUCCESS_ISSET_ID = 0;
28682     private BitSet __isset_bit_vector = new BitSet(1);
28683 
28684     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
28685       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
28686           new FieldValueMetaData(TType.I32)));
28687       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
28688           new FieldValueMetaData(TType.STRUCT)));
28689     }});
28690 
28691     static {
28692       FieldMetaData.addStructMetaDataMap(scannerOpen_result.class, metaDataMap);
28693     }
28694 
28695     public scannerOpen_result() {
28696     }
28697 
28698     public scannerOpen_result(
28699       int success,
28700       IOError io)
28701     {
28702       this();
28703       this.success = success;
28704       setSuccessIsSet(true);
28705       this.io = io;
28706     }
28707 
28708     /**
28709      * Performs a deep copy on <i>other</i>.
28710      */
28711     public scannerOpen_result(scannerOpen_result other) {
28712       __isset_bit_vector.clear();
28713       __isset_bit_vector.or(other.__isset_bit_vector);
28714       this.success = other.success;
28715       if (other.isSetIo()) {
28716         this.io = new IOError(other.io);
28717       }
28718     }
28719 
28720     public scannerOpen_result deepCopy() {
28721       return new scannerOpen_result(this);
28722     }
28723 
28724     @Deprecated
28725     public scannerOpen_result clone() {
28726       return new scannerOpen_result(this);
28727     }
28728 
28729     public int getSuccess() {
28730       return this.success;
28731     }
28732 
28733     public scannerOpen_result setSuccess(int success) {
28734       this.success = success;
28735       setSuccessIsSet(true);
28736       return this;
28737     }
28738 
28739     public void unsetSuccess() {
28740       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
28741     }
28742 
28743     /** Returns true if field success is set (has been asigned a value) and false otherwise */
28744     public boolean isSetSuccess() {
28745       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
28746     }
28747 
28748     public void setSuccessIsSet(boolean value) {
28749       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
28750     }
28751 
28752     public IOError getIo() {
28753       return this.io;
28754     }
28755 
28756     public scannerOpen_result setIo(IOError io) {
28757       this.io = io;
28758       return this;
28759     }
28760 
28761     public void unsetIo() {
28762       this.io = null;
28763     }
28764 
28765     /** Returns true if field io is set (has been asigned a value) and false otherwise */
28766     public boolean isSetIo() {
28767       return this.io != null;
28768     }
28769 
28770     public void setIoIsSet(boolean value) {
28771       if (!value) {
28772         this.io = null;
28773       }
28774     }
28775 
28776     public void setFieldValue(_Fields field, Object value) {
28777       switch (field) {
28778       case SUCCESS:
28779         if (value == null) {
28780           unsetSuccess();
28781         } else {
28782           setSuccess((Integer)value);
28783         }
28784         break;
28785 
28786       case IO:
28787         if (value == null) {
28788           unsetIo();
28789         } else {
28790           setIo((IOError)value);
28791         }
28792         break;
28793 
28794       }
28795     }
28796 
28797     public void setFieldValue(int fieldID, Object value) {
28798       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
28799     }
28800 
28801     public Object getFieldValue(_Fields field) {
28802       switch (field) {
28803       case SUCCESS:
28804         return new Integer(getSuccess());
28805 
28806       case IO:
28807         return getIo();
28808 
28809       }
28810       throw new IllegalStateException();
28811     }
28812 
28813     public Object getFieldValue(int fieldId) {
28814       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
28815     }
28816 
28817     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
28818     public boolean isSet(_Fields field) {
28819       switch (field) {
28820       case SUCCESS:
28821         return isSetSuccess();
28822       case IO:
28823         return isSetIo();
28824       }
28825       throw new IllegalStateException();
28826     }
28827 
28828     public boolean isSet(int fieldID) {
28829       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
28830     }
28831 
28832     @Override
28833     public boolean equals(Object that) {
28834       if (that == null)
28835         return false;
28836       if (that instanceof scannerOpen_result)
28837         return this.equals((scannerOpen_result)that);
28838       return false;
28839     }
28840 
28841     public boolean equals(scannerOpen_result that) {
28842       if (that == null)
28843         return false;
28844 
28845       boolean this_present_success = true;
28846       boolean that_present_success = true;
28847       if (this_present_success || that_present_success) {
28848         if (!(this_present_success && that_present_success))
28849           return false;
28850         if (this.success != that.success)
28851           return false;
28852       }
28853 
28854       boolean this_present_io = true && this.isSetIo();
28855       boolean that_present_io = true && that.isSetIo();
28856       if (this_present_io || that_present_io) {
28857         if (!(this_present_io && that_present_io))
28858           return false;
28859         if (!this.io.equals(that.io))
28860           return false;
28861       }
28862 
28863       return true;
28864     }
28865 
28866     @Override
28867     public int hashCode() {
28868       HashCodeBuilder builder = new HashCodeBuilder();
28869 
28870       boolean present_success = true;
28871       builder.append(present_success);
28872       if (present_success)
28873         builder.append(success);
28874 
28875       boolean present_io = true && (isSetIo());
28876       builder.append(present_io);
28877       if (present_io)
28878         builder.append(io);
28879 
28880       return builder.toHashCode();
28881     }
28882 
28883     public int compareTo(scannerOpen_result other) {
28884       if (!getClass().equals(other.getClass())) {
28885         return getClass().getName().compareTo(other.getClass().getName());
28886       }
28887 
28888       int lastComparison = 0;
28889       scannerOpen_result typedOther = (scannerOpen_result)other;
28890 
28891       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
28892       if (lastComparison != 0) {
28893         return lastComparison;
28894       }
28895       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
28896       if (lastComparison != 0) {
28897         return lastComparison;
28898       }
28899       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
28900       if (lastComparison != 0) {
28901         return lastComparison;
28902       }
28903       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
28904       if (lastComparison != 0) {
28905         return lastComparison;
28906       }
28907       return 0;
28908     }
28909 
28910     public void read(TProtocol iprot) throws TException {
28911       TField field;
28912       iprot.readStructBegin();
28913       while (true)
28914       {
28915         field = iprot.readFieldBegin();
28916         if (field.type == TType.STOP) {
28917           break;
28918         }
28919         _Fields fieldId = _Fields.findByThriftId(field.id);
28920         if (fieldId == null) {
28921           TProtocolUtil.skip(iprot, field.type);
28922         } else {
28923           switch (fieldId) {
28924             case SUCCESS:
28925               if (field.type == TType.I32) {
28926                 this.success = iprot.readI32();
28927                 setSuccessIsSet(true);
28928               } else {
28929                 TProtocolUtil.skip(iprot, field.type);
28930               }
28931               break;
28932             case IO:
28933               if (field.type == TType.STRUCT) {
28934                 this.io = new IOError();
28935                 this.io.read(iprot);
28936               } else {
28937                 TProtocolUtil.skip(iprot, field.type);
28938               }
28939               break;
28940           }
28941           iprot.readFieldEnd();
28942         }
28943       }
28944       iprot.readStructEnd();
28945 
28946       // check for required fields of primitive type, which can't be checked in the validate method
28947       validate();
28948     }
28949 
28950     public void write(TProtocol oprot) throws TException {
28951       oprot.writeStructBegin(STRUCT_DESC);
28952 
28953       if (this.isSetSuccess()) {
28954         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28955         oprot.writeI32(this.success);
28956         oprot.writeFieldEnd();
28957       } else if (this.isSetIo()) {
28958         oprot.writeFieldBegin(IO_FIELD_DESC);
28959         this.io.write(oprot);
28960         oprot.writeFieldEnd();
28961       }
28962       oprot.writeFieldStop();
28963       oprot.writeStructEnd();
28964     }
28965 
28966     @Override
28967     public String toString() {
28968       StringBuilder sb = new StringBuilder("scannerOpen_result(");
28969       boolean first = true;
28970 
28971       sb.append("success:");
28972       sb.append(this.success);
28973       first = false;
28974       if (!first) sb.append(", ");
28975       sb.append("io:");
28976       if (this.io == null) {
28977         sb.append("null");
28978       } else {
28979         sb.append(this.io);
28980       }
28981       first = false;
28982       sb.append(")");
28983       return sb.toString();
28984     }
28985 
28986     public void validate() throws TException {
28987       // check for required fields
28988     }
28989 
28990   }
28991 
28992   public static class scannerOpenWithStop_args implements TBase<scannerOpenWithStop_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_args>   {
28993     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_args");
28994 
28995     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
28996     private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
28997     private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3);
28998     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4);
28999 
29000     /**
29001      * name of table
29002      */
29003     public byte[] tableName;
29004     /**
29005      * Starting row in table to scan.
29006      * Send "" (empty string) to start at the first row.
29007      */
29008     public byte[] startRow;
29009     /**
29010      * row to stop scanning on. This row is *not* included in the
29011      * scanner's results
29012      */
29013     public byte[] stopRow;
29014     /**
29015      * columns to scan. If column name is a column family, all
29016      * columns of the specified column family are returned. It's also possible
29017      * to pass a regex in the column qualifier.
29018      */
29019     public List<byte[]> columns;
29020 
29021     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
29022     public enum _Fields implements TFieldIdEnum {
29023       /**
29024        * name of table
29025        */
29026       TABLE_NAME((short)1, "tableName"),
29027       /**
29028        * Starting row in table to scan.
29029        * Send "" (empty string) to start at the first row.
29030        */
29031       START_ROW((short)2, "startRow"),
29032       /**
29033        * row to stop scanning on. This row is *not* included in the
29034        * scanner's results
29035        */
29036       STOP_ROW((short)3, "stopRow"),
29037       /**
29038        * columns to scan. If column name is a column family, all
29039        * columns of the specified column family are returned. It's also possible
29040        * to pass a regex in the column qualifier.
29041        */
29042       COLUMNS((short)4, "columns");
29043 
29044       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29045       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29046 
29047       static {
29048         for (_Fields field : EnumSet.allOf(_Fields.class)) {
29049           byId.put((int)field._thriftId, field);
29050           byName.put(field.getFieldName(), field);
29051         }
29052       }
29053 
29054       /**
29055        * Find the _Fields constant that matches fieldId, or null if its not found.
29056        */
29057       public static _Fields findByThriftId(int fieldId) {
29058         return byId.get(fieldId);
29059       }
29060 
29061       /**
29062        * Find the _Fields constant that matches fieldId, throwing an exception
29063        * if it is not found.
29064        */
29065       public static _Fields findByThriftIdOrThrow(int fieldId) {
29066         _Fields fields = findByThriftId(fieldId);
29067         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29068         return fields;
29069       }
29070 
29071       /**
29072        * Find the _Fields constant that matches name, or null if its not found.
29073        */
29074       public static _Fields findByName(String name) {
29075         return byName.get(name);
29076       }
29077 
29078       private final short _thriftId;
29079       private final String _fieldName;
29080 
29081       _Fields(short thriftId, String fieldName) {
29082         _thriftId = thriftId;
29083         _fieldName = fieldName;
29084       }
29085 
29086       public short getThriftFieldId() {
29087         return _thriftId;
29088       }
29089 
29090       public String getFieldName() {
29091         return _fieldName;
29092       }
29093     }
29094 
29095     // isset id assignments
29096 
29097     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29098       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
29099           new FieldValueMetaData(TType.STRING)));
29100       put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
29101           new FieldValueMetaData(TType.STRING)));
29102       put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT,
29103           new FieldValueMetaData(TType.STRING)));
29104       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
29105           new ListMetaData(TType.LIST,
29106               new FieldValueMetaData(TType.STRING))));
29107     }});
29108 
29109     static {
29110       FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_args.class, metaDataMap);
29111     }
29112 
29113     public scannerOpenWithStop_args() {
29114     }
29115 
29116     public scannerOpenWithStop_args(
29117       byte[] tableName,
29118       byte[] startRow,
29119       byte[] stopRow,
29120       List<byte[]> columns)
29121     {
29122       this();
29123       this.tableName = tableName;
29124       this.startRow = startRow;
29125       this.stopRow = stopRow;
29126       this.columns = columns;
29127     }
29128 
29129     /**
29130      * Performs a deep copy on <i>other</i>.
29131      */
29132     public scannerOpenWithStop_args(scannerOpenWithStop_args other) {
29133       if (other.isSetTableName()) {
29134         this.tableName = other.tableName;
29135       }
29136       if (other.isSetStartRow()) {
29137         this.startRow = other.startRow;
29138       }
29139       if (other.isSetStopRow()) {
29140         this.stopRow = other.stopRow;
29141       }
29142       if (other.isSetColumns()) {
29143         List<byte[]> __this__columns = new ArrayList<byte[]>();
29144         for (byte[] other_element : other.columns) {
29145           __this__columns.add(other_element);
29146         }
29147         this.columns = __this__columns;
29148       }
29149     }
29150 
29151     public scannerOpenWithStop_args deepCopy() {
29152       return new scannerOpenWithStop_args(this);
29153     }
29154 
29155     @Deprecated
29156     public scannerOpenWithStop_args clone() {
29157       return new scannerOpenWithStop_args(this);
29158     }
29159 
29160     /**
29161      * name of table
29162      */
29163     public byte[] getTableName() {
29164       return this.tableName;
29165     }
29166 
29167     /**
29168      * name of table
29169      */
29170     public scannerOpenWithStop_args setTableName(byte[] tableName) {
29171       this.tableName = tableName;
29172       return this;
29173     }
29174 
29175     public void unsetTableName() {
29176       this.tableName = null;
29177     }
29178 
29179     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
29180     public boolean isSetTableName() {
29181       return this.tableName != null;
29182     }
29183 
29184     public void setTableNameIsSet(boolean value) {
29185       if (!value) {
29186         this.tableName = null;
29187       }
29188     }
29189 
29190     /**
29191      * Starting row in table to scan.
29192      * Send "" (empty string) to start at the first row.
29193      */
29194     public byte[] getStartRow() {
29195       return this.startRow;
29196     }
29197 
29198     /**
29199      * Starting row in table to scan.
29200      * Send "" (empty string) to start at the first row.
29201      */
29202     public scannerOpenWithStop_args setStartRow(byte[] startRow) {
29203       this.startRow = startRow;
29204       return this;
29205     }
29206 
29207     public void unsetStartRow() {
29208       this.startRow = null;
29209     }
29210 
29211     /** Returns true if field startRow is set (has been asigned a value) and false otherwise */
29212     public boolean isSetStartRow() {
29213       return this.startRow != null;
29214     }
29215 
29216     public void setStartRowIsSet(boolean value) {
29217       if (!value) {
29218         this.startRow = null;
29219       }
29220     }
29221 
29222     /**
29223      * row to stop scanning on. This row is *not* included in the
29224      * scanner's results
29225      */
29226     public byte[] getStopRow() {
29227       return this.stopRow;
29228     }
29229 
29230     /**
29231      * row to stop scanning on. This row is *not* included in the
29232      * scanner's results
29233      */
29234     public scannerOpenWithStop_args setStopRow(byte[] stopRow) {
29235       this.stopRow = stopRow;
29236       return this;
29237     }
29238 
29239     public void unsetStopRow() {
29240       this.stopRow = null;
29241     }
29242 
29243     /** Returns true if field stopRow is set (has been asigned a value) and false otherwise */
29244     public boolean isSetStopRow() {
29245       return this.stopRow != null;
29246     }
29247 
29248     public void setStopRowIsSet(boolean value) {
29249       if (!value) {
29250         this.stopRow = null;
29251       }
29252     }
29253 
29254     public int getColumnsSize() {
29255       return (this.columns == null) ? 0 : this.columns.size();
29256     }
29257 
29258     public java.util.Iterator<byte[]> getColumnsIterator() {
29259       return (this.columns == null) ? null : this.columns.iterator();
29260     }
29261 
29262     public void addToColumns(byte[] elem) {
29263       if (this.columns == null) {
29264         this.columns = new ArrayList<byte[]>();
29265       }
29266       this.columns.add(elem);
29267     }
29268 
29269     /**
29270      * columns to scan. If column name is a column family, all
29271      * columns of the specified column family are returned. It's also possible
29272      * to pass a regex in the column qualifier.
29273      */
29274     public List<byte[]> getColumns() {
29275       return this.columns;
29276     }
29277 
29278     /**
29279      * columns to scan. If column name is a column family, all
29280      * columns of the specified column family are returned. It's also possible
29281      * to pass a regex in the column qualifier.
29282      */
29283     public scannerOpenWithStop_args setColumns(List<byte[]> columns) {
29284       this.columns = columns;
29285       return this;
29286     }
29287 
29288     public void unsetColumns() {
29289       this.columns = null;
29290     }
29291 
29292     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
29293     public boolean isSetColumns() {
29294       return this.columns != null;
29295     }
29296 
29297     public void setColumnsIsSet(boolean value) {
29298       if (!value) {
29299         this.columns = null;
29300       }
29301     }
29302 
29303     public void setFieldValue(_Fields field, Object value) {
29304       switch (field) {
29305       case TABLE_NAME:
29306         if (value == null) {
29307           unsetTableName();
29308         } else {
29309           setTableName((byte[])value);
29310         }
29311         break;
29312 
29313       case START_ROW:
29314         if (value == null) {
29315           unsetStartRow();
29316         } else {
29317           setStartRow((byte[])value);
29318         }
29319         break;
29320 
29321       case STOP_ROW:
29322         if (value == null) {
29323           unsetStopRow();
29324         } else {
29325           setStopRow((byte[])value);
29326         }
29327         break;
29328 
29329       case COLUMNS:
29330         if (value == null) {
29331           unsetColumns();
29332         } else {
29333           setColumns((List<byte[]>)value);
29334         }
29335         break;
29336 
29337       }
29338     }
29339 
29340     public void setFieldValue(int fieldID, Object value) {
29341       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29342     }
29343 
29344     public Object getFieldValue(_Fields field) {
29345       switch (field) {
29346       case TABLE_NAME:
29347         return getTableName();
29348 
29349       case START_ROW:
29350         return getStartRow();
29351 
29352       case STOP_ROW:
29353         return getStopRow();
29354 
29355       case COLUMNS:
29356         return getColumns();
29357 
29358       }
29359       throw new IllegalStateException();
29360     }
29361 
29362     public Object getFieldValue(int fieldId) {
29363       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29364     }
29365 
29366     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
29367     public boolean isSet(_Fields field) {
29368       switch (field) {
29369       case TABLE_NAME:
29370         return isSetTableName();
29371       case START_ROW:
29372         return isSetStartRow();
29373       case STOP_ROW:
29374         return isSetStopRow();
29375       case COLUMNS:
29376         return isSetColumns();
29377       }
29378       throw new IllegalStateException();
29379     }
29380 
29381     public boolean isSet(int fieldID) {
29382       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
29383     }
29384 
29385     @Override
29386     public boolean equals(Object that) {
29387       if (that == null)
29388         return false;
29389       if (that instanceof scannerOpenWithStop_args)
29390         return this.equals((scannerOpenWithStop_args)that);
29391       return false;
29392     }
29393 
29394     public boolean equals(scannerOpenWithStop_args that) {
29395       if (that == null)
29396         return false;
29397 
29398       boolean this_present_tableName = true && this.isSetTableName();
29399       boolean that_present_tableName = true && that.isSetTableName();
29400       if (this_present_tableName || that_present_tableName) {
29401         if (!(this_present_tableName && that_present_tableName))
29402           return false;
29403         if (!java.util.Arrays.equals(this.tableName, that.tableName))
29404           return false;
29405       }
29406 
29407       boolean this_present_startRow = true && this.isSetStartRow();
29408       boolean that_present_startRow = true && that.isSetStartRow();
29409       if (this_present_startRow || that_present_startRow) {
29410         if (!(this_present_startRow && that_present_startRow))
29411           return false;
29412         if (!java.util.Arrays.equals(this.startRow, that.startRow))
29413           return false;
29414       }
29415 
29416       boolean this_present_stopRow = true && this.isSetStopRow();
29417       boolean that_present_stopRow = true && that.isSetStopRow();
29418       if (this_present_stopRow || that_present_stopRow) {
29419         if (!(this_present_stopRow && that_present_stopRow))
29420           return false;
29421         if (!java.util.Arrays.equals(this.stopRow, that.stopRow))
29422           return false;
29423       }
29424 
29425       boolean this_present_columns = true && this.isSetColumns();
29426       boolean that_present_columns = true && that.isSetColumns();
29427       if (this_present_columns || that_present_columns) {
29428         if (!(this_present_columns && that_present_columns))
29429           return false;
29430         if (!this.columns.equals(that.columns))
29431           return false;
29432       }
29433 
29434       return true;
29435     }
29436 
29437     @Override
29438     public int hashCode() {
29439       HashCodeBuilder builder = new HashCodeBuilder();
29440 
29441       boolean present_tableName = true && (isSetTableName());
29442       builder.append(present_tableName);
29443       if (present_tableName)
29444         builder.append(tableName);
29445 
29446       boolean present_startRow = true && (isSetStartRow());
29447       builder.append(present_startRow);
29448       if (present_startRow)
29449         builder.append(startRow);
29450 
29451       boolean present_stopRow = true && (isSetStopRow());
29452       builder.append(present_stopRow);
29453       if (present_stopRow)
29454         builder.append(stopRow);
29455 
29456       boolean present_columns = true && (isSetColumns());
29457       builder.append(present_columns);
29458       if (present_columns)
29459         builder.append(columns);
29460 
29461       return builder.toHashCode();
29462     }
29463 
29464     public int compareTo(scannerOpenWithStop_args other) {
29465       if (!getClass().equals(other.getClass())) {
29466         return getClass().getName().compareTo(other.getClass().getName());
29467       }
29468 
29469       int lastComparison = 0;
29470       scannerOpenWithStop_args typedOther = (scannerOpenWithStop_args)other;
29471 
29472       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
29473       if (lastComparison != 0) {
29474         return lastComparison;
29475       }
29476       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
29477       if (lastComparison != 0) {
29478         return lastComparison;
29479       }
29480       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
29481       if (lastComparison != 0) {
29482         return lastComparison;
29483       }
29484       lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
29485       if (lastComparison != 0) {
29486         return lastComparison;
29487       }
29488       lastComparison = Boolean.valueOf(isSetStopRow()).compareTo(isSetStopRow());
29489       if (lastComparison != 0) {
29490         return lastComparison;
29491       }
29492       lastComparison = TBaseHelper.compareTo(stopRow, typedOther.stopRow);
29493       if (lastComparison != 0) {
29494         return lastComparison;
29495       }
29496       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
29497       if (lastComparison != 0) {
29498         return lastComparison;
29499       }
29500       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
29501       if (lastComparison != 0) {
29502         return lastComparison;
29503       }
29504       return 0;
29505     }
29506 
29507     public void read(TProtocol iprot) throws TException {
29508       TField field;
29509       iprot.readStructBegin();
29510       while (true)
29511       {
29512         field = iprot.readFieldBegin();
29513         if (field.type == TType.STOP) {
29514           break;
29515         }
29516         _Fields fieldId = _Fields.findByThriftId(field.id);
29517         if (fieldId == null) {
29518           TProtocolUtil.skip(iprot, field.type);
29519         } else {
29520           switch (fieldId) {
29521             case TABLE_NAME:
29522               if (field.type == TType.STRING) {
29523                 this.tableName = iprot.readBinary();
29524               } else {
29525                 TProtocolUtil.skip(iprot, field.type);
29526               }
29527               break;
29528             case START_ROW:
29529               if (field.type == TType.STRING) {
29530                 this.startRow = iprot.readBinary();
29531               } else {
29532                 TProtocolUtil.skip(iprot, field.type);
29533               }
29534               break;
29535             case STOP_ROW:
29536               if (field.type == TType.STRING) {
29537                 this.stopRow = iprot.readBinary();
29538               } else {
29539                 TProtocolUtil.skip(iprot, field.type);
29540               }
29541               break;
29542             case COLUMNS:
29543               if (field.type == TType.LIST) {
29544                 {
29545                   TList _list122 = iprot.readListBegin();
29546                   this.columns = new ArrayList<byte[]>(_list122.size);
29547                   for (int _i123 = 0; _i123 < _list122.size; ++_i123)
29548                   {
29549                     byte[] _elem124;
29550                     _elem124 = iprot.readBinary();
29551                     this.columns.add(_elem124);
29552                   }
29553                   iprot.readListEnd();
29554                 }
29555               } else {
29556                 TProtocolUtil.skip(iprot, field.type);
29557               }
29558               break;
29559           }
29560           iprot.readFieldEnd();
29561         }
29562       }
29563       iprot.readStructEnd();
29564 
29565       // check for required fields of primitive type, which can't be checked in the validate method
29566       validate();
29567     }
29568 
29569     public void write(TProtocol oprot) throws TException {
29570       validate();
29571 
29572       oprot.writeStructBegin(STRUCT_DESC);
29573       if (this.tableName != null) {
29574         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
29575         oprot.writeBinary(this.tableName);
29576         oprot.writeFieldEnd();
29577       }
29578       if (this.startRow != null) {
29579         oprot.writeFieldBegin(START_ROW_FIELD_DESC);
29580         oprot.writeBinary(this.startRow);
29581         oprot.writeFieldEnd();
29582       }
29583       if (this.stopRow != null) {
29584         oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
29585         oprot.writeBinary(this.stopRow);
29586         oprot.writeFieldEnd();
29587       }
29588       if (this.columns != null) {
29589         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
29590         {
29591           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
29592           for (byte[] _iter125 : this.columns)
29593           {
29594             oprot.writeBinary(_iter125);
29595           }
29596           oprot.writeListEnd();
29597         }
29598         oprot.writeFieldEnd();
29599       }
29600       oprot.writeFieldStop();
29601       oprot.writeStructEnd();
29602     }
29603 
29604     @Override
29605     public String toString() {
29606       StringBuilder sb = new StringBuilder("scannerOpenWithStop_args(");
29607       boolean first = true;
29608 
29609       sb.append("tableName:");
29610       if (this.tableName == null) {
29611         sb.append("null");
29612       } else {
29613         sb.append(this.tableName);
29614       }
29615       first = false;
29616       if (!first) sb.append(", ");
29617       sb.append("startRow:");
29618       if (this.startRow == null) {
29619         sb.append("null");
29620       } else {
29621         sb.append(this.startRow);
29622       }
29623       first = false;
29624       if (!first) sb.append(", ");
29625       sb.append("stopRow:");
29626       if (this.stopRow == null) {
29627         sb.append("null");
29628       } else {
29629         sb.append(this.stopRow);
29630       }
29631       first = false;
29632       if (!first) sb.append(", ");
29633       sb.append("columns:");
29634       if (this.columns == null) {
29635         sb.append("null");
29636       } else {
29637         sb.append(this.columns);
29638       }
29639       first = false;
29640       sb.append(")");
29641       return sb.toString();
29642     }
29643 
29644     public void validate() throws TException {
29645       // check for required fields
29646     }
29647 
29648   }
29649 
29650   public static class scannerOpenWithStop_result implements TBase<scannerOpenWithStop_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_result>   {
29651     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_result");
29652 
29653     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
29654     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
29655 
29656     public int success;
29657     public IOError io;
29658 
29659     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
29660     public enum _Fields implements TFieldIdEnum {
29661       SUCCESS((short)0, "success"),
29662       IO((short)1, "io");
29663 
29664       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29665       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29666 
29667       static {
29668         for (_Fields field : EnumSet.allOf(_Fields.class)) {
29669           byId.put((int)field._thriftId, field);
29670           byName.put(field.getFieldName(), field);
29671         }
29672       }
29673 
29674       /**
29675        * Find the _Fields constant that matches fieldId, or null if its not found.
29676        */
29677       public static _Fields findByThriftId(int fieldId) {
29678         return byId.get(fieldId);
29679       }
29680 
29681       /**
29682        * Find the _Fields constant that matches fieldId, throwing an exception
29683        * if it is not found.
29684        */
29685       public static _Fields findByThriftIdOrThrow(int fieldId) {
29686         _Fields fields = findByThriftId(fieldId);
29687         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29688         return fields;
29689       }
29690 
29691       /**
29692        * Find the _Fields constant that matches name, or null if its not found.
29693        */
29694       public static _Fields findByName(String name) {
29695         return byName.get(name);
29696       }
29697 
29698       private final short _thriftId;
29699       private final String _fieldName;
29700 
29701       _Fields(short thriftId, String fieldName) {
29702         _thriftId = thriftId;
29703         _fieldName = fieldName;
29704       }
29705 
29706       public short getThriftFieldId() {
29707         return _thriftId;
29708       }
29709 
29710       public String getFieldName() {
29711         return _fieldName;
29712       }
29713     }
29714 
29715     // isset id assignments
29716     private static final int __SUCCESS_ISSET_ID = 0;
29717     private BitSet __isset_bit_vector = new BitSet(1);
29718 
29719     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29720       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
29721           new FieldValueMetaData(TType.I32)));
29722       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
29723           new FieldValueMetaData(TType.STRUCT)));
29724     }});
29725 
29726     static {
29727       FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_result.class, metaDataMap);
29728     }
29729 
29730     public scannerOpenWithStop_result() {
29731     }
29732 
29733     public scannerOpenWithStop_result(
29734       int success,
29735       IOError io)
29736     {
29737       this();
29738       this.success = success;
29739       setSuccessIsSet(true);
29740       this.io = io;
29741     }
29742 
29743     /**
29744      * Performs a deep copy on <i>other</i>.
29745      */
29746     public scannerOpenWithStop_result(scannerOpenWithStop_result other) {
29747       __isset_bit_vector.clear();
29748       __isset_bit_vector.or(other.__isset_bit_vector);
29749       this.success = other.success;
29750       if (other.isSetIo()) {
29751         this.io = new IOError(other.io);
29752       }
29753     }
29754 
29755     public scannerOpenWithStop_result deepCopy() {
29756       return new scannerOpenWithStop_result(this);
29757     }
29758 
29759     @Deprecated
29760     public scannerOpenWithStop_result clone() {
29761       return new scannerOpenWithStop_result(this);
29762     }
29763 
29764     public int getSuccess() {
29765       return this.success;
29766     }
29767 
29768     public scannerOpenWithStop_result setSuccess(int success) {
29769       this.success = success;
29770       setSuccessIsSet(true);
29771       return this;
29772     }
29773 
29774     public void unsetSuccess() {
29775       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
29776     }
29777 
29778     /** Returns true if field success is set (has been asigned a value) and false otherwise */
29779     public boolean isSetSuccess() {
29780       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
29781     }
29782 
29783     public void setSuccessIsSet(boolean value) {
29784       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
29785     }
29786 
29787     public IOError getIo() {
29788       return this.io;
29789     }
29790 
29791     public scannerOpenWithStop_result setIo(IOError io) {
29792       this.io = io;
29793       return this;
29794     }
29795 
29796     public void unsetIo() {
29797       this.io = null;
29798     }
29799 
29800     /** Returns true if field io is set (has been asigned a value) and false otherwise */
29801     public boolean isSetIo() {
29802       return this.io != null;
29803     }
29804 
29805     public void setIoIsSet(boolean value) {
29806       if (!value) {
29807         this.io = null;
29808       }
29809     }
29810 
29811     public void setFieldValue(_Fields field, Object value) {
29812       switch (field) {
29813       case SUCCESS:
29814         if (value == null) {
29815           unsetSuccess();
29816         } else {
29817           setSuccess((Integer)value);
29818         }
29819         break;
29820 
29821       case IO:
29822         if (value == null) {
29823           unsetIo();
29824         } else {
29825           setIo((IOError)value);
29826         }
29827         break;
29828 
29829       }
29830     }
29831 
29832     public void setFieldValue(int fieldID, Object value) {
29833       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29834     }
29835 
29836     public Object getFieldValue(_Fields field) {
29837       switch (field) {
29838       case SUCCESS:
29839         return new Integer(getSuccess());
29840 
29841       case IO:
29842         return getIo();
29843 
29844       }
29845       throw new IllegalStateException();
29846     }
29847 
29848     public Object getFieldValue(int fieldId) {
29849       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29850     }
29851 
29852     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
29853     public boolean isSet(_Fields field) {
29854       switch (field) {
29855       case SUCCESS:
29856         return isSetSuccess();
29857       case IO:
29858         return isSetIo();
29859       }
29860       throw new IllegalStateException();
29861     }
29862 
29863     public boolean isSet(int fieldID) {
29864       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
29865     }
29866 
29867     @Override
29868     public boolean equals(Object that) {
29869       if (that == null)
29870         return false;
29871       if (that instanceof scannerOpenWithStop_result)
29872         return this.equals((scannerOpenWithStop_result)that);
29873       return false;
29874     }
29875 
29876     public boolean equals(scannerOpenWithStop_result that) {
29877       if (that == null)
29878         return false;
29879 
29880       boolean this_present_success = true;
29881       boolean that_present_success = true;
29882       if (this_present_success || that_present_success) {
29883         if (!(this_present_success && that_present_success))
29884           return false;
29885         if (this.success != that.success)
29886           return false;
29887       }
29888 
29889       boolean this_present_io = true && this.isSetIo();
29890       boolean that_present_io = true && that.isSetIo();
29891       if (this_present_io || that_present_io) {
29892         if (!(this_present_io && that_present_io))
29893           return false;
29894         if (!this.io.equals(that.io))
29895           return false;
29896       }
29897 
29898       return true;
29899     }
29900 
29901     @Override
29902     public int hashCode() {
29903       HashCodeBuilder builder = new HashCodeBuilder();
29904 
29905       boolean present_success = true;
29906       builder.append(present_success);
29907       if (present_success)
29908         builder.append(success);
29909 
29910       boolean present_io = true && (isSetIo());
29911       builder.append(present_io);
29912       if (present_io)
29913         builder.append(io);
29914 
29915       return builder.toHashCode();
29916     }
29917 
29918     public int compareTo(scannerOpenWithStop_result other) {
29919       if (!getClass().equals(other.getClass())) {
29920         return getClass().getName().compareTo(other.getClass().getName());
29921       }
29922 
29923       int lastComparison = 0;
29924       scannerOpenWithStop_result typedOther = (scannerOpenWithStop_result)other;
29925 
29926       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
29927       if (lastComparison != 0) {
29928         return lastComparison;
29929       }
29930       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
29931       if (lastComparison != 0) {
29932         return lastComparison;
29933       }
29934       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
29935       if (lastComparison != 0) {
29936         return lastComparison;
29937       }
29938       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
29939       if (lastComparison != 0) {
29940         return lastComparison;
29941       }
29942       return 0;
29943     }
29944 
29945     public void read(TProtocol iprot) throws TException {
29946       TField field;
29947       iprot.readStructBegin();
29948       while (true)
29949       {
29950         field = iprot.readFieldBegin();
29951         if (field.type == TType.STOP) {
29952           break;
29953         }
29954         _Fields fieldId = _Fields.findByThriftId(field.id);
29955         if (fieldId == null) {
29956           TProtocolUtil.skip(iprot, field.type);
29957         } else {
29958           switch (fieldId) {
29959             case SUCCESS:
29960               if (field.type == TType.I32) {
29961                 this.success = iprot.readI32();
29962                 setSuccessIsSet(true);
29963               } else {
29964                 TProtocolUtil.skip(iprot, field.type);
29965               }
29966               break;
29967             case IO:
29968               if (field.type == TType.STRUCT) {
29969                 this.io = new IOError();
29970                 this.io.read(iprot);
29971               } else {
29972                 TProtocolUtil.skip(iprot, field.type);
29973               }
29974               break;
29975           }
29976           iprot.readFieldEnd();
29977         }
29978       }
29979       iprot.readStructEnd();
29980 
29981       // check for required fields of primitive type, which can't be checked in the validate method
29982       validate();
29983     }
29984 
29985     public void write(TProtocol oprot) throws TException {
29986       oprot.writeStructBegin(STRUCT_DESC);
29987 
29988       if (this.isSetSuccess()) {
29989         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29990         oprot.writeI32(this.success);
29991         oprot.writeFieldEnd();
29992       } else if (this.isSetIo()) {
29993         oprot.writeFieldBegin(IO_FIELD_DESC);
29994         this.io.write(oprot);
29995         oprot.writeFieldEnd();
29996       }
29997       oprot.writeFieldStop();
29998       oprot.writeStructEnd();
29999     }
30000 
30001     @Override
30002     public String toString() {
30003       StringBuilder sb = new StringBuilder("scannerOpenWithStop_result(");
30004       boolean first = true;
30005 
30006       sb.append("success:");
30007       sb.append(this.success);
30008       first = false;
30009       if (!first) sb.append(", ");
30010       sb.append("io:");
30011       if (this.io == null) {
30012         sb.append("null");
30013       } else {
30014         sb.append(this.io);
30015       }
30016       first = false;
30017       sb.append(")");
30018       return sb.toString();
30019     }
30020 
30021     public void validate() throws TException {
30022       // check for required fields
30023     }
30024 
30025   }
30026 
30027   public static class scannerOpenWithPrefix_args implements TBase<scannerOpenWithPrefix_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_args>   {
30028     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_args");
30029 
30030     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
30031     private static final TField START_AND_PREFIX_FIELD_DESC = new TField("startAndPrefix", TType.STRING, (short)2);
30032     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
30033 
30034     /**
30035      * name of table
30036      */
30037     public byte[] tableName;
30038     /**
30039      * the prefix (and thus start row) of the keys you want
30040      */
30041     public byte[] startAndPrefix;
30042     /**
30043      * the columns you want returned
30044      */
30045     public List<byte[]> columns;
30046 
30047     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
30048     public enum _Fields implements TFieldIdEnum {
30049       /**
30050        * name of table
30051        */
30052       TABLE_NAME((short)1, "tableName"),
30053       /**
30054        * the prefix (and thus start row) of the keys you want
30055        */
30056       START_AND_PREFIX((short)2, "startAndPrefix"),
30057       /**
30058        * the columns you want returned
30059        */
30060       COLUMNS((short)3, "columns");
30061 
30062       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30063       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30064 
30065       static {
30066         for (_Fields field : EnumSet.allOf(_Fields.class)) {
30067           byId.put((int)field._thriftId, field);
30068           byName.put(field.getFieldName(), field);
30069         }
30070       }
30071 
30072       /**
30073        * Find the _Fields constant that matches fieldId, or null if its not found.
30074        */
30075       public static _Fields findByThriftId(int fieldId) {
30076         return byId.get(fieldId);
30077       }
30078 
30079       /**
30080        * Find the _Fields constant that matches fieldId, throwing an exception
30081        * if it is not found.
30082        */
30083       public static _Fields findByThriftIdOrThrow(int fieldId) {
30084         _Fields fields = findByThriftId(fieldId);
30085         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30086         return fields;
30087       }
30088 
30089       /**
30090        * Find the _Fields constant that matches name, or null if its not found.
30091        */
30092       public static _Fields findByName(String name) {
30093         return byName.get(name);
30094       }
30095 
30096       private final short _thriftId;
30097       private final String _fieldName;
30098 
30099       _Fields(short thriftId, String fieldName) {
30100         _thriftId = thriftId;
30101         _fieldName = fieldName;
30102       }
30103 
30104       public short getThriftFieldId() {
30105         return _thriftId;
30106       }
30107 
30108       public String getFieldName() {
30109         return _fieldName;
30110       }
30111     }
30112 
30113     // isset id assignments
30114 
30115     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30116       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
30117           new FieldValueMetaData(TType.STRING)));
30118       put(_Fields.START_AND_PREFIX, new FieldMetaData("startAndPrefix", TFieldRequirementType.DEFAULT,
30119           new FieldValueMetaData(TType.STRING)));
30120       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
30121           new ListMetaData(TType.LIST,
30122               new FieldValueMetaData(TType.STRING))));
30123     }});
30124 
30125     static {
30126       FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_args.class, metaDataMap);
30127     }
30128 
30129     public scannerOpenWithPrefix_args() {
30130     }
30131 
30132     public scannerOpenWithPrefix_args(
30133       byte[] tableName,
30134       byte[] startAndPrefix,
30135       List<byte[]> columns)
30136     {
30137       this();
30138       this.tableName = tableName;
30139       this.startAndPrefix = startAndPrefix;
30140       this.columns = columns;
30141     }
30142 
30143     /**
30144      * Performs a deep copy on <i>other</i>.
30145      */
30146     public scannerOpenWithPrefix_args(scannerOpenWithPrefix_args other) {
30147       if (other.isSetTableName()) {
30148         this.tableName = other.tableName;
30149       }
30150       if (other.isSetStartAndPrefix()) {
30151         this.startAndPrefix = other.startAndPrefix;
30152       }
30153       if (other.isSetColumns()) {
30154         List<byte[]> __this__columns = new ArrayList<byte[]>();
30155         for (byte[] other_element : other.columns) {
30156           __this__columns.add(other_element);
30157         }
30158         this.columns = __this__columns;
30159       }
30160     }
30161 
30162     public scannerOpenWithPrefix_args deepCopy() {
30163       return new scannerOpenWithPrefix_args(this);
30164     }
30165 
30166     @Deprecated
30167     public scannerOpenWithPrefix_args clone() {
30168       return new scannerOpenWithPrefix_args(this);
30169     }
30170 
30171     /**
30172      * name of table
30173      */
30174     public byte[] getTableName() {
30175       return this.tableName;
30176     }
30177 
30178     /**
30179      * name of table
30180      */
30181     public scannerOpenWithPrefix_args setTableName(byte[] tableName) {
30182       this.tableName = tableName;
30183       return this;
30184     }
30185 
30186     public void unsetTableName() {
30187       this.tableName = null;
30188     }
30189 
30190     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
30191     public boolean isSetTableName() {
30192       return this.tableName != null;
30193     }
30194 
30195     public void setTableNameIsSet(boolean value) {
30196       if (!value) {
30197         this.tableName = null;
30198       }
30199     }
30200 
30201     /**
30202      * the prefix (and thus start row) of the keys you want
30203      */
30204     public byte[] getStartAndPrefix() {
30205       return this.startAndPrefix;
30206     }
30207 
30208     /**
30209      * the prefix (and thus start row) of the keys you want
30210      */
30211     public scannerOpenWithPrefix_args setStartAndPrefix(byte[] startAndPrefix) {
30212       this.startAndPrefix = startAndPrefix;
30213       return this;
30214     }
30215 
30216     public void unsetStartAndPrefix() {
30217       this.startAndPrefix = null;
30218     }
30219 
30220     /** Returns true if field startAndPrefix is set (has been asigned a value) and false otherwise */
30221     public boolean isSetStartAndPrefix() {
30222       return this.startAndPrefix != null;
30223     }
30224 
30225     public void setStartAndPrefixIsSet(boolean value) {
30226       if (!value) {
30227         this.startAndPrefix = null;
30228       }
30229     }
30230 
30231     public int getColumnsSize() {
30232       return (this.columns == null) ? 0 : this.columns.size();
30233     }
30234 
30235     public java.util.Iterator<byte[]> getColumnsIterator() {
30236       return (this.columns == null) ? null : this.columns.iterator();
30237     }
30238 
30239     public void addToColumns(byte[] elem) {
30240       if (this.columns == null) {
30241         this.columns = new ArrayList<byte[]>();
30242       }
30243       this.columns.add(elem);
30244     }
30245 
30246     /**
30247      * the columns you want returned
30248      */
30249     public List<byte[]> getColumns() {
30250       return this.columns;
30251     }
30252 
30253     /**
30254      * the columns you want returned
30255      */
30256     public scannerOpenWithPrefix_args setColumns(List<byte[]> columns) {
30257       this.columns = columns;
30258       return this;
30259     }
30260 
30261     public void unsetColumns() {
30262       this.columns = null;
30263     }
30264 
30265     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
30266     public boolean isSetColumns() {
30267       return this.columns != null;
30268     }
30269 
30270     public void setColumnsIsSet(boolean value) {
30271       if (!value) {
30272         this.columns = null;
30273       }
30274     }
30275 
30276     public void setFieldValue(_Fields field, Object value) {
30277       switch (field) {
30278       case TABLE_NAME:
30279         if (value == null) {
30280           unsetTableName();
30281         } else {
30282           setTableName((byte[])value);
30283         }
30284         break;
30285 
30286       case START_AND_PREFIX:
30287         if (value == null) {
30288           unsetStartAndPrefix();
30289         } else {
30290           setStartAndPrefix((byte[])value);
30291         }
30292         break;
30293 
30294       case COLUMNS:
30295         if (value == null) {
30296           unsetColumns();
30297         } else {
30298           setColumns((List<byte[]>)value);
30299         }
30300         break;
30301 
30302       }
30303     }
30304 
30305     public void setFieldValue(int fieldID, Object value) {
30306       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
30307     }
30308 
30309     public Object getFieldValue(_Fields field) {
30310       switch (field) {
30311       case TABLE_NAME:
30312         return getTableName();
30313 
30314       case START_AND_PREFIX:
30315         return getStartAndPrefix();
30316 
30317       case COLUMNS:
30318         return getColumns();
30319 
30320       }
30321       throw new IllegalStateException();
30322     }
30323 
30324     public Object getFieldValue(int fieldId) {
30325       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
30326     }
30327 
30328     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
30329     public boolean isSet(_Fields field) {
30330       switch (field) {
30331       case TABLE_NAME:
30332         return isSetTableName();
30333       case START_AND_PREFIX:
30334         return isSetStartAndPrefix();
30335       case COLUMNS:
30336         return isSetColumns();
30337       }
30338       throw new IllegalStateException();
30339     }
30340 
30341     public boolean isSet(int fieldID) {
30342       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30343     }
30344 
30345     @Override
30346     public boolean equals(Object that) {
30347       if (that == null)
30348         return false;
30349       if (that instanceof scannerOpenWithPrefix_args)
30350         return this.equals((scannerOpenWithPrefix_args)that);
30351       return false;
30352     }
30353 
30354     public boolean equals(scannerOpenWithPrefix_args that) {
30355       if (that == null)
30356         return false;
30357 
30358       boolean this_present_tableName = true && this.isSetTableName();
30359       boolean that_present_tableName = true && that.isSetTableName();
30360       if (this_present_tableName || that_present_tableName) {
30361         if (!(this_present_tableName && that_present_tableName))
30362           return false;
30363         if (!java.util.Arrays.equals(this.tableName, that.tableName))
30364           return false;
30365       }
30366 
30367       boolean this_present_startAndPrefix = true && this.isSetStartAndPrefix();
30368       boolean that_present_startAndPrefix = true && that.isSetStartAndPrefix();
30369       if (this_present_startAndPrefix || that_present_startAndPrefix) {
30370         if (!(this_present_startAndPrefix && that_present_startAndPrefix))
30371           return false;
30372         if (!java.util.Arrays.equals(this.startAndPrefix, that.startAndPrefix))
30373           return false;
30374       }
30375 
30376       boolean this_present_columns = true && this.isSetColumns();
30377       boolean that_present_columns = true && that.isSetColumns();
30378       if (this_present_columns || that_present_columns) {
30379         if (!(this_present_columns && that_present_columns))
30380           return false;
30381         if (!this.columns.equals(that.columns))
30382           return false;
30383       }
30384 
30385       return true;
30386     }
30387 
30388     @Override
30389     public int hashCode() {
30390       HashCodeBuilder builder = new HashCodeBuilder();
30391 
30392       boolean present_tableName = true && (isSetTableName());
30393       builder.append(present_tableName);
30394       if (present_tableName)
30395         builder.append(tableName);
30396 
30397       boolean present_startAndPrefix = true && (isSetStartAndPrefix());
30398       builder.append(present_startAndPrefix);
30399       if (present_startAndPrefix)
30400         builder.append(startAndPrefix);
30401 
30402       boolean present_columns = true && (isSetColumns());
30403       builder.append(present_columns);
30404       if (present_columns)
30405         builder.append(columns);
30406 
30407       return builder.toHashCode();
30408     }
30409 
30410     public int compareTo(scannerOpenWithPrefix_args other) {
30411       if (!getClass().equals(other.getClass())) {
30412         return getClass().getName().compareTo(other.getClass().getName());
30413       }
30414 
30415       int lastComparison = 0;
30416       scannerOpenWithPrefix_args typedOther = (scannerOpenWithPrefix_args)other;
30417 
30418       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
30419       if (lastComparison != 0) {
30420         return lastComparison;
30421       }
30422       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
30423       if (lastComparison != 0) {
30424         return lastComparison;
30425       }
30426       lastComparison = Boolean.valueOf(isSetStartAndPrefix()).compareTo(isSetStartAndPrefix());
30427       if (lastComparison != 0) {
30428         return lastComparison;
30429       }
30430       lastComparison = TBaseHelper.compareTo(startAndPrefix, typedOther.startAndPrefix);
30431       if (lastComparison != 0) {
30432         return lastComparison;
30433       }
30434       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
30435       if (lastComparison != 0) {
30436         return lastComparison;
30437       }
30438       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
30439       if (lastComparison != 0) {
30440         return lastComparison;
30441       }
30442       return 0;
30443     }
30444 
30445     public void read(TProtocol iprot) throws TException {
30446       TField field;
30447       iprot.readStructBegin();
30448       while (true)
30449       {
30450         field = iprot.readFieldBegin();
30451         if (field.type == TType.STOP) {
30452           break;
30453         }
30454         _Fields fieldId = _Fields.findByThriftId(field.id);
30455         if (fieldId == null) {
30456           TProtocolUtil.skip(iprot, field.type);
30457         } else {
30458           switch (fieldId) {
30459             case TABLE_NAME:
30460               if (field.type == TType.STRING) {
30461                 this.tableName = iprot.readBinary();
30462               } else {
30463                 TProtocolUtil.skip(iprot, field.type);
30464               }
30465               break;
30466             case START_AND_PREFIX:
30467               if (field.type == TType.STRING) {
30468                 this.startAndPrefix = iprot.readBinary();
30469               } else {
30470                 TProtocolUtil.skip(iprot, field.type);
30471               }
30472               break;
30473             case COLUMNS:
30474               if (field.type == TType.LIST) {
30475                 {
30476                   TList _list126 = iprot.readListBegin();
30477                   this.columns = new ArrayList<byte[]>(_list126.size);
30478                   for (int _i127 = 0; _i127 < _list126.size; ++_i127)
30479                   {
30480                     byte[] _elem128;
30481                     _elem128 = iprot.readBinary();
30482                     this.columns.add(_elem128);
30483                   }
30484                   iprot.readListEnd();
30485                 }
30486               } else {
30487                 TProtocolUtil.skip(iprot, field.type);
30488               }
30489               break;
30490           }
30491           iprot.readFieldEnd();
30492         }
30493       }
30494       iprot.readStructEnd();
30495 
30496       // check for required fields of primitive type, which can't be checked in the validate method
30497       validate();
30498     }
30499 
30500     public void write(TProtocol oprot) throws TException {
30501       validate();
30502 
30503       oprot.writeStructBegin(STRUCT_DESC);
30504       if (this.tableName != null) {
30505         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
30506         oprot.writeBinary(this.tableName);
30507         oprot.writeFieldEnd();
30508       }
30509       if (this.startAndPrefix != null) {
30510         oprot.writeFieldBegin(START_AND_PREFIX_FIELD_DESC);
30511         oprot.writeBinary(this.startAndPrefix);
30512         oprot.writeFieldEnd();
30513       }
30514       if (this.columns != null) {
30515         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
30516         {
30517           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
30518           for (byte[] _iter129 : this.columns)
30519           {
30520             oprot.writeBinary(_iter129);
30521           }
30522           oprot.writeListEnd();
30523         }
30524         oprot.writeFieldEnd();
30525       }
30526       oprot.writeFieldStop();
30527       oprot.writeStructEnd();
30528     }
30529 
30530     @Override
30531     public String toString() {
30532       StringBuilder sb = new StringBuilder("scannerOpenWithPrefix_args(");
30533       boolean first = true;
30534 
30535       sb.append("tableName:");
30536       if (this.tableName == null) {
30537         sb.append("null");
30538       } else {
30539         sb.append(this.tableName);
30540       }
30541       first = false;
30542       if (!first) sb.append(", ");
30543       sb.append("startAndPrefix:");
30544       if (this.startAndPrefix == null) {
30545         sb.append("null");
30546       } else {
30547         sb.append(this.startAndPrefix);
30548       }
30549       first = false;
30550       if (!first) sb.append(", ");
30551       sb.append("columns:");
30552       if (this.columns == null) {
30553         sb.append("null");
30554       } else {
30555         sb.append(this.columns);
30556       }
30557       first = false;
30558       sb.append(")");
30559       return sb.toString();
30560     }
30561 
30562     public void validate() throws TException {
30563       // check for required fields
30564     }
30565 
30566   }
30567 
30568   public static class scannerOpenWithPrefix_result implements TBase<scannerOpenWithPrefix_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_result>   {
30569     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_result");
30570 
30571     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
30572     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
30573 
30574     public int success;
30575     public IOError io;
30576 
30577     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
30578     public enum _Fields implements TFieldIdEnum {
30579       SUCCESS((short)0, "success"),
30580       IO((short)1, "io");
30581 
30582       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30583       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30584 
30585       static {
30586         for (_Fields field : EnumSet.allOf(_Fields.class)) {
30587           byId.put((int)field._thriftId, field);
30588           byName.put(field.getFieldName(), field);
30589         }
30590       }
30591 
30592       /**
30593        * Find the _Fields constant that matches fieldId, or null if its not found.
30594        */
30595       public static _Fields findByThriftId(int fieldId) {
30596         return byId.get(fieldId);
30597       }
30598 
30599       /**
30600        * Find the _Fields constant that matches fieldId, throwing an exception
30601        * if it is not found.
30602        */
30603       public static _Fields findByThriftIdOrThrow(int fieldId) {
30604         _Fields fields = findByThriftId(fieldId);
30605         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30606         return fields;
30607       }
30608 
30609       /**
30610        * Find the _Fields constant that matches name, or null if its not found.
30611        */
30612       public static _Fields findByName(String name) {
30613         return byName.get(name);
30614       }
30615 
30616       private final short _thriftId;
30617       private final String _fieldName;
30618 
30619       _Fields(short thriftId, String fieldName) {
30620         _thriftId = thriftId;
30621         _fieldName = fieldName;
30622       }
30623 
30624       public short getThriftFieldId() {
30625         return _thriftId;
30626       }
30627 
30628       public String getFieldName() {
30629         return _fieldName;
30630       }
30631     }
30632 
30633     // isset id assignments
30634     private static final int __SUCCESS_ISSET_ID = 0;
30635     private BitSet __isset_bit_vector = new BitSet(1);
30636 
30637     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30638       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
30639           new FieldValueMetaData(TType.I32)));
30640       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
30641           new FieldValueMetaData(TType.STRUCT)));
30642     }});
30643 
30644     static {
30645       FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_result.class, metaDataMap);
30646     }
30647 
30648     public scannerOpenWithPrefix_result() {
30649     }
30650 
30651     public scannerOpenWithPrefix_result(
30652       int success,
30653       IOError io)
30654     {
30655       this();
30656       this.success = success;
30657       setSuccessIsSet(true);
30658       this.io = io;
30659     }
30660 
30661     /**
30662      * Performs a deep copy on <i>other</i>.
30663      */
30664     public scannerOpenWithPrefix_result(scannerOpenWithPrefix_result other) {
30665       __isset_bit_vector.clear();
30666       __isset_bit_vector.or(other.__isset_bit_vector);
30667       this.success = other.success;
30668       if (other.isSetIo()) {
30669         this.io = new IOError(other.io);
30670       }
30671     }
30672 
30673     public scannerOpenWithPrefix_result deepCopy() {
30674       return new scannerOpenWithPrefix_result(this);
30675     }
30676 
30677     @Deprecated
30678     public scannerOpenWithPrefix_result clone() {
30679       return new scannerOpenWithPrefix_result(this);
30680     }
30681 
30682     public int getSuccess() {
30683       return this.success;
30684     }
30685 
30686     public scannerOpenWithPrefix_result setSuccess(int success) {
30687       this.success = success;
30688       setSuccessIsSet(true);
30689       return this;
30690     }
30691 
30692     public void unsetSuccess() {
30693       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
30694     }
30695 
30696     /** Returns true if field success is set (has been asigned a value) and false otherwise */
30697     public boolean isSetSuccess() {
30698       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
30699     }
30700 
30701     public void setSuccessIsSet(boolean value) {
30702       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
30703     }
30704 
30705     public IOError getIo() {
30706       return this.io;
30707     }
30708 
30709     public scannerOpenWithPrefix_result setIo(IOError io) {
30710       this.io = io;
30711       return this;
30712     }
30713 
30714     public void unsetIo() {
30715       this.io = null;
30716     }
30717 
30718     /** Returns true if field io is set (has been asigned a value) and false otherwise */
30719     public boolean isSetIo() {
30720       return this.io != null;
30721     }
30722 
30723     public void setIoIsSet(boolean value) {
30724       if (!value) {
30725         this.io = null;
30726       }
30727     }
30728 
30729     public void setFieldValue(_Fields field, Object value) {
30730       switch (field) {
30731       case SUCCESS:
30732         if (value == null) {
30733           unsetSuccess();
30734         } else {
30735           setSuccess((Integer)value);
30736         }
30737         break;
30738 
30739       case IO:
30740         if (value == null) {
30741           unsetIo();
30742         } else {
30743           setIo((IOError)value);
30744         }
30745         break;
30746 
30747       }
30748     }
30749 
30750     public void setFieldValue(int fieldID, Object value) {
30751       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
30752     }
30753 
30754     public Object getFieldValue(_Fields field) {
30755       switch (field) {
30756       case SUCCESS:
30757         return new Integer(getSuccess());
30758 
30759       case IO:
30760         return getIo();
30761 
30762       }
30763       throw new IllegalStateException();
30764     }
30765 
30766     public Object getFieldValue(int fieldId) {
30767       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
30768     }
30769 
30770     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
30771     public boolean isSet(_Fields field) {
30772       switch (field) {
30773       case SUCCESS:
30774         return isSetSuccess();
30775       case IO:
30776         return isSetIo();
30777       }
30778       throw new IllegalStateException();
30779     }
30780 
30781     public boolean isSet(int fieldID) {
30782       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30783     }
30784 
30785     @Override
30786     public boolean equals(Object that) {
30787       if (that == null)
30788         return false;
30789       if (that instanceof scannerOpenWithPrefix_result)
30790         return this.equals((scannerOpenWithPrefix_result)that);
30791       return false;
30792     }
30793 
30794     public boolean equals(scannerOpenWithPrefix_result that) {
30795       if (that == null)
30796         return false;
30797 
30798       boolean this_present_success = true;
30799       boolean that_present_success = true;
30800       if (this_present_success || that_present_success) {
30801         if (!(this_present_success && that_present_success))
30802           return false;
30803         if (this.success != that.success)
30804           return false;
30805       }
30806 
30807       boolean this_present_io = true && this.isSetIo();
30808       boolean that_present_io = true && that.isSetIo();
30809       if (this_present_io || that_present_io) {
30810         if (!(this_present_io && that_present_io))
30811           return false;
30812         if (!this.io.equals(that.io))
30813           return false;
30814       }
30815 
30816       return true;
30817     }
30818 
30819     @Override
30820     public int hashCode() {
30821       HashCodeBuilder builder = new HashCodeBuilder();
30822 
30823       boolean present_success = true;
30824       builder.append(present_success);
30825       if (present_success)
30826         builder.append(success);
30827 
30828       boolean present_io = true && (isSetIo());
30829       builder.append(present_io);
30830       if (present_io)
30831         builder.append(io);
30832 
30833       return builder.toHashCode();
30834     }
30835 
30836     public int compareTo(scannerOpenWithPrefix_result other) {
30837       if (!getClass().equals(other.getClass())) {
30838         return getClass().getName().compareTo(other.getClass().getName());
30839       }
30840 
30841       int lastComparison = 0;
30842       scannerOpenWithPrefix_result typedOther = (scannerOpenWithPrefix_result)other;
30843 
30844       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
30845       if (lastComparison != 0) {
30846         return lastComparison;
30847       }
30848       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
30849       if (lastComparison != 0) {
30850         return lastComparison;
30851       }
30852       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
30853       if (lastComparison != 0) {
30854         return lastComparison;
30855       }
30856       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
30857       if (lastComparison != 0) {
30858         return lastComparison;
30859       }
30860       return 0;
30861     }
30862 
30863     public void read(TProtocol iprot) throws TException {
30864       TField field;
30865       iprot.readStructBegin();
30866       while (true)
30867       {
30868         field = iprot.readFieldBegin();
30869         if (field.type == TType.STOP) {
30870           break;
30871         }
30872         _Fields fieldId = _Fields.findByThriftId(field.id);
30873         if (fieldId == null) {
30874           TProtocolUtil.skip(iprot, field.type);
30875         } else {
30876           switch (fieldId) {
30877             case SUCCESS:
30878               if (field.type == TType.I32) {
30879                 this.success = iprot.readI32();
30880                 setSuccessIsSet(true);
30881               } else {
30882                 TProtocolUtil.skip(iprot, field.type);
30883               }
30884               break;
30885             case IO:
30886               if (field.type == TType.STRUCT) {
30887                 this.io = new IOError();
30888                 this.io.read(iprot);
30889               } else {
30890                 TProtocolUtil.skip(iprot, field.type);
30891               }
30892               break;
30893           }
30894           iprot.readFieldEnd();
30895         }
30896       }
30897       iprot.readStructEnd();
30898 
30899       // check for required fields of primitive type, which can't be checked in the validate method
30900       validate();
30901     }
30902 
30903     public void write(TProtocol oprot) throws TException {
30904       oprot.writeStructBegin(STRUCT_DESC);
30905 
30906       if (this.isSetSuccess()) {
30907         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30908         oprot.writeI32(this.success);
30909         oprot.writeFieldEnd();
30910       } else if (this.isSetIo()) {
30911         oprot.writeFieldBegin(IO_FIELD_DESC);
30912         this.io.write(oprot);
30913         oprot.writeFieldEnd();
30914       }
30915       oprot.writeFieldStop();
30916       oprot.writeStructEnd();
30917     }
30918 
30919     @Override
30920     public String toString() {
30921       StringBuilder sb = new StringBuilder("scannerOpenWithPrefix_result(");
30922       boolean first = true;
30923 
30924       sb.append("success:");
30925       sb.append(this.success);
30926       first = false;
30927       if (!first) sb.append(", ");
30928       sb.append("io:");
30929       if (this.io == null) {
30930         sb.append("null");
30931       } else {
30932         sb.append(this.io);
30933       }
30934       first = false;
30935       sb.append(")");
30936       return sb.toString();
30937     }
30938 
30939     public void validate() throws TException {
30940       // check for required fields
30941     }
30942 
30943   }
30944 
30945   public static class scannerOpenTs_args implements TBase<scannerOpenTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_args>   {
30946     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_args");
30947 
30948     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
30949     private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
30950     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
30951     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
30952 
30953     /**
30954      * name of table
30955      */
30956     public byte[] tableName;
30957     /**
30958      * Starting row in table to scan.
30959      * Send "" (empty string) to start at the first row.
30960      */
30961     public byte[] startRow;
30962     /**
30963      * columns to scan. If column name is a column family, all
30964      * columns of the specified column family are returned. It's also possible
30965      * to pass a regex in the column qualifier.
30966      */
30967     public List<byte[]> columns;
30968     /**
30969      * timestamp
30970      */
30971     public long timestamp;
30972 
30973     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
30974     public enum _Fields implements TFieldIdEnum {
30975       /**
30976        * name of table
30977        */
30978       TABLE_NAME((short)1, "tableName"),
30979       /**
30980        * Starting row in table to scan.
30981        * Send "" (empty string) to start at the first row.
30982        */
30983       START_ROW((short)2, "startRow"),
30984       /**
30985        * columns to scan. If column name is a column family, all
30986        * columns of the specified column family are returned. It's also possible
30987        * to pass a regex in the column qualifier.
30988        */
30989       COLUMNS((short)3, "columns"),
30990       /**
30991        * timestamp
30992        */
30993       TIMESTAMP((short)4, "timestamp");
30994 
30995       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30996       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30997 
30998       static {
30999         for (_Fields field : EnumSet.allOf(_Fields.class)) {
31000           byId.put((int)field._thriftId, field);
31001           byName.put(field.getFieldName(), field);
31002         }
31003       }
31004 
31005       /**
31006        * Find the _Fields constant that matches fieldId, or null if its not found.
31007        */
31008       public static _Fields findByThriftId(int fieldId) {
31009         return byId.get(fieldId);
31010       }
31011 
31012       /**
31013        * Find the _Fields constant that matches fieldId, throwing an exception
31014        * if it is not found.
31015        */
31016       public static _Fields findByThriftIdOrThrow(int fieldId) {
31017         _Fields fields = findByThriftId(fieldId);
31018         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
31019         return fields;
31020       }
31021 
31022       /**
31023        * Find the _Fields constant that matches name, or null if its not found.
31024        */
31025       public static _Fields findByName(String name) {
31026         return byName.get(name);
31027       }
31028 
31029       private final short _thriftId;
31030       private final String _fieldName;
31031 
31032       _Fields(short thriftId, String fieldName) {
31033         _thriftId = thriftId;
31034         _fieldName = fieldName;
31035       }
31036 
31037       public short getThriftFieldId() {
31038         return _thriftId;
31039       }
31040 
31041       public String getFieldName() {
31042         return _fieldName;
31043       }
31044     }
31045 
31046     // isset id assignments
31047     private static final int __TIMESTAMP_ISSET_ID = 0;
31048     private BitSet __isset_bit_vector = new BitSet(1);
31049 
31050     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
31051       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
31052           new FieldValueMetaData(TType.STRING)));
31053       put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
31054           new FieldValueMetaData(TType.STRING)));
31055       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
31056           new ListMetaData(TType.LIST,
31057               new FieldValueMetaData(TType.STRING))));
31058       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
31059           new FieldValueMetaData(TType.I64)));
31060     }});
31061 
31062     static {
31063       FieldMetaData.addStructMetaDataMap(scannerOpenTs_args.class, metaDataMap);
31064     }
31065 
31066     public scannerOpenTs_args() {
31067     }
31068 
31069     public scannerOpenTs_args(
31070       byte[] tableName,
31071       byte[] startRow,
31072       List<byte[]> columns,
31073       long timestamp)
31074     {
31075       this();
31076       this.tableName = tableName;
31077       this.startRow = startRow;
31078       this.columns = columns;
31079       this.timestamp = timestamp;
31080       setTimestampIsSet(true);
31081     }
31082 
31083     /**
31084      * Performs a deep copy on <i>other</i>.
31085      */
31086     public scannerOpenTs_args(scannerOpenTs_args other) {
31087       __isset_bit_vector.clear();
31088       __isset_bit_vector.or(other.__isset_bit_vector);
31089       if (other.isSetTableName()) {
31090         this.tableName = other.tableName;
31091       }
31092       if (other.isSetStartRow()) {
31093         this.startRow = other.startRow;
31094       }
31095       if (other.isSetColumns()) {
31096         List<byte[]> __this__columns = new ArrayList<byte[]>();
31097         for (byte[] other_element : other.columns) {
31098           __this__columns.add(other_element);
31099         }
31100         this.columns = __this__columns;
31101       }
31102       this.timestamp = other.timestamp;
31103     }
31104 
31105     public scannerOpenTs_args deepCopy() {
31106       return new scannerOpenTs_args(this);
31107     }
31108 
31109     @Deprecated
31110     public scannerOpenTs_args clone() {
31111       return new scannerOpenTs_args(this);
31112     }
31113 
31114     /**
31115      * name of table
31116      */
31117     public byte[] getTableName() {
31118       return this.tableName;
31119     }
31120 
31121     /**
31122      * name of table
31123      */
31124     public scannerOpenTs_args setTableName(byte[] tableName) {
31125       this.tableName = tableName;
31126       return this;
31127     }
31128 
31129     public void unsetTableName() {
31130       this.tableName = null;
31131     }
31132 
31133     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
31134     public boolean isSetTableName() {
31135       return this.tableName != null;
31136     }
31137 
31138     public void setTableNameIsSet(boolean value) {
31139       if (!value) {
31140         this.tableName = null;
31141       }
31142     }
31143 
31144     /**
31145      * Starting row in table to scan.
31146      * Send "" (empty string) to start at the first row.
31147      */
31148     public byte[] getStartRow() {
31149       return this.startRow;
31150     }
31151 
31152     /**
31153      * Starting row in table to scan.
31154      * Send "" (empty string) to start at the first row.
31155      */
31156     public scannerOpenTs_args setStartRow(byte[] startRow) {
31157       this.startRow = startRow;
31158       return this;
31159     }
31160 
31161     public void unsetStartRow() {
31162       this.startRow = null;
31163     }
31164 
31165     /** Returns true if field startRow is set (has been asigned a value) and false otherwise */
31166     public boolean isSetStartRow() {
31167       return this.startRow != null;
31168     }
31169 
31170     public void setStartRowIsSet(boolean value) {
31171       if (!value) {
31172         this.startRow = null;
31173       }
31174     }
31175 
31176     public int getColumnsSize() {
31177       return (this.columns == null) ? 0 : this.columns.size();
31178     }
31179 
31180     public java.util.Iterator<byte[]> getColumnsIterator() {
31181       return (this.columns == null) ? null : this.columns.iterator();
31182     }
31183 
31184     public void addToColumns(byte[] elem) {
31185       if (this.columns == null) {
31186         this.columns = new ArrayList<byte[]>();
31187       }
31188       this.columns.add(elem);
31189     }
31190 
31191     /**
31192      * columns to scan. If column name is a column family, all
31193      * columns of the specified column family are returned. It's also possible
31194      * to pass a regex in the column qualifier.
31195      */
31196     public List<byte[]> getColumns() {
31197       return this.columns;
31198     }
31199 
31200     /**
31201      * columns to scan. If column name is a column family, all
31202      * columns of the specified column family are returned. It's also possible
31203      * to pass a regex in the column qualifier.
31204      */
31205     public scannerOpenTs_args setColumns(List<byte[]> columns) {
31206       this.columns = columns;
31207       return this;
31208     }
31209 
31210     public void unsetColumns() {
31211       this.columns = null;
31212     }
31213 
31214     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
31215     public boolean isSetColumns() {
31216       return this.columns != null;
31217     }
31218 
31219     public void setColumnsIsSet(boolean value) {
31220       if (!value) {
31221         this.columns = null;
31222       }
31223     }
31224 
31225     /**
31226      * timestamp
31227      */
31228     public long getTimestamp() {
31229       return this.timestamp;
31230     }
31231 
31232     /**
31233      * timestamp
31234      */
31235     public scannerOpenTs_args setTimestamp(long timestamp) {
31236       this.timestamp = timestamp;
31237       setTimestampIsSet(true);
31238       return this;
31239     }
31240 
31241     public void unsetTimestamp() {
31242       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
31243     }
31244 
31245     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
31246     public boolean isSetTimestamp() {
31247       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
31248     }
31249 
31250     public void setTimestampIsSet(boolean value) {
31251       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
31252     }
31253 
31254     public void setFieldValue(_Fields field, Object value) {
31255       switch (field) {
31256       case TABLE_NAME:
31257         if (value == null) {
31258           unsetTableName();
31259         } else {
31260           setTableName((byte[])value);
31261         }
31262         break;
31263 
31264       case START_ROW:
31265         if (value == null) {
31266           unsetStartRow();
31267         } else {
31268           setStartRow((byte[])value);
31269         }
31270         break;
31271 
31272       case COLUMNS:
31273         if (value == null) {
31274           unsetColumns();
31275         } else {
31276           setColumns((List<byte[]>)value);
31277         }
31278         break;
31279 
31280       case TIMESTAMP:
31281         if (value == null) {
31282           unsetTimestamp();
31283         } else {
31284           setTimestamp((Long)value);
31285         }
31286         break;
31287 
31288       }
31289     }
31290 
31291     public void setFieldValue(int fieldID, Object value) {
31292       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
31293     }
31294 
31295     public Object getFieldValue(_Fields field) {
31296       switch (field) {
31297       case TABLE_NAME:
31298         return getTableName();
31299 
31300       case START_ROW:
31301         return getStartRow();
31302 
31303       case COLUMNS:
31304         return getColumns();
31305 
31306       case TIMESTAMP:
31307         return new Long(getTimestamp());
31308 
31309       }
31310       throw new IllegalStateException();
31311     }
31312 
31313     public Object getFieldValue(int fieldId) {
31314       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
31315     }
31316 
31317     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
31318     public boolean isSet(_Fields field) {
31319       switch (field) {
31320       case TABLE_NAME:
31321         return isSetTableName();
31322       case START_ROW:
31323         return isSetStartRow();
31324       case COLUMNS:
31325         return isSetColumns();
31326       case TIMESTAMP:
31327         return isSetTimestamp();
31328       }
31329       throw new IllegalStateException();
31330     }
31331 
31332     public boolean isSet(int fieldID) {
31333       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
31334     }
31335 
31336     @Override
31337     public boolean equals(Object that) {
31338       if (that == null)
31339         return false;
31340       if (that instanceof scannerOpenTs_args)
31341         return this.equals((scannerOpenTs_args)that);
31342       return false;
31343     }
31344 
31345     public boolean equals(scannerOpenTs_args that) {
31346       if (that == null)
31347         return false;
31348 
31349       boolean this_present_tableName = true && this.isSetTableName();
31350       boolean that_present_tableName = true && that.isSetTableName();
31351       if (this_present_tableName || that_present_tableName) {
31352         if (!(this_present_tableName && that_present_tableName))
31353           return false;
31354         if (!java.util.Arrays.equals(this.tableName, that.tableName))
31355           return false;
31356       }
31357 
31358       boolean this_present_startRow = true && this.isSetStartRow();
31359       boolean that_present_startRow = true && that.isSetStartRow();
31360       if (this_present_startRow || that_present_startRow) {
31361         if (!(this_present_startRow && that_present_startRow))
31362           return false;
31363         if (!java.util.Arrays.equals(this.startRow, that.startRow))
31364           return false;
31365       }
31366 
31367       boolean this_present_columns = true && this.isSetColumns();
31368       boolean that_present_columns = true && that.isSetColumns();
31369       if (this_present_columns || that_present_columns) {
31370         if (!(this_present_columns && that_present_columns))
31371           return false;
31372         if (!this.columns.equals(that.columns))
31373           return false;
31374       }
31375 
31376       boolean this_present_timestamp = true;
31377       boolean that_present_timestamp = true;
31378       if (this_present_timestamp || that_present_timestamp) {
31379         if (!(this_present_timestamp && that_present_timestamp))
31380           return false;
31381         if (this.timestamp != that.timestamp)
31382           return false;
31383       }
31384 
31385       return true;
31386     }
31387 
31388     @Override
31389     public int hashCode() {
31390       HashCodeBuilder builder = new HashCodeBuilder();
31391 
31392       boolean present_tableName = true && (isSetTableName());
31393       builder.append(present_tableName);
31394       if (present_tableName)
31395         builder.append(tableName);
31396 
31397       boolean present_startRow = true && (isSetStartRow());
31398       builder.append(present_startRow);
31399       if (present_startRow)
31400         builder.append(startRow);
31401 
31402       boolean present_columns = true && (isSetColumns());
31403       builder.append(present_columns);
31404       if (present_columns)
31405         builder.append(columns);
31406 
31407       boolean present_timestamp = true;
31408       builder.append(present_timestamp);
31409       if (present_timestamp)
31410         builder.append(timestamp);
31411 
31412       return builder.toHashCode();
31413     }
31414 
31415     public int compareTo(scannerOpenTs_args other) {
31416       if (!getClass().equals(other.getClass())) {
31417         return getClass().getName().compareTo(other.getClass().getName());
31418       }
31419 
31420       int lastComparison = 0;
31421       scannerOpenTs_args typedOther = (scannerOpenTs_args)other;
31422 
31423       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
31424       if (lastComparison != 0) {
31425         return lastComparison;
31426       }
31427       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
31428       if (lastComparison != 0) {
31429         return lastComparison;
31430       }
31431       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
31432       if (lastComparison != 0) {
31433         return lastComparison;
31434       }
31435       lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
31436       if (lastComparison != 0) {
31437         return lastComparison;
31438       }
31439       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
31440       if (lastComparison != 0) {
31441         return lastComparison;
31442       }
31443       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
31444       if (lastComparison != 0) {
31445         return lastComparison;
31446       }
31447       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
31448       if (lastComparison != 0) {
31449         return lastComparison;
31450       }
31451       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
31452       if (lastComparison != 0) {
31453         return lastComparison;
31454       }
31455       return 0;
31456     }
31457 
31458     public void read(TProtocol iprot) throws TException {
31459       TField field;
31460       iprot.readStructBegin();
31461       while (true)
31462       {
31463         field = iprot.readFieldBegin();
31464         if (field.type == TType.STOP) {
31465           break;
31466         }
31467         _Fields fieldId = _Fields.findByThriftId(field.id);
31468         if (fieldId == null) {
31469           TProtocolUtil.skip(iprot, field.type);
31470         } else {
31471           switch (fieldId) {
31472             case TABLE_NAME:
31473               if (field.type == TType.STRING) {
31474                 this.tableName = iprot.readBinary();
31475               } else {
31476                 TProtocolUtil.skip(iprot, field.type);
31477               }
31478               break;
31479             case START_ROW:
31480               if (field.type == TType.STRING) {
31481                 this.startRow = iprot.readBinary();
31482               } else {
31483                 TProtocolUtil.skip(iprot, field.type);
31484               }
31485               break;
31486             case COLUMNS:
31487               if (field.type == TType.LIST) {
31488                 {
31489                   TList _list130 = iprot.readListBegin();
31490                   this.columns = new ArrayList<byte[]>(_list130.size);
31491                   for (int _i131 = 0; _i131 < _list130.size; ++_i131)
31492                   {
31493                     byte[] _elem132;
31494                     _elem132 = iprot.readBinary();
31495                     this.columns.add(_elem132);
31496                   }
31497                   iprot.readListEnd();
31498                 }
31499               } else {
31500                 TProtocolUtil.skip(iprot, field.type);
31501               }
31502               break;
31503             case TIMESTAMP:
31504               if (field.type == TType.I64) {
31505                 this.timestamp = iprot.readI64();
31506                 setTimestampIsSet(true);
31507               } else {
31508                 TProtocolUtil.skip(iprot, field.type);
31509               }
31510               break;
31511           }
31512           iprot.readFieldEnd();
31513         }
31514       }
31515       iprot.readStructEnd();
31516 
31517       // check for required fields of primitive type, which can't be checked in the validate method
31518       validate();
31519     }
31520 
31521     public void write(TProtocol oprot) throws TException {
31522       validate();
31523 
31524       oprot.writeStructBegin(STRUCT_DESC);
31525       if (this.tableName != null) {
31526         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
31527         oprot.writeBinary(this.tableName);
31528         oprot.writeFieldEnd();
31529       }
31530       if (this.startRow != null) {
31531         oprot.writeFieldBegin(START_ROW_FIELD_DESC);
31532         oprot.writeBinary(this.startRow);
31533         oprot.writeFieldEnd();
31534       }
31535       if (this.columns != null) {
31536         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
31537         {
31538           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
31539           for (byte[] _iter133 : this.columns)
31540           {
31541             oprot.writeBinary(_iter133);
31542           }
31543           oprot.writeListEnd();
31544         }
31545         oprot.writeFieldEnd();
31546       }
31547       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
31548       oprot.writeI64(this.timestamp);
31549       oprot.writeFieldEnd();
31550       oprot.writeFieldStop();
31551       oprot.writeStructEnd();
31552     }
31553 
31554     @Override
31555     public String toString() {
31556       StringBuilder sb = new StringBuilder("scannerOpenTs_args(");
31557       boolean first = true;
31558 
31559       sb.append("tableName:");
31560       if (this.tableName == null) {
31561         sb.append("null");
31562       } else {
31563         sb.append(this.tableName);
31564       }
31565       first = false;
31566       if (!first) sb.append(", ");
31567       sb.append("startRow:");
31568       if (this.startRow == null) {
31569         sb.append("null");
31570       } else {
31571         sb.append(this.startRow);
31572       }
31573       first = false;
31574       if (!first) sb.append(", ");
31575       sb.append("columns:");
31576       if (this.columns == null) {
31577         sb.append("null");
31578       } else {
31579         sb.append(this.columns);
31580       }
31581       first = false;
31582       if (!first) sb.append(", ");
31583       sb.append("timestamp:");
31584       sb.append(this.timestamp);
31585       first = false;
31586       sb.append(")");
31587       return sb.toString();
31588     }
31589 
31590     public void validate() throws TException {
31591       // check for required fields
31592     }
31593 
31594   }
31595 
31596   public static class scannerOpenTs_result implements TBase<scannerOpenTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_result>   {
31597     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_result");
31598 
31599     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
31600     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
31601 
31602     public int success;
31603     public IOError io;
31604 
31605     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
31606     public enum _Fields implements TFieldIdEnum {
31607       SUCCESS((short)0, "success"),
31608       IO((short)1, "io");
31609 
31610       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
31611       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
31612 
31613       static {
31614         for (_Fields field : EnumSet.allOf(_Fields.class)) {
31615           byId.put((int)field._thriftId, field);
31616           byName.put(field.getFieldName(), field);
31617         }
31618       }
31619 
31620       /**
31621        * Find the _Fields constant that matches fieldId, or null if its not found.
31622        */
31623       public static _Fields findByThriftId(int fieldId) {
31624         return byId.get(fieldId);
31625       }
31626 
31627       /**
31628        * Find the _Fields constant that matches fieldId, throwing an exception
31629        * if it is not found.
31630        */
31631       public static _Fields findByThriftIdOrThrow(int fieldId) {
31632         _Fields fields = findByThriftId(fieldId);
31633         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
31634         return fields;
31635       }
31636 
31637       /**
31638        * Find the _Fields constant that matches name, or null if its not found.
31639        */
31640       public static _Fields findByName(String name) {
31641         return byName.get(name);
31642       }
31643 
31644       private final short _thriftId;
31645       private final String _fieldName;
31646 
31647       _Fields(short thriftId, String fieldName) {
31648         _thriftId = thriftId;
31649         _fieldName = fieldName;
31650       }
31651 
31652       public short getThriftFieldId() {
31653         return _thriftId;
31654       }
31655 
31656       public String getFieldName() {
31657         return _fieldName;
31658       }
31659     }
31660 
31661     // isset id assignments
31662     private static final int __SUCCESS_ISSET_ID = 0;
31663     private BitSet __isset_bit_vector = new BitSet(1);
31664 
31665     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
31666       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
31667           new FieldValueMetaData(TType.I32)));
31668       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
31669           new FieldValueMetaData(TType.STRUCT)));
31670     }});
31671 
31672     static {
31673       FieldMetaData.addStructMetaDataMap(scannerOpenTs_result.class, metaDataMap);
31674     }
31675 
31676     public scannerOpenTs_result() {
31677     }
31678 
31679     public scannerOpenTs_result(
31680       int success,
31681       IOError io)
31682     {
31683       this();
31684       this.success = success;
31685       setSuccessIsSet(true);
31686       this.io = io;
31687     }
31688 
31689     /**
31690      * Performs a deep copy on <i>other</i>.
31691      */
31692     public scannerOpenTs_result(scannerOpenTs_result other) {
31693       __isset_bit_vector.clear();
31694       __isset_bit_vector.or(other.__isset_bit_vector);
31695       this.success = other.success;
31696       if (other.isSetIo()) {
31697         this.io = new IOError(other.io);
31698       }
31699     }
31700 
31701     public scannerOpenTs_result deepCopy() {
31702       return new scannerOpenTs_result(this);
31703     }
31704 
31705     @Deprecated
31706     public scannerOpenTs_result clone() {
31707       return new scannerOpenTs_result(this);
31708     }
31709 
31710     public int getSuccess() {
31711       return this.success;
31712     }
31713 
31714     public scannerOpenTs_result setSuccess(int success) {
31715       this.success = success;
31716       setSuccessIsSet(true);
31717       return this;
31718     }
31719 
31720     public void unsetSuccess() {
31721       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
31722     }
31723 
31724     /** Returns true if field success is set (has been asigned a value) and false otherwise */
31725     public boolean isSetSuccess() {
31726       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
31727     }
31728 
31729     public void setSuccessIsSet(boolean value) {
31730       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
31731     }
31732 
31733     public IOError getIo() {
31734       return this.io;
31735     }
31736 
31737     public scannerOpenTs_result setIo(IOError io) {
31738       this.io = io;
31739       return this;
31740     }
31741 
31742     public void unsetIo() {
31743       this.io = null;
31744     }
31745 
31746     /** Returns true if field io is set (has been asigned a value) and false otherwise */
31747     public boolean isSetIo() {
31748       return this.io != null;
31749     }
31750 
31751     public void setIoIsSet(boolean value) {
31752       if (!value) {
31753         this.io = null;
31754       }
31755     }
31756 
31757     public void setFieldValue(_Fields field, Object value) {
31758       switch (field) {
31759       case SUCCESS:
31760         if (value == null) {
31761           unsetSuccess();
31762         } else {
31763           setSuccess((Integer)value);
31764         }
31765         break;
31766 
31767       case IO:
31768         if (value == null) {
31769           unsetIo();
31770         } else {
31771           setIo((IOError)value);
31772         }
31773         break;
31774 
31775       }
31776     }
31777 
31778     public void setFieldValue(int fieldID, Object value) {
31779       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
31780     }
31781 
31782     public Object getFieldValue(_Fields field) {
31783       switch (field) {
31784       case SUCCESS:
31785         return new Integer(getSuccess());
31786 
31787       case IO:
31788         return getIo();
31789 
31790       }
31791       throw new IllegalStateException();
31792     }
31793 
31794     public Object getFieldValue(int fieldId) {
31795       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
31796     }
31797 
31798     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
31799     public boolean isSet(_Fields field) {
31800       switch (field) {
31801       case SUCCESS:
31802         return isSetSuccess();
31803       case IO:
31804         return isSetIo();
31805       }
31806       throw new IllegalStateException();
31807     }
31808 
31809     public boolean isSet(int fieldID) {
31810       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
31811     }
31812 
31813     @Override
31814     public boolean equals(Object that) {
31815       if (that == null)
31816         return false;
31817       if (that instanceof scannerOpenTs_result)
31818         return this.equals((scannerOpenTs_result)that);
31819       return false;
31820     }
31821 
31822     public boolean equals(scannerOpenTs_result that) {
31823       if (that == null)
31824         return false;
31825 
31826       boolean this_present_success = true;
31827       boolean that_present_success = true;
31828       if (this_present_success || that_present_success) {
31829         if (!(this_present_success && that_present_success))
31830           return false;
31831         if (this.success != that.success)
31832           return false;
31833       }
31834 
31835       boolean this_present_io = true && this.isSetIo();
31836       boolean that_present_io = true && that.isSetIo();
31837       if (this_present_io || that_present_io) {
31838         if (!(this_present_io && that_present_io))
31839           return false;
31840         if (!this.io.equals(that.io))
31841           return false;
31842       }
31843 
31844       return true;
31845     }
31846 
31847     @Override
31848     public int hashCode() {
31849       HashCodeBuilder builder = new HashCodeBuilder();
31850 
31851       boolean present_success = true;
31852       builder.append(present_success);
31853       if (present_success)
31854         builder.append(success);
31855 
31856       boolean present_io = true && (isSetIo());
31857       builder.append(present_io);
31858       if (present_io)
31859         builder.append(io);
31860 
31861       return builder.toHashCode();
31862     }
31863 
31864     public int compareTo(scannerOpenTs_result other) {
31865       if (!getClass().equals(other.getClass())) {
31866         return getClass().getName().compareTo(other.getClass().getName());
31867       }
31868 
31869       int lastComparison = 0;
31870       scannerOpenTs_result typedOther = (scannerOpenTs_result)other;
31871 
31872       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
31873       if (lastComparison != 0) {
31874         return lastComparison;
31875       }
31876       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
31877       if (lastComparison != 0) {
31878         return lastComparison;
31879       }
31880       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
31881       if (lastComparison != 0) {
31882         return lastComparison;
31883       }
31884       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
31885       if (lastComparison != 0) {
31886         return lastComparison;
31887       }
31888       return 0;
31889     }
31890 
31891     public void read(TProtocol iprot) throws TException {
31892       TField field;
31893       iprot.readStructBegin();
31894       while (true)
31895       {
31896         field = iprot.readFieldBegin();
31897         if (field.type == TType.STOP) {
31898           break;
31899         }
31900         _Fields fieldId = _Fields.findByThriftId(field.id);
31901         if (fieldId == null) {
31902           TProtocolUtil.skip(iprot, field.type);
31903         } else {
31904           switch (fieldId) {
31905             case SUCCESS:
31906               if (field.type == TType.I32) {
31907                 this.success = iprot.readI32();
31908                 setSuccessIsSet(true);
31909               } else {
31910                 TProtocolUtil.skip(iprot, field.type);
31911               }
31912               break;
31913             case IO:
31914               if (field.type == TType.STRUCT) {
31915                 this.io = new IOError();
31916                 this.io.read(iprot);
31917               } else {
31918                 TProtocolUtil.skip(iprot, field.type);
31919               }
31920               break;
31921           }
31922           iprot.readFieldEnd();
31923         }
31924       }
31925       iprot.readStructEnd();
31926 
31927       // check for required fields of primitive type, which can't be checked in the validate method
31928       validate();
31929     }
31930 
31931     public void write(TProtocol oprot) throws TException {
31932       oprot.writeStructBegin(STRUCT_DESC);
31933 
31934       if (this.isSetSuccess()) {
31935         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
31936         oprot.writeI32(this.success);
31937         oprot.writeFieldEnd();
31938       } else if (this.isSetIo()) {
31939         oprot.writeFieldBegin(IO_FIELD_DESC);
31940         this.io.write(oprot);
31941         oprot.writeFieldEnd();
31942       }
31943       oprot.writeFieldStop();
31944       oprot.writeStructEnd();
31945     }
31946 
31947     @Override
31948     public String toString() {
31949       StringBuilder sb = new StringBuilder("scannerOpenTs_result(");
31950       boolean first = true;
31951 
31952       sb.append("success:");
31953       sb.append(this.success);
31954       first = false;
31955       if (!first) sb.append(", ");
31956       sb.append("io:");
31957       if (this.io == null) {
31958         sb.append("null");
31959       } else {
31960         sb.append(this.io);
31961       }
31962       first = false;
31963       sb.append(")");
31964       return sb.toString();
31965     }
31966 
31967     public void validate() throws TException {
31968       // check for required fields
31969     }
31970 
31971   }
31972 
31973   public static class scannerOpenWithStopTs_args implements TBase<scannerOpenWithStopTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_args>   {
31974     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_args");
31975 
31976     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
31977     private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
31978     private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3);
31979     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4);
31980     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)5);
31981 
31982     /**
31983      * name of table
31984      */
31985     public byte[] tableName;
31986     /**
31987      * Starting row in table to scan.
31988      * Send "" (empty string) to start at the first row.
31989      */
31990     public byte[] startRow;
31991     /**
31992      * row to stop scanning on. This row is *not* included in the
31993      * scanner's results
31994      */
31995     public byte[] stopRow;
31996     /**
31997      * columns to scan. If column name is a column family, all
31998      * columns of the specified column family are returned. It's also possible
31999      * to pass a regex in the column qualifier.
32000      */
32001     public List<byte[]> columns;
32002     /**
32003      * timestamp
32004      */
32005     public long timestamp;
32006 
32007     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
32008     public enum _Fields implements TFieldIdEnum {
32009       /**
32010        * name of table
32011        */
32012       TABLE_NAME((short)1, "tableName"),
32013       /**
32014        * Starting row in table to scan.
32015        * Send "" (empty string) to start at the first row.
32016        */
32017       START_ROW((short)2, "startRow"),
32018       /**
32019        * row to stop scanning on. This row is *not* included in the
32020        * scanner's results
32021        */
32022       STOP_ROW((short)3, "stopRow"),
32023       /**
32024        * columns to scan. If column name is a column family, all
32025        * columns of the specified column family are returned. It's also possible
32026        * to pass a regex in the column qualifier.
32027        */
32028       COLUMNS((short)4, "columns"),
32029       /**
32030        * timestamp
32031        */
32032       TIMESTAMP((short)5, "timestamp");
32033 
32034       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
32035       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
32036 
32037       static {
32038         for (_Fields field : EnumSet.allOf(_Fields.class)) {
32039           byId.put((int)field._thriftId, field);
32040           byName.put(field.getFieldName(), field);
32041         }
32042       }
32043 
32044       /**
32045        * Find the _Fields constant that matches fieldId, or null if its not found.
32046        */
32047       public static _Fields findByThriftId(int fieldId) {
32048         return byId.get(fieldId);
32049       }
32050 
32051       /**
32052        * Find the _Fields constant that matches fieldId, throwing an exception
32053        * if it is not found.
32054        */
32055       public static _Fields findByThriftIdOrThrow(int fieldId) {
32056         _Fields fields = findByThriftId(fieldId);
32057         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
32058         return fields;
32059       }
32060 
32061       /**
32062        * Find the _Fields constant that matches name, or null if its not found.
32063        */
32064       public static _Fields findByName(String name) {
32065         return byName.get(name);
32066       }
32067 
32068       private final short _thriftId;
32069       private final String _fieldName;
32070 
32071       _Fields(short thriftId, String fieldName) {
32072         _thriftId = thriftId;
32073         _fieldName = fieldName;
32074       }
32075 
32076       public short getThriftFieldId() {
32077         return _thriftId;
32078       }
32079 
32080       public String getFieldName() {
32081         return _fieldName;
32082       }
32083     }
32084 
32085     // isset id assignments
32086     private static final int __TIMESTAMP_ISSET_ID = 0;
32087     private BitSet __isset_bit_vector = new BitSet(1);
32088 
32089     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
32090       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
32091           new FieldValueMetaData(TType.STRING)));
32092       put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
32093           new FieldValueMetaData(TType.STRING)));
32094       put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT,
32095           new FieldValueMetaData(TType.STRING)));
32096       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
32097           new ListMetaData(TType.LIST,
32098               new FieldValueMetaData(TType.STRING))));
32099       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
32100           new FieldValueMetaData(TType.I64)));
32101     }});
32102 
32103     static {
32104       FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_args.class, metaDataMap);
32105     }
32106 
32107     public scannerOpenWithStopTs_args() {
32108     }
32109 
32110     public scannerOpenWithStopTs_args(
32111       byte[] tableName,
32112       byte[] startRow,
32113       byte[] stopRow,
32114       List<byte[]> columns,
32115       long timestamp)
32116     {
32117       this();
32118       this.tableName = tableName;
32119       this.startRow = startRow;
32120       this.stopRow = stopRow;
32121       this.columns = columns;
32122       this.timestamp = timestamp;
32123       setTimestampIsSet(true);
32124     }
32125 
32126     /**
32127      * Performs a deep copy on <i>other</i>.
32128      */
32129     public scannerOpenWithStopTs_args(scannerOpenWithStopTs_args other) {
32130       __isset_bit_vector.clear();
32131       __isset_bit_vector.or(other.__isset_bit_vector);
32132       if (other.isSetTableName()) {
32133         this.tableName = other.tableName;
32134       }
32135       if (other.isSetStartRow()) {
32136         this.startRow = other.startRow;
32137       }
32138       if (other.isSetStopRow()) {
32139         this.stopRow = other.stopRow;
32140       }
32141       if (other.isSetColumns()) {
32142         List<byte[]> __this__columns = new ArrayList<byte[]>();
32143         for (byte[] other_element : other.columns) {
32144           __this__columns.add(other_element);
32145         }
32146         this.columns = __this__columns;
32147       }
32148       this.timestamp = other.timestamp;
32149     }
32150 
32151     public scannerOpenWithStopTs_args deepCopy() {
32152       return new scannerOpenWithStopTs_args(this);
32153     }
32154 
32155     @Deprecated
32156     public scannerOpenWithStopTs_args clone() {
32157       return new scannerOpenWithStopTs_args(this);
32158     }
32159 
32160     /**
32161      * name of table
32162      */
32163     public byte[] getTableName() {
32164       return this.tableName;
32165     }
32166 
32167     /**
32168      * name of table
32169      */
32170     public scannerOpenWithStopTs_args setTableName(byte[] tableName) {
32171       this.tableName = tableName;
32172       return this;
32173     }
32174 
32175     public void unsetTableName() {
32176       this.tableName = null;
32177     }
32178 
32179     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
32180     public boolean isSetTableName() {
32181       return this.tableName != null;
32182     }
32183 
32184     public void setTableNameIsSet(boolean value) {
32185       if (!value) {
32186         this.tableName = null;
32187       }
32188     }
32189 
32190     /**
32191      * Starting row in table to scan.
32192      * Send "" (empty string) to start at the first row.
32193      */
32194     public byte[] getStartRow() {
32195       return this.startRow;
32196     }
32197 
32198     /**
32199      * Starting row in table to scan.
32200      * Send "" (empty string) to start at the first row.
32201      */
32202     public scannerOpenWithStopTs_args setStartRow(byte[] startRow) {
32203       this.startRow = startRow;
32204       return this;
32205     }
32206 
32207     public void unsetStartRow() {
32208       this.startRow = null;
32209     }
32210 
32211     /** Returns true if field startRow is set (has been asigned a value) and false otherwise */
32212     public boolean isSetStartRow() {
32213       return this.startRow != null;
32214     }
32215 
32216     public void setStartRowIsSet(boolean value) {
32217       if (!value) {
32218         this.startRow = null;
32219       }
32220     }
32221 
32222     /**
32223      * row to stop scanning on. This row is *not* included in the
32224      * scanner's results
32225      */
32226     public byte[] getStopRow() {
32227       return this.stopRow;
32228     }
32229 
32230     /**
32231      * row to stop scanning on. This row is *not* included in the
32232      * scanner's results
32233      */
32234     public scannerOpenWithStopTs_args setStopRow(byte[] stopRow) {
32235       this.stopRow = stopRow;
32236       return this;
32237     }
32238 
32239     public void unsetStopRow() {
32240       this.stopRow = null;
32241     }
32242 
32243     /** Returns true if field stopRow is set (has been asigned a value) and false otherwise */
32244     public boolean isSetStopRow() {
32245       return this.stopRow != null;
32246     }
32247 
32248     public void setStopRowIsSet(boolean value) {
32249       if (!value) {
32250         this.stopRow = null;
32251       }
32252     }
32253 
32254     public int getColumnsSize() {
32255       return (this.columns == null) ? 0 : this.columns.size();
32256     }
32257 
32258     public java.util.Iterator<byte[]> getColumnsIterator() {
32259       return (this.columns == null) ? null : this.columns.iterator();
32260     }
32261 
32262     public void addToColumns(byte[] elem) {
32263       if (this.columns == null) {
32264         this.columns = new ArrayList<byte[]>();
32265       }
32266       this.columns.add(elem);
32267     }
32268 
32269     /**
32270      * columns to scan. If column name is a column family, all
32271      * columns of the specified column family are returned. It's also possible
32272      * to pass a regex in the column qualifier.
32273      */
32274     public List<byte[]> getColumns() {
32275       return this.columns;
32276     }
32277 
32278     /**
32279      * columns to scan. If column name is a column family, all
32280      * columns of the specified column family are returned. It's also possible
32281      * to pass a regex in the column qualifier.
32282      */
32283     public scannerOpenWithStopTs_args setColumns(List<byte[]> columns) {
32284       this.columns = columns;
32285       return this;
32286     }
32287 
32288     public void unsetColumns() {
32289       this.columns = null;
32290     }
32291 
32292     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
32293     public boolean isSetColumns() {
32294       return this.columns != null;
32295     }
32296 
32297     public void setColumnsIsSet(boolean value) {
32298       if (!value) {
32299         this.columns = null;
32300       }
32301     }
32302 
32303     /**
32304      * timestamp
32305      */
32306     public long getTimestamp() {
32307       return this.timestamp;
32308     }
32309 
32310     /**
32311      * timestamp
32312      */
32313     public scannerOpenWithStopTs_args setTimestamp(long timestamp) {
32314       this.timestamp = timestamp;
32315       setTimestampIsSet(true);
32316       return this;
32317     }
32318 
32319     public void unsetTimestamp() {
32320       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
32321     }
32322 
32323     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
32324     public boolean isSetTimestamp() {
32325       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
32326     }
32327 
32328     public void setTimestampIsSet(boolean value) {
32329       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
32330     }
32331 
32332     public void setFieldValue(_Fields field, Object value) {
32333       switch (field) {
32334       case TABLE_NAME:
32335         if (value == null) {
32336           unsetTableName();
32337         } else {
32338           setTableName((byte[])value);
32339         }
32340         break;
32341 
32342       case START_ROW:
32343         if (value == null) {
32344           unsetStartRow();
32345         } else {
32346           setStartRow((byte[])value);
32347         }
32348         break;
32349 
32350       case STOP_ROW:
32351         if (value == null) {
32352           unsetStopRow();
32353         } else {
32354           setStopRow((byte[])value);
32355         }
32356         break;
32357 
32358       case COLUMNS:
32359         if (value == null) {
32360           unsetColumns();
32361         } else {
32362           setColumns((List<byte[]>)value);
32363         }
32364         break;
32365 
32366       case TIMESTAMP:
32367         if (value == null) {
32368           unsetTimestamp();
32369         } else {
32370           setTimestamp((Long)value);
32371         }
32372         break;
32373 
32374       }
32375     }
32376 
32377     public void setFieldValue(int fieldID, Object value) {
32378       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
32379     }
32380 
32381     public Object getFieldValue(_Fields field) {
32382       switch (field) {
32383       case TABLE_NAME:
32384         return getTableName();
32385 
32386       case START_ROW:
32387         return getStartRow();
32388 
32389       case STOP_ROW:
32390         return getStopRow();
32391 
32392       case COLUMNS:
32393         return getColumns();
32394 
32395       case TIMESTAMP:
32396         return new Long(getTimestamp());
32397 
32398       }
32399       throw new IllegalStateException();
32400     }
32401 
32402     public Object getFieldValue(int fieldId) {
32403       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
32404     }
32405 
32406     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
32407     public boolean isSet(_Fields field) {
32408       switch (field) {
32409       case TABLE_NAME:
32410         return isSetTableName();
32411       case START_ROW:
32412         return isSetStartRow();
32413       case STOP_ROW:
32414         return isSetStopRow();
32415       case COLUMNS:
32416         return isSetColumns();
32417       case TIMESTAMP:
32418         return isSetTimestamp();
32419       }
32420       throw new IllegalStateException();
32421     }
32422 
32423     public boolean isSet(int fieldID) {
32424       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
32425     }
32426 
32427     @Override
32428     public boolean equals(Object that) {
32429       if (that == null)
32430         return false;
32431       if (that instanceof scannerOpenWithStopTs_args)
32432         return this.equals((scannerOpenWithStopTs_args)that);
32433       return false;
32434     }
32435 
32436     public boolean equals(scannerOpenWithStopTs_args that) {
32437       if (that == null)
32438         return false;
32439 
32440       boolean this_present_tableName = true && this.isSetTableName();
32441       boolean that_present_tableName = true && that.isSetTableName();
32442       if (this_present_tableName || that_present_tableName) {
32443         if (!(this_present_tableName && that_present_tableName))
32444           return false;
32445         if (!java.util.Arrays.equals(this.tableName, that.tableName))
32446           return false;
32447       }
32448 
32449       boolean this_present_startRow = true && this.isSetStartRow();
32450       boolean that_present_startRow = true && that.isSetStartRow();
32451       if (this_present_startRow || that_present_startRow) {
32452         if (!(this_present_startRow && that_present_startRow))
32453           return false;
32454         if (!java.util.Arrays.equals(this.startRow, that.startRow))
32455           return false;
32456       }
32457 
32458       boolean this_present_stopRow = true && this.isSetStopRow();
32459       boolean that_present_stopRow = true && that.isSetStopRow();
32460       if (this_present_stopRow || that_present_stopRow) {
32461         if (!(this_present_stopRow && that_present_stopRow))
32462           return false;
32463         if (!java.util.Arrays.equals(this.stopRow, that.stopRow))
32464           return false;
32465       }
32466 
32467       boolean this_present_columns = true && this.isSetColumns();
32468       boolean that_present_columns = true && that.isSetColumns();
32469       if (this_present_columns || that_present_columns) {
32470         if (!(this_present_columns && that_present_columns))
32471           return false;
32472         if (!this.columns.equals(that.columns))
32473           return false;
32474       }
32475 
32476       boolean this_present_timestamp = true;
32477       boolean that_present_timestamp = true;
32478       if (this_present_timestamp || that_present_timestamp) {
32479         if (!(this_present_timestamp && that_present_timestamp))
32480           return false;
32481         if (this.timestamp != that.timestamp)
32482           return false;
32483       }
32484 
32485       return true;
32486     }
32487 
32488     @Override
32489     public int hashCode() {
32490       HashCodeBuilder builder = new HashCodeBuilder();
32491 
32492       boolean present_tableName = true && (isSetTableName());
32493       builder.append(present_tableName);
32494       if (present_tableName)
32495         builder.append(tableName);
32496 
32497       boolean present_startRow = true && (isSetStartRow());
32498       builder.append(present_startRow);
32499       if (present_startRow)
32500         builder.append(startRow);
32501 
32502       boolean present_stopRow = true && (isSetStopRow());
32503       builder.append(present_stopRow);
32504       if (present_stopRow)
32505         builder.append(stopRow);
32506 
32507       boolean present_columns = true && (isSetColumns());
32508       builder.append(present_columns);
32509       if (present_columns)
32510         builder.append(columns);
32511 
32512       boolean present_timestamp = true;
32513       builder.append(present_timestamp);
32514       if (present_timestamp)
32515         builder.append(timestamp);
32516 
32517       return builder.toHashCode();
32518     }
32519 
32520     public int compareTo(scannerOpenWithStopTs_args other) {
32521       if (!getClass().equals(other.getClass())) {
32522         return getClass().getName().compareTo(other.getClass().getName());
32523       }
32524 
32525       int lastComparison = 0;
32526       scannerOpenWithStopTs_args typedOther = (scannerOpenWithStopTs_args)other;
32527 
32528       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
32529       if (lastComparison != 0) {
32530         return lastComparison;
32531       }
32532       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
32533       if (lastComparison != 0) {
32534         return lastComparison;
32535       }
32536       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
32537       if (lastComparison != 0) {
32538         return lastComparison;
32539       }
32540       lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
32541       if (lastComparison != 0) {
32542         return lastComparison;
32543       }
32544       lastComparison = Boolean.valueOf(isSetStopRow()).compareTo(isSetStopRow());
32545       if (lastComparison != 0) {
32546         return lastComparison;
32547       }
32548       lastComparison = TBaseHelper.compareTo(stopRow, typedOther.stopRow);
32549       if (lastComparison != 0) {
32550         return lastComparison;
32551       }
32552       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
32553       if (lastComparison != 0) {
32554         return lastComparison;
32555       }
32556       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
32557       if (lastComparison != 0) {
32558         return lastComparison;
32559       }
32560       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
32561       if (lastComparison != 0) {
32562         return lastComparison;
32563       }
32564       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
32565       if (lastComparison != 0) {
32566         return lastComparison;
32567       }
32568       return 0;
32569     }
32570 
32571     public void read(TProtocol iprot) throws TException {
32572       TField field;
32573       iprot.readStructBegin();
32574       while (true)
32575       {
32576         field = iprot.readFieldBegin();
32577         if (field.type == TType.STOP) {
32578           break;
32579         }
32580         _Fields fieldId = _Fields.findByThriftId(field.id);
32581         if (fieldId == null) {
32582           TProtocolUtil.skip(iprot, field.type);
32583         } else {
32584           switch (fieldId) {
32585             case TABLE_NAME:
32586               if (field.type == TType.STRING) {
32587                 this.tableName = iprot.readBinary();
32588               } else {
32589                 TProtocolUtil.skip(iprot, field.type);
32590               }
32591               break;
32592             case START_ROW:
32593               if (field.type == TType.STRING) {
32594                 this.startRow = iprot.readBinary();
32595               } else {
32596                 TProtocolUtil.skip(iprot, field.type);
32597               }
32598               break;
32599             case STOP_ROW:
32600               if (field.type == TType.STRING) {
32601                 this.stopRow = iprot.readBinary();
32602               } else {
32603                 TProtocolUtil.skip(iprot, field.type);
32604               }
32605               break;
32606             case COLUMNS:
32607               if (field.type == TType.LIST) {
32608                 {
32609                   TList _list134 = iprot.readListBegin();
32610                   this.columns = new ArrayList<byte[]>(_list134.size);
32611                   for (int _i135 = 0; _i135 < _list134.size; ++_i135)
32612                   {
32613                     byte[] _elem136;
32614                     _elem136 = iprot.readBinary();
32615                     this.columns.add(_elem136);
32616                   }
32617                   iprot.readListEnd();
32618                 }
32619               } else {
32620                 TProtocolUtil.skip(iprot, field.type);
32621               }
32622               break;
32623             case TIMESTAMP:
32624               if (field.type == TType.I64) {
32625                 this.timestamp = iprot.readI64();
32626                 setTimestampIsSet(true);
32627               } else {
32628                 TProtocolUtil.skip(iprot, field.type);
32629               }
32630               break;
32631           }
32632           iprot.readFieldEnd();
32633         }
32634       }
32635       iprot.readStructEnd();
32636 
32637       // check for required fields of primitive type, which can't be checked in the validate method
32638       validate();
32639     }
32640 
32641     public void write(TProtocol oprot) throws TException {
32642       validate();
32643 
32644       oprot.writeStructBegin(STRUCT_DESC);
32645       if (this.tableName != null) {
32646         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
32647         oprot.writeBinary(this.tableName);
32648         oprot.writeFieldEnd();
32649       }
32650       if (this.startRow != null) {
32651         oprot.writeFieldBegin(START_ROW_FIELD_DESC);
32652         oprot.writeBinary(this.startRow);
32653         oprot.writeFieldEnd();
32654       }
32655       if (this.stopRow != null) {
32656         oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
32657         oprot.writeBinary(this.stopRow);
32658         oprot.writeFieldEnd();
32659       }
32660       if (this.columns != null) {
32661         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
32662         {
32663           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
32664           for (byte[] _iter137 : this.columns)
32665           {
32666             oprot.writeBinary(_iter137);
32667           }
32668           oprot.writeListEnd();
32669         }
32670         oprot.writeFieldEnd();
32671       }
32672       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
32673       oprot.writeI64(this.timestamp);
32674       oprot.writeFieldEnd();
32675       oprot.writeFieldStop();
32676       oprot.writeStructEnd();
32677     }
32678 
32679     @Override
32680     public String toString() {
32681       StringBuilder sb = new StringBuilder("scannerOpenWithStopTs_args(");
32682       boolean first = true;
32683 
32684       sb.append("tableName:");
32685       if (this.tableName == null) {
32686         sb.append("null");
32687       } else {
32688         sb.append(this.tableName);
32689       }
32690       first = false;
32691       if (!first) sb.append(", ");
32692       sb.append("startRow:");
32693       if (this.startRow == null) {
32694         sb.append("null");
32695       } else {
32696         sb.append(this.startRow);
32697       }
32698       first = false;
32699       if (!first) sb.append(", ");
32700       sb.append("stopRow:");
32701       if (this.stopRow == null) {
32702         sb.append("null");
32703       } else {
32704         sb.append(this.stopRow);
32705       }
32706       first = false;
32707       if (!first) sb.append(", ");
32708       sb.append("columns:");
32709       if (this.columns == null) {
32710         sb.append("null");
32711       } else {
32712         sb.append(this.columns);
32713       }
32714       first = false;
32715       if (!first) sb.append(", ");
32716       sb.append("timestamp:");
32717       sb.append(this.timestamp);
32718       first = false;
32719       sb.append(")");
32720       return sb.toString();
32721     }
32722 
32723     public void validate() throws TException {
32724       // check for required fields
32725     }
32726 
32727   }
32728 
32729   public static class scannerOpenWithStopTs_result implements TBase<scannerOpenWithStopTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_result>   {
32730     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_result");
32731 
32732     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
32733     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
32734 
32735     public int success;
32736     public IOError io;
32737 
32738     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
32739     public enum _Fields implements TFieldIdEnum {
32740       SUCCESS((short)0, "success"),
32741       IO((short)1, "io");
32742 
32743       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
32744       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
32745 
32746       static {
32747         for (_Fields field : EnumSet.allOf(_Fields.class)) {
32748           byId.put((int)field._thriftId, field);
32749           byName.put(field.getFieldName(), field);
32750         }
32751       }
32752 
32753       /**
32754        * Find the _Fields constant that matches fieldId, or null if its not found.
32755        */
32756       public static _Fields findByThriftId(int fieldId) {
32757         return byId.get(fieldId);
32758       }
32759 
32760       /**
32761        * Find the _Fields constant that matches fieldId, throwing an exception
32762        * if it is not found.
32763        */
32764       public static _Fields findByThriftIdOrThrow(int fieldId) {
32765         _Fields fields = findByThriftId(fieldId);
32766         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
32767         return fields;
32768       }
32769 
32770       /**
32771        * Find the _Fields constant that matches name, or null if its not found.
32772        */
32773       public static _Fields findByName(String name) {
32774         return byName.get(name);
32775       }
32776 
32777       private final short _thriftId;
32778       private final String _fieldName;
32779 
32780       _Fields(short thriftId, String fieldName) {
32781         _thriftId = thriftId;
32782         _fieldName = fieldName;
32783       }
32784 
32785       public short getThriftFieldId() {
32786         return _thriftId;
32787       }
32788 
32789       public String getFieldName() {
32790         return _fieldName;
32791       }
32792     }
32793 
32794     // isset id assignments
32795     private static final int __SUCCESS_ISSET_ID = 0;
32796     private BitSet __isset_bit_vector = new BitSet(1);
32797 
32798     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
32799       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
32800           new FieldValueMetaData(TType.I32)));
32801       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
32802           new FieldValueMetaData(TType.STRUCT)));
32803     }});
32804 
32805     static {
32806       FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_result.class, metaDataMap);
32807     }
32808 
32809     public scannerOpenWithStopTs_result() {
32810     }
32811 
32812     public scannerOpenWithStopTs_result(
32813       int success,
32814       IOError io)
32815     {
32816       this();
32817       this.success = success;
32818       setSuccessIsSet(true);
32819       this.io = io;
32820     }
32821 
32822     /**
32823      * Performs a deep copy on <i>other</i>.
32824      */
32825     public scannerOpenWithStopTs_result(scannerOpenWithStopTs_result other) {
32826       __isset_bit_vector.clear();
32827       __isset_bit_vector.or(other.__isset_bit_vector);
32828       this.success = other.success;
32829       if (other.isSetIo()) {
32830         this.io = new IOError(other.io);
32831       }
32832     }
32833 
32834     public scannerOpenWithStopTs_result deepCopy() {
32835       return new scannerOpenWithStopTs_result(this);
32836     }
32837 
32838     @Deprecated
32839     public scannerOpenWithStopTs_result clone() {
32840       return new scannerOpenWithStopTs_result(this);
32841     }
32842 
32843     public int getSuccess() {
32844       return this.success;
32845     }
32846 
32847     public scannerOpenWithStopTs_result setSuccess(int success) {
32848       this.success = success;
32849       setSuccessIsSet(true);
32850       return this;
32851     }
32852 
32853     public void unsetSuccess() {
32854       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
32855     }
32856 
32857     /** Returns true if field success is set (has been asigned a value) and false otherwise */
32858     public boolean isSetSuccess() {
32859       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
32860     }
32861 
32862     public void setSuccessIsSet(boolean value) {
32863       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
32864     }
32865 
32866     public IOError getIo() {
32867       return this.io;
32868     }
32869 
32870     public scannerOpenWithStopTs_result setIo(IOError io) {
32871       this.io = io;
32872       return this;
32873     }
32874 
32875     public void unsetIo() {
32876       this.io = null;
32877     }
32878 
32879     /** Returns true if field io is set (has been asigned a value) and false otherwise */
32880     public boolean isSetIo() {
32881       return this.io != null;
32882     }
32883 
32884     public void setIoIsSet(boolean value) {
32885       if (!value) {
32886         this.io = null;
32887       }
32888     }
32889 
32890     public void setFieldValue(_Fields field, Object value) {
32891       switch (field) {
32892       case SUCCESS:
32893         if (value == null) {
32894           unsetSuccess();
32895         } else {
32896           setSuccess((Integer)value);
32897         }
32898         break;
32899 
32900       case IO:
32901         if (value == null) {
32902           unsetIo();
32903         } else {
32904           setIo((IOError)value);
32905         }
32906         break;
32907 
32908       }
32909     }
32910 
32911     public void setFieldValue(int fieldID, Object value) {
32912       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
32913     }
32914 
32915     public Object getFieldValue(_Fields field) {
32916       switch (field) {
32917       case SUCCESS:
32918         return new Integer(getSuccess());
32919 
32920       case IO:
32921         return getIo();
32922 
32923       }
32924       throw new IllegalStateException();
32925     }
32926 
32927     public Object getFieldValue(int fieldId) {
32928       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
32929     }
32930 
32931     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
32932     public boolean isSet(_Fields field) {
32933       switch (field) {
32934       case SUCCESS:
32935         return isSetSuccess();
32936       case IO:
32937         return isSetIo();
32938       }
32939       throw new IllegalStateException();
32940     }
32941 
32942     public boolean isSet(int fieldID) {
32943       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
32944     }
32945 
32946     @Override
32947     public boolean equals(Object that) {
32948       if (that == null)
32949         return false;
32950       if (that instanceof scannerOpenWithStopTs_result)
32951         return this.equals((scannerOpenWithStopTs_result)that);
32952       return false;
32953     }
32954 
32955     public boolean equals(scannerOpenWithStopTs_result that) {
32956       if (that == null)
32957         return false;
32958 
32959       boolean this_present_success = true;
32960       boolean that_present_success = true;
32961       if (this_present_success || that_present_success) {
32962         if (!(this_present_success && that_present_success))
32963           return false;
32964         if (this.success != that.success)
32965           return false;
32966       }
32967 
32968       boolean this_present_io = true && this.isSetIo();
32969       boolean that_present_io = true && that.isSetIo();
32970       if (this_present_io || that_present_io) {
32971         if (!(this_present_io && that_present_io))
32972           return false;
32973         if (!this.io.equals(that.io))
32974           return false;
32975       }
32976 
32977       return true;
32978     }
32979 
32980     @Override
32981     public int hashCode() {
32982       HashCodeBuilder builder = new HashCodeBuilder();
32983 
32984       boolean present_success = true;
32985       builder.append(present_success);
32986       if (present_success)
32987         builder.append(success);
32988 
32989       boolean present_io = true && (isSetIo());
32990       builder.append(present_io);
32991       if (present_io)
32992         builder.append(io);
32993 
32994       return builder.toHashCode();
32995     }
32996 
32997     public int compareTo(scannerOpenWithStopTs_result other) {
32998       if (!getClass().equals(other.getClass())) {
32999         return getClass().getName().compareTo(other.getClass().getName());
33000       }
33001 
33002       int lastComparison = 0;
33003       scannerOpenWithStopTs_result typedOther = (scannerOpenWithStopTs_result)other;
33004 
33005       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
33006       if (lastComparison != 0) {
33007         return lastComparison;
33008       }
33009       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
33010       if (lastComparison != 0) {
33011         return lastComparison;
33012       }
33013       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
33014       if (lastComparison != 0) {
33015         return lastComparison;
33016       }
33017       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
33018       if (lastComparison != 0) {
33019         return lastComparison;
33020       }
33021       return 0;
33022     }
33023 
33024     public void read(TProtocol iprot) throws TException {
33025       TField field;
33026       iprot.readStructBegin();
33027       while (true)
33028       {
33029         field = iprot.readFieldBegin();
33030         if (field.type == TType.STOP) {
33031           break;
33032         }
33033         _Fields fieldId = _Fields.findByThriftId(field.id);
33034         if (fieldId == null) {
33035           TProtocolUtil.skip(iprot, field.type);
33036         } else {
33037           switch (fieldId) {
33038             case SUCCESS:
33039               if (field.type == TType.I32) {
33040                 this.success = iprot.readI32();
33041                 setSuccessIsSet(true);
33042               } else {
33043                 TProtocolUtil.skip(iprot, field.type);
33044               }
33045               break;
33046             case IO:
33047               if (field.type == TType.STRUCT) {
33048                 this.io = new IOError();
33049                 this.io.read(iprot);
33050               } else {
33051                 TProtocolUtil.skip(iprot, field.type);
33052               }
33053               break;
33054           }
33055           iprot.readFieldEnd();
33056         }
33057       }
33058       iprot.readStructEnd();
33059 
33060       // check for required fields of primitive type, which can't be checked in the validate method
33061       validate();
33062     }
33063 
33064     public void write(TProtocol oprot) throws TException {
33065       oprot.writeStructBegin(STRUCT_DESC);
33066 
33067       if (this.isSetSuccess()) {
33068         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33069         oprot.writeI32(this.success);
33070         oprot.writeFieldEnd();
33071       } else if (this.isSetIo()) {
33072         oprot.writeFieldBegin(IO_FIELD_DESC);
33073         this.io.write(oprot);
33074         oprot.writeFieldEnd();
33075       }
33076       oprot.writeFieldStop();
33077       oprot.writeStructEnd();
33078     }
33079 
33080     @Override
33081     public String toString() {
33082       StringBuilder sb = new StringBuilder("scannerOpenWithStopTs_result(");
33083       boolean first = true;
33084 
33085       sb.append("success:");
33086       sb.append(this.success);
33087       first = false;
33088       if (!first) sb.append(", ");
33089       sb.append("io:");
33090       if (this.io == null) {
33091         sb.append("null");
33092       } else {
33093         sb.append(this.io);
33094       }
33095       first = false;
33096       sb.append(")");
33097       return sb.toString();
33098     }
33099 
33100     public void validate() throws TException {
33101       // check for required fields
33102     }
33103 
33104   }
33105 
33106   public static class scannerGet_args implements TBase<scannerGet_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGet_args>   {
33107     private static final TStruct STRUCT_DESC = new TStruct("scannerGet_args");
33108 
33109     private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
33110 
33111     /**
33112      * id of a scanner returned by scannerOpen
33113      */
33114     public int id;
33115 
33116     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
33117     public enum _Fields implements TFieldIdEnum {
33118       /**
33119        * id of a scanner returned by scannerOpen
33120        */
33121       ID((short)1, "id");
33122 
33123       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
33124       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
33125 
33126       static {
33127         for (_Fields field : EnumSet.allOf(_Fields.class)) {
33128           byId.put((int)field._thriftId, field);
33129           byName.put(field.getFieldName(), field);
33130         }
33131       }
33132 
33133       /**
33134        * Find the _Fields constant that matches fieldId, or null if its not found.
33135        */
33136       public static _Fields findByThriftId(int fieldId) {
33137         return byId.get(fieldId);
33138       }
33139 
33140       /**
33141        * Find the _Fields constant that matches fieldId, throwing an exception
33142        * if it is not found.
33143        */
33144       public static _Fields findByThriftIdOrThrow(int fieldId) {
33145         _Fields fields = findByThriftId(fieldId);
33146         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
33147         return fields;
33148       }
33149 
33150       /**
33151        * Find the _Fields constant that matches name, or null if its not found.
33152        */
33153       public static _Fields findByName(String name) {
33154         return byName.get(name);
33155       }
33156 
33157       private final short _thriftId;
33158       private final String _fieldName;
33159 
33160       _Fields(short thriftId, String fieldName) {
33161         _thriftId = thriftId;
33162         _fieldName = fieldName;
33163       }
33164 
33165       public short getThriftFieldId() {
33166         return _thriftId;
33167       }
33168 
33169       public String getFieldName() {
33170         return _fieldName;
33171       }
33172     }
33173 
33174     // isset id assignments
33175     private static final int __ID_ISSET_ID = 0;
33176     private BitSet __isset_bit_vector = new BitSet(1);
33177 
33178     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
33179       put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
33180           new FieldValueMetaData(TType.I32)));
33181     }});
33182 
33183     static {
33184       FieldMetaData.addStructMetaDataMap(scannerGet_args.class, metaDataMap);
33185     }
33186 
33187     public scannerGet_args() {
33188     }
33189 
33190     public scannerGet_args(
33191       int id)
33192     {
33193       this();
33194       this.id = id;
33195       setIdIsSet(true);
33196     }
33197 
33198     /**
33199      * Performs a deep copy on <i>other</i>.
33200      */
33201     public scannerGet_args(scannerGet_args other) {
33202       __isset_bit_vector.clear();
33203       __isset_bit_vector.or(other.__isset_bit_vector);
33204       this.id = other.id;
33205     }
33206 
33207     public scannerGet_args deepCopy() {
33208       return new scannerGet_args(this);
33209     }
33210 
33211     @Deprecated
33212     public scannerGet_args clone() {
33213       return new scannerGet_args(this);
33214     }
33215 
33216     /**
33217      * id of a scanner returned by scannerOpen
33218      */
33219     public int getId() {
33220       return this.id;
33221     }
33222 
33223     /**
33224      * id of a scanner returned by scannerOpen
33225      */
33226     public scannerGet_args setId(int id) {
33227       this.id = id;
33228       setIdIsSet(true);
33229       return this;
33230     }
33231 
33232     public void unsetId() {
33233       __isset_bit_vector.clear(__ID_ISSET_ID);
33234     }
33235 
33236     /** Returns true if field id is set (has been asigned a value) and false otherwise */
33237     public boolean isSetId() {
33238       return __isset_bit_vector.get(__ID_ISSET_ID);
33239     }
33240 
33241     public void setIdIsSet(boolean value) {
33242       __isset_bit_vector.set(__ID_ISSET_ID, value);
33243     }
33244 
33245     public void setFieldValue(_Fields field, Object value) {
33246       switch (field) {
33247       case ID:
33248         if (value == null) {
33249           unsetId();
33250         } else {
33251           setId((Integer)value);
33252         }
33253         break;
33254 
33255       }
33256     }
33257 
33258     public void setFieldValue(int fieldID, Object value) {
33259       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
33260     }
33261 
33262     public Object getFieldValue(_Fields field) {
33263       switch (field) {
33264       case ID:
33265         return new Integer(getId());
33266 
33267       }
33268       throw new IllegalStateException();
33269     }
33270 
33271     public Object getFieldValue(int fieldId) {
33272       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
33273     }
33274 
33275     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
33276     public boolean isSet(_Fields field) {
33277       switch (field) {
33278       case ID:
33279         return isSetId();
33280       }
33281       throw new IllegalStateException();
33282     }
33283 
33284     public boolean isSet(int fieldID) {
33285       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
33286     }
33287 
33288     @Override
33289     public boolean equals(Object that) {
33290       if (that == null)
33291         return false;
33292       if (that instanceof scannerGet_args)
33293         return this.equals((scannerGet_args)that);
33294       return false;
33295     }
33296 
33297     public boolean equals(scannerGet_args that) {
33298       if (that == null)
33299         return false;
33300 
33301       boolean this_present_id = true;
33302       boolean that_present_id = true;
33303       if (this_present_id || that_present_id) {
33304         if (!(this_present_id && that_present_id))
33305           return false;
33306         if (this.id != that.id)
33307           return false;
33308       }
33309 
33310       return true;
33311     }
33312 
33313     @Override
33314     public int hashCode() {
33315       HashCodeBuilder builder = new HashCodeBuilder();
33316 
33317       boolean present_id = true;
33318       builder.append(present_id);
33319       if (present_id)
33320         builder.append(id);
33321 
33322       return builder.toHashCode();
33323     }
33324 
33325     public int compareTo(scannerGet_args other) {
33326       if (!getClass().equals(other.getClass())) {
33327         return getClass().getName().compareTo(other.getClass().getName());
33328       }
33329 
33330       int lastComparison = 0;
33331       scannerGet_args typedOther = (scannerGet_args)other;
33332 
33333       lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
33334       if (lastComparison != 0) {
33335         return lastComparison;
33336       }
33337       lastComparison = TBaseHelper.compareTo(id, typedOther.id);
33338       if (lastComparison != 0) {
33339         return lastComparison;
33340       }
33341       return 0;
33342     }
33343 
33344     public void read(TProtocol iprot) throws TException {
33345       TField field;
33346       iprot.readStructBegin();
33347       while (true)
33348       {
33349         field = iprot.readFieldBegin();
33350         if (field.type == TType.STOP) {
33351           break;
33352         }
33353         _Fields fieldId = _Fields.findByThriftId(field.id);
33354         if (fieldId == null) {
33355           TProtocolUtil.skip(iprot, field.type);
33356         } else {
33357           switch (fieldId) {
33358             case ID:
33359               if (field.type == TType.I32) {
33360                 this.id = iprot.readI32();
33361                 setIdIsSet(true);
33362               } else {
33363                 TProtocolUtil.skip(iprot, field.type);
33364               }
33365               break;
33366           }
33367           iprot.readFieldEnd();
33368         }
33369       }
33370       iprot.readStructEnd();
33371 
33372       // check for required fields of primitive type, which can't be checked in the validate method
33373       validate();
33374     }
33375 
33376     public void write(TProtocol oprot) throws TException {
33377       validate();
33378 
33379       oprot.writeStructBegin(STRUCT_DESC);
33380       oprot.writeFieldBegin(ID_FIELD_DESC);
33381       oprot.writeI32(this.id);
33382       oprot.writeFieldEnd();
33383       oprot.writeFieldStop();
33384       oprot.writeStructEnd();
33385     }
33386 
33387     @Override
33388     public String toString() {
33389       StringBuilder sb = new StringBuilder("scannerGet_args(");
33390       boolean first = true;
33391 
33392       sb.append("id:");
33393       sb.append(this.id);
33394       first = false;
33395       sb.append(")");
33396       return sb.toString();
33397     }
33398 
33399     public void validate() throws TException {
33400       // check for required fields
33401     }
33402 
33403   }
33404 
33405   public static class scannerGet_result implements TBase<scannerGet_result._Fields>, java.io.Serializable, Cloneable   {
33406     private static final TStruct STRUCT_DESC = new TStruct("scannerGet_result");
33407 
33408     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
33409     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
33410     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
33411 
33412     public List<TRowResult> success;
33413     public IOError io;
33414     public IllegalArgument ia;
33415 
33416     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
33417     public enum _Fields implements TFieldIdEnum {
33418       SUCCESS((short)0, "success"),
33419       IO((short)1, "io"),
33420       IA((short)2, "ia");
33421 
33422       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
33423       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
33424 
33425       static {
33426         for (_Fields field : EnumSet.allOf(_Fields.class)) {
33427           byId.put((int)field._thriftId, field);
33428           byName.put(field.getFieldName(), field);
33429         }
33430       }
33431 
33432       /**
33433        * Find the _Fields constant that matches fieldId, or null if its not found.
33434        */
33435       public static _Fields findByThriftId(int fieldId) {
33436         return byId.get(fieldId);
33437       }
33438 
33439       /**
33440        * Find the _Fields constant that matches fieldId, throwing an exception
33441        * if it is not found.
33442        */
33443       public static _Fields findByThriftIdOrThrow(int fieldId) {
33444         _Fields fields = findByThriftId(fieldId);
33445         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
33446         return fields;
33447       }
33448 
33449       /**
33450        * Find the _Fields constant that matches name, or null if its not found.
33451        */
33452       public static _Fields findByName(String name) {
33453         return byName.get(name);
33454       }
33455 
33456       private final short _thriftId;
33457       private final String _fieldName;
33458 
33459       _Fields(short thriftId, String fieldName) {
33460         _thriftId = thriftId;
33461         _fieldName = fieldName;
33462       }
33463 
33464       public short getThriftFieldId() {
33465         return _thriftId;
33466       }
33467 
33468       public String getFieldName() {
33469         return _fieldName;
33470       }
33471     }
33472 
33473     // isset id assignments
33474 
33475     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
33476       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
33477           new ListMetaData(TType.LIST,
33478               new StructMetaData(TType.STRUCT, TRowResult.class))));
33479       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
33480           new FieldValueMetaData(TType.STRUCT)));
33481       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
33482           new FieldValueMetaData(TType.STRUCT)));
33483     }});
33484 
33485     static {
33486       FieldMetaData.addStructMetaDataMap(scannerGet_result.class, metaDataMap);
33487     }
33488 
33489     public scannerGet_result() {
33490     }
33491 
33492     public scannerGet_result(
33493       List<TRowResult> success,
33494       IOError io,
33495       IllegalArgument ia)
33496     {
33497       this();
33498       this.success = success;
33499       this.io = io;
33500       this.ia = ia;
33501     }
33502 
33503     /**
33504      * Performs a deep copy on <i>other</i>.
33505      */
33506     public scannerGet_result(scannerGet_result other) {
33507       if (other.isSetSuccess()) {
33508         List<TRowResult> __this__success = new ArrayList<TRowResult>();
33509         for (TRowResult other_element : other.success) {
33510           __this__success.add(new TRowResult(other_element));
33511         }
33512         this.success = __this__success;
33513       }
33514       if (other.isSetIo()) {
33515         this.io = new IOError(other.io);
33516       }
33517       if (other.isSetIa()) {
33518         this.ia = new IllegalArgument(other.ia);
33519       }
33520     }
33521 
33522     public scannerGet_result deepCopy() {
33523       return new scannerGet_result(this);
33524     }
33525 
33526     @Deprecated
33527     public scannerGet_result clone() {
33528       return new scannerGet_result(this);
33529     }
33530 
33531     public int getSuccessSize() {
33532       return (this.success == null) ? 0 : this.success.size();
33533     }
33534 
33535     public java.util.Iterator<TRowResult> getSuccessIterator() {
33536       return (this.success == null) ? null : this.success.iterator();
33537     }
33538 
33539     public void addToSuccess(TRowResult elem) {
33540       if (this.success == null) {
33541         this.success = new ArrayList<TRowResult>();
33542       }
33543       this.success.add(elem);
33544     }
33545 
33546     public List<TRowResult> getSuccess() {
33547       return this.success;
33548     }
33549 
33550     public scannerGet_result setSuccess(List<TRowResult> success) {
33551       this.success = success;
33552       return this;
33553     }
33554 
33555     public void unsetSuccess() {
33556       this.success = null;
33557     }
33558 
33559     /** Returns true if field success is set (has been asigned a value) and false otherwise */
33560     public boolean isSetSuccess() {
33561       return this.success != null;
33562     }
33563 
33564     public void setSuccessIsSet(boolean value) {
33565       if (!value) {
33566         this.success = null;
33567       }
33568     }
33569 
33570     public IOError getIo() {
33571       return this.io;
33572     }
33573 
33574     public scannerGet_result setIo(IOError io) {
33575       this.io = io;
33576       return this;
33577     }
33578 
33579     public void unsetIo() {
33580       this.io = null;
33581     }
33582 
33583     /** Returns true if field io is set (has been asigned a value) and false otherwise */
33584     public boolean isSetIo() {
33585       return this.io != null;
33586     }
33587 
33588     public void setIoIsSet(boolean value) {
33589       if (!value) {
33590         this.io = null;
33591       }
33592     }
33593 
33594     public IllegalArgument getIa() {
33595       return this.ia;
33596     }
33597 
33598     public scannerGet_result setIa(IllegalArgument ia) {
33599       this.ia = ia;
33600       return this;
33601     }
33602 
33603     public void unsetIa() {
33604       this.ia = null;
33605     }
33606 
33607     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
33608     public boolean isSetIa() {
33609       return this.ia != null;
33610     }
33611 
33612     public void setIaIsSet(boolean value) {
33613       if (!value) {
33614         this.ia = null;
33615       }
33616     }
33617 
33618     public void setFieldValue(_Fields field, Object value) {
33619       switch (field) {
33620       case SUCCESS:
33621         if (value == null) {
33622           unsetSuccess();
33623         } else {
33624           setSuccess((List<TRowResult>)value);
33625         }
33626         break;
33627 
33628       case IO:
33629         if (value == null) {
33630           unsetIo();
33631         } else {
33632           setIo((IOError)value);
33633         }
33634         break;
33635 
33636       case IA:
33637         if (value == null) {
33638           unsetIa();
33639         } else {
33640           setIa((IllegalArgument)value);
33641         }
33642         break;
33643 
33644       }
33645     }
33646 
33647     public void setFieldValue(int fieldID, Object value) {
33648       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
33649     }
33650 
33651     public Object getFieldValue(_Fields field) {
33652       switch (field) {
33653       case SUCCESS:
33654         return getSuccess();
33655 
33656       case IO:
33657         return getIo();
33658 
33659       case IA:
33660         return getIa();
33661 
33662       }
33663       throw new IllegalStateException();
33664     }
33665 
33666     public Object getFieldValue(int fieldId) {
33667       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
33668     }
33669 
33670     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
33671     public boolean isSet(_Fields field) {
33672       switch (field) {
33673       case SUCCESS:
33674         return isSetSuccess();
33675       case IO:
33676         return isSetIo();
33677       case IA:
33678         return isSetIa();
33679       }
33680       throw new IllegalStateException();
33681     }
33682 
33683     public boolean isSet(int fieldID) {
33684       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
33685     }
33686 
33687     @Override
33688     public boolean equals(Object that) {
33689       if (that == null)
33690         return false;
33691       if (that instanceof scannerGet_result)
33692         return this.equals((scannerGet_result)that);
33693       return false;
33694     }
33695 
33696     public boolean equals(scannerGet_result that) {
33697       if (that == null)
33698         return false;
33699 
33700       boolean this_present_success = true && this.isSetSuccess();
33701       boolean that_present_success = true && that.isSetSuccess();
33702       if (this_present_success || that_present_success) {
33703         if (!(this_present_success && that_present_success))
33704           return false;
33705         if (!this.success.equals(that.success))
33706           return false;
33707       }
33708 
33709       boolean this_present_io = true && this.isSetIo();
33710       boolean that_present_io = true && that.isSetIo();
33711       if (this_present_io || that_present_io) {
33712         if (!(this_present_io && that_present_io))
33713           return false;
33714         if (!this.io.equals(that.io))
33715           return false;
33716       }
33717 
33718       boolean this_present_ia = true && this.isSetIa();
33719       boolean that_present_ia = true && that.isSetIa();
33720       if (this_present_ia || that_present_ia) {
33721         if (!(this_present_ia && that_present_ia))
33722           return false;
33723         if (!this.ia.equals(that.ia))
33724           return false;
33725       }
33726 
33727       return true;
33728     }
33729 
33730     @Override
33731     public int hashCode() {
33732       HashCodeBuilder builder = new HashCodeBuilder();
33733 
33734       boolean present_success = true && (isSetSuccess());
33735       builder.append(present_success);
33736       if (present_success)
33737         builder.append(success);
33738 
33739       boolean present_io = true && (isSetIo());
33740       builder.append(present_io);
33741       if (present_io)
33742         builder.append(io);
33743 
33744       boolean present_ia = true && (isSetIa());
33745       builder.append(present_ia);
33746       if (present_ia)
33747         builder.append(ia);
33748 
33749       return builder.toHashCode();
33750     }
33751 
33752     public void read(TProtocol iprot) throws TException {
33753       TField field;
33754       iprot.readStructBegin();
33755       while (true)
33756       {
33757         field = iprot.readFieldBegin();
33758         if (field.type == TType.STOP) {
33759           break;
33760         }
33761         _Fields fieldId = _Fields.findByThriftId(field.id);
33762         if (fieldId == null) {
33763           TProtocolUtil.skip(iprot, field.type);
33764         } else {
33765           switch (fieldId) {
33766             case SUCCESS:
33767               if (field.type == TType.LIST) {
33768                 {
33769                   TList _list138 = iprot.readListBegin();
33770                   this.success = new ArrayList<TRowResult>(_list138.size);
33771                   for (int _i139 = 0; _i139 < _list138.size; ++_i139)
33772                   {
33773                     TRowResult _elem140;
33774                     _elem140 = new TRowResult();
33775                     _elem140.read(iprot);
33776                     this.success.add(_elem140);
33777                   }
33778                   iprot.readListEnd();
33779                 }
33780               } else {
33781                 TProtocolUtil.skip(iprot, field.type);
33782               }
33783               break;
33784             case IO:
33785               if (field.type == TType.STRUCT) {
33786                 this.io = new IOError();
33787                 this.io.read(iprot);
33788               } else {
33789                 TProtocolUtil.skip(iprot, field.type);
33790               }
33791               break;
33792             case IA:
33793               if (field.type == TType.STRUCT) {
33794                 this.ia = new IllegalArgument();
33795                 this.ia.read(iprot);
33796               } else {
33797                 TProtocolUtil.skip(iprot, field.type);
33798               }
33799               break;
33800           }
33801           iprot.readFieldEnd();
33802         }
33803       }
33804       iprot.readStructEnd();
33805 
33806       // check for required fields of primitive type, which can't be checked in the validate method
33807       validate();
33808     }
33809 
33810     public void write(TProtocol oprot) throws TException {
33811       oprot.writeStructBegin(STRUCT_DESC);
33812 
33813       if (this.isSetSuccess()) {
33814         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33815         {
33816           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
33817           for (TRowResult _iter141 : this.success)
33818           {
33819             _iter141.write(oprot);
33820           }
33821           oprot.writeListEnd();
33822         }
33823         oprot.writeFieldEnd();
33824       } else if (this.isSetIo()) {
33825         oprot.writeFieldBegin(IO_FIELD_DESC);
33826         this.io.write(oprot);
33827         oprot.writeFieldEnd();
33828       } else if (this.isSetIa()) {
33829         oprot.writeFieldBegin(IA_FIELD_DESC);
33830         this.ia.write(oprot);
33831         oprot.writeFieldEnd();
33832       }
33833       oprot.writeFieldStop();
33834       oprot.writeStructEnd();
33835     }
33836 
33837     @Override
33838     public String toString() {
33839       StringBuilder sb = new StringBuilder("scannerGet_result(");
33840       boolean first = true;
33841 
33842       sb.append("success:");
33843       if (this.success == null) {
33844         sb.append("null");
33845       } else {
33846         sb.append(this.success);
33847       }
33848       first = false;
33849       if (!first) sb.append(", ");
33850       sb.append("io:");
33851       if (this.io == null) {
33852         sb.append("null");
33853       } else {
33854         sb.append(this.io);
33855       }
33856       first = false;
33857       if (!first) sb.append(", ");
33858       sb.append("ia:");
33859       if (this.ia == null) {
33860         sb.append("null");
33861       } else {
33862         sb.append(this.ia);
33863       }
33864       first = false;
33865       sb.append(")");
33866       return sb.toString();
33867     }
33868 
33869     public void validate() throws TException {
33870       // check for required fields
33871     }
33872 
33873   }
33874 
33875   public static class scannerGetList_args implements TBase<scannerGetList_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGetList_args>   {
33876     private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_args");
33877 
33878     private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
33879     private static final TField NB_ROWS_FIELD_DESC = new TField("nbRows", TType.I32, (short)2);
33880 
33881     /**
33882      * id of a scanner returned by scannerOpen
33883      */
33884     public int id;
33885     /**
33886      * number of results to return
33887      */
33888     public int nbRows;
33889 
33890     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
33891     public enum _Fields implements TFieldIdEnum {
33892       /**
33893        * id of a scanner returned by scannerOpen
33894        */
33895       ID((short)1, "id"),
33896       /**
33897        * number of results to return
33898        */
33899       NB_ROWS((short)2, "nbRows");
33900 
33901       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
33902       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
33903 
33904       static {
33905         for (_Fields field : EnumSet.allOf(_Fields.class)) {
33906           byId.put((int)field._thriftId, field);
33907           byName.put(field.getFieldName(), field);
33908         }
33909       }
33910 
33911       /**
33912        * Find the _Fields constant that matches fieldId, or null if its not found.
33913        */
33914       public static _Fields findByThriftId(int fieldId) {
33915         return byId.get(fieldId);
33916       }
33917 
33918       /**
33919        * Find the _Fields constant that matches fieldId, throwing an exception
33920        * if it is not found.
33921        */
33922       public static _Fields findByThriftIdOrThrow(int fieldId) {
33923         _Fields fields = findByThriftId(fieldId);
33924         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
33925         return fields;
33926       }
33927 
33928       /**
33929        * Find the _Fields constant that matches name, or null if its not found.
33930        */
33931       public static _Fields findByName(String name) {
33932         return byName.get(name);
33933       }
33934 
33935       private final short _thriftId;
33936       private final String _fieldName;
33937 
33938       _Fields(short thriftId, String fieldName) {
33939         _thriftId = thriftId;
33940         _fieldName = fieldName;
33941       }
33942 
33943       public short getThriftFieldId() {
33944         return _thriftId;
33945       }
33946 
33947       public String getFieldName() {
33948         return _fieldName;
33949       }
33950     }
33951 
33952     // isset id assignments
33953     private static final int __ID_ISSET_ID = 0;
33954     private static final int __NBROWS_ISSET_ID = 1;
33955     private BitSet __isset_bit_vector = new BitSet(2);
33956 
33957     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
33958       put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
33959           new FieldValueMetaData(TType.I32)));
33960       put(_Fields.NB_ROWS, new FieldMetaData("nbRows", TFieldRequirementType.DEFAULT,
33961           new FieldValueMetaData(TType.I32)));
33962     }});
33963 
33964     static {
33965       FieldMetaData.addStructMetaDataMap(scannerGetList_args.class, metaDataMap);
33966     }
33967 
33968     public scannerGetList_args() {
33969     }
33970 
33971     public scannerGetList_args(
33972       int id,
33973       int nbRows)
33974     {
33975       this();
33976       this.id = id;
33977       setIdIsSet(true);
33978       this.nbRows = nbRows;
33979       setNbRowsIsSet(true);
33980     }
33981 
33982     /**
33983      * Performs a deep copy on <i>other</i>.
33984      */
33985     public scannerGetList_args(scannerGetList_args other) {
33986       __isset_bit_vector.clear();
33987       __isset_bit_vector.or(other.__isset_bit_vector);
33988       this.id = other.id;
33989       this.nbRows = other.nbRows;
33990     }
33991 
33992     public scannerGetList_args deepCopy() {
33993       return new scannerGetList_args(this);
33994     }
33995 
33996     @Deprecated
33997     public scannerGetList_args clone() {
33998       return new scannerGetList_args(this);
33999     }
34000 
34001     /**
34002      * id of a scanner returned by scannerOpen
34003      */
34004     public int getId() {
34005       return this.id;
34006     }
34007 
34008     /**
34009      * id of a scanner returned by scannerOpen
34010      */
34011     public scannerGetList_args setId(int id) {
34012       this.id = id;
34013       setIdIsSet(true);
34014       return this;
34015     }
34016 
34017     public void unsetId() {
34018       __isset_bit_vector.clear(__ID_ISSET_ID);
34019     }
34020 
34021     /** Returns true if field id is set (has been asigned a value) and false otherwise */
34022     public boolean isSetId() {
34023       return __isset_bit_vector.get(__ID_ISSET_ID);
34024     }
34025 
34026     public void setIdIsSet(boolean value) {
34027       __isset_bit_vector.set(__ID_ISSET_ID, value);
34028     }
34029 
34030     /**
34031      * number of results to return
34032      */
34033     public int getNbRows() {
34034       return this.nbRows;
34035     }
34036 
34037     /**
34038      * number of results to return
34039      */
34040     public scannerGetList_args setNbRows(int nbRows) {
34041       this.nbRows = nbRows;
34042       setNbRowsIsSet(true);
34043       return this;
34044     }
34045 
34046     public void unsetNbRows() {
34047       __isset_bit_vector.clear(__NBROWS_ISSET_ID);
34048     }
34049 
34050     /** Returns true if field nbRows is set (has been asigned a value) and false otherwise */
34051     public boolean isSetNbRows() {
34052       return __isset_bit_vector.get(__NBROWS_ISSET_ID);
34053     }
34054 
34055     public void setNbRowsIsSet(boolean value) {
34056       __isset_bit_vector.set(__NBROWS_ISSET_ID, value);
34057     }
34058 
34059     public void setFieldValue(_Fields field, Object value) {
34060       switch (field) {
34061       case ID:
34062         if (value == null) {
34063           unsetId();
34064         } else {
34065           setId((Integer)value);
34066         }
34067         break;
34068 
34069       case NB_ROWS:
34070         if (value == null) {
34071           unsetNbRows();
34072         } else {
34073           setNbRows((Integer)value);
34074         }
34075         break;
34076 
34077       }
34078     }
34079 
34080     public void setFieldValue(int fieldID, Object value) {
34081       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
34082     }
34083 
34084     public Object getFieldValue(_Fields field) {
34085       switch (field) {
34086       case ID:
34087         return new Integer(getId());
34088 
34089       case NB_ROWS:
34090         return new Integer(getNbRows());
34091 
34092       }
34093       throw new IllegalStateException();
34094     }
34095 
34096     public Object getFieldValue(int fieldId) {
34097       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
34098     }
34099 
34100     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
34101     public boolean isSet(_Fields field) {
34102       switch (field) {
34103       case ID:
34104         return isSetId();
34105       case NB_ROWS:
34106         return isSetNbRows();
34107       }
34108       throw new IllegalStateException();
34109     }
34110 
34111     public boolean isSet(int fieldID) {
34112       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
34113     }
34114 
34115     @Override
34116     public boolean equals(Object that) {
34117       if (that == null)
34118         return false;
34119       if (that instanceof scannerGetList_args)
34120         return this.equals((scannerGetList_args)that);
34121       return false;
34122     }
34123 
34124     public boolean equals(scannerGetList_args that) {
34125       if (that == null)
34126         return false;
34127 
34128       boolean this_present_id = true;
34129       boolean that_present_id = true;
34130       if (this_present_id || that_present_id) {
34131         if (!(this_present_id && that_present_id))
34132           return false;
34133         if (this.id != that.id)
34134           return false;
34135       }
34136 
34137       boolean this_present_nbRows = true;
34138       boolean that_present_nbRows = true;
34139       if (this_present_nbRows || that_present_nbRows) {
34140         if (!(this_present_nbRows && that_present_nbRows))
34141           return false;
34142         if (this.nbRows != that.nbRows)
34143           return false;
34144       }
34145 
34146       return true;
34147     }
34148 
34149     @Override
34150     public int hashCode() {
34151       HashCodeBuilder builder = new HashCodeBuilder();
34152 
34153       boolean present_id = true;
34154       builder.append(present_id);
34155       if (present_id)
34156         builder.append(id);
34157 
34158       boolean present_nbRows = true;
34159       builder.append(present_nbRows);
34160       if (present_nbRows)
34161         builder.append(nbRows);
34162 
34163       return builder.toHashCode();
34164     }
34165 
34166     public int compareTo(scannerGetList_args other) {
34167       if (!getClass().equals(other.getClass())) {
34168         return getClass().getName().compareTo(other.getClass().getName());
34169       }
34170 
34171       int lastComparison = 0;
34172       scannerGetList_args typedOther = (scannerGetList_args)other;
34173 
34174       lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
34175       if (lastComparison != 0) {
34176         return lastComparison;
34177       }
34178       lastComparison = TBaseHelper.compareTo(id, typedOther.id);
34179       if (lastComparison != 0) {
34180         return lastComparison;
34181       }
34182       lastComparison = Boolean.valueOf(isSetNbRows()).compareTo(isSetNbRows());
34183       if (lastComparison != 0) {
34184         return lastComparison;
34185       }
34186       lastComparison = TBaseHelper.compareTo(nbRows, typedOther.nbRows);
34187       if (lastComparison != 0) {
34188         return lastComparison;
34189       }
34190       return 0;
34191     }
34192 
34193     public void read(TProtocol iprot) throws TException {
34194       TField field;
34195       iprot.readStructBegin();
34196       while (true)
34197       {
34198         field = iprot.readFieldBegin();
34199         if (field.type == TType.STOP) {
34200           break;
34201         }
34202         _Fields fieldId = _Fields.findByThriftId(field.id);
34203         if (fieldId == null) {
34204           TProtocolUtil.skip(iprot, field.type);
34205         } else {
34206           switch (fieldId) {
34207             case ID:
34208               if (field.type == TType.I32) {
34209                 this.id = iprot.readI32();
34210                 setIdIsSet(true);
34211               } else {
34212                 TProtocolUtil.skip(iprot, field.type);
34213               }
34214               break;
34215             case NB_ROWS:
34216               if (field.type == TType.I32) {
34217                 this.nbRows = iprot.readI32();
34218                 setNbRowsIsSet(true);
34219               } else {
34220                 TProtocolUtil.skip(iprot, field.type);
34221               }
34222               break;
34223           }
34224           iprot.readFieldEnd();
34225         }
34226       }
34227       iprot.readStructEnd();
34228 
34229       // check for required fields of primitive type, which can't be checked in the validate method
34230       validate();
34231     }
34232 
34233     public void write(TProtocol oprot) throws TException {
34234       validate();
34235 
34236       oprot.writeStructBegin(STRUCT_DESC);
34237       oprot.writeFieldBegin(ID_FIELD_DESC);
34238       oprot.writeI32(this.id);
34239       oprot.writeFieldEnd();
34240       oprot.writeFieldBegin(NB_ROWS_FIELD_DESC);
34241       oprot.writeI32(this.nbRows);
34242       oprot.writeFieldEnd();
34243       oprot.writeFieldStop();
34244       oprot.writeStructEnd();
34245     }
34246 
34247     @Override
34248     public String toString() {
34249       StringBuilder sb = new StringBuilder("scannerGetList_args(");
34250       boolean first = true;
34251 
34252       sb.append("id:");
34253       sb.append(this.id);
34254       first = false;
34255       if (!first) sb.append(", ");
34256       sb.append("nbRows:");
34257       sb.append(this.nbRows);
34258       first = false;
34259       sb.append(")");
34260       return sb.toString();
34261     }
34262 
34263     public void validate() throws TException {
34264       // check for required fields
34265     }
34266 
34267   }
34268 
34269   public static class scannerGetList_result implements TBase<scannerGetList_result._Fields>, java.io.Serializable, Cloneable   {
34270     private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_result");
34271 
34272     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
34273     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
34274     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
34275 
34276     public List<TRowResult> success;
34277     public IOError io;
34278     public IllegalArgument ia;
34279 
34280     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
34281     public enum _Fields implements TFieldIdEnum {
34282       SUCCESS((short)0, "success"),
34283       IO((short)1, "io"),
34284       IA((short)2, "ia");
34285 
34286       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
34287       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
34288 
34289       static {
34290         for (_Fields field : EnumSet.allOf(_Fields.class)) {
34291           byId.put((int)field._thriftId, field);
34292           byName.put(field.getFieldName(), field);
34293         }
34294       }
34295 
34296       /**
34297        * Find the _Fields constant that matches fieldId, or null if its not found.
34298        */
34299       public static _Fields findByThriftId(int fieldId) {
34300         return byId.get(fieldId);
34301       }
34302 
34303       /**
34304        * Find the _Fields constant that matches fieldId, throwing an exception
34305        * if it is not found.
34306        */
34307       public static _Fields findByThriftIdOrThrow(int fieldId) {
34308         _Fields fields = findByThriftId(fieldId);
34309         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
34310         return fields;
34311       }
34312 
34313       /**
34314        * Find the _Fields constant that matches name, or null if its not found.
34315        */
34316       public static _Fields findByName(String name) {
34317         return byName.get(name);
34318       }
34319 
34320       private final short _thriftId;
34321       private final String _fieldName;
34322 
34323       _Fields(short thriftId, String fieldName) {
34324         _thriftId = thriftId;
34325         _fieldName = fieldName;
34326       }
34327 
34328       public short getThriftFieldId() {
34329         return _thriftId;
34330       }
34331 
34332       public String getFieldName() {
34333         return _fieldName;
34334       }
34335     }
34336 
34337     // isset id assignments
34338 
34339     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
34340       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
34341           new ListMetaData(TType.LIST,
34342               new StructMetaData(TType.STRUCT, TRowResult.class))));
34343       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
34344           new FieldValueMetaData(TType.STRUCT)));
34345       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
34346           new FieldValueMetaData(TType.STRUCT)));
34347     }});
34348 
34349     static {
34350       FieldMetaData.addStructMetaDataMap(scannerGetList_result.class, metaDataMap);
34351     }
34352 
34353     public scannerGetList_result() {
34354     }
34355 
34356     public scannerGetList_result(
34357       List<TRowResult> success,
34358       IOError io,
34359       IllegalArgument ia)
34360     {
34361       this();
34362       this.success = success;
34363       this.io = io;
34364       this.ia = ia;
34365     }
34366 
34367     /**
34368      * Performs a deep copy on <i>other</i>.
34369      */
34370     public scannerGetList_result(scannerGetList_result other) {
34371       if (other.isSetSuccess()) {
34372         List<TRowResult> __this__success = new ArrayList<TRowResult>();
34373         for (TRowResult other_element : other.success) {
34374           __this__success.add(new TRowResult(other_element));
34375         }
34376         this.success = __this__success;
34377       }
34378       if (other.isSetIo()) {
34379         this.io = new IOError(other.io);
34380       }
34381       if (other.isSetIa()) {
34382         this.ia = new IllegalArgument(other.ia);
34383       }
34384     }
34385 
34386     public scannerGetList_result deepCopy() {
34387       return new scannerGetList_result(this);
34388     }
34389 
34390     @Deprecated
34391     public scannerGetList_result clone() {
34392       return new scannerGetList_result(this);
34393     }
34394 
34395     public int getSuccessSize() {
34396       return (this.success == null) ? 0 : this.success.size();
34397     }
34398 
34399     public java.util.Iterator<TRowResult> getSuccessIterator() {
34400       return (this.success == null) ? null : this.success.iterator();
34401     }
34402 
34403     public void addToSuccess(TRowResult elem) {
34404       if (this.success == null) {
34405         this.success = new ArrayList<TRowResult>();
34406       }
34407       this.success.add(elem);
34408     }
34409 
34410     public List<TRowResult> getSuccess() {
34411       return this.success;
34412     }
34413 
34414     public scannerGetList_result setSuccess(List<TRowResult> success) {
34415       this.success = success;
34416       return this;
34417     }
34418 
34419     public void unsetSuccess() {
34420       this.success = null;
34421     }
34422 
34423     /** Returns true if field success is set (has been asigned a value) and false otherwise */
34424     public boolean isSetSuccess() {
34425       return this.success != null;
34426     }
34427 
34428     public void setSuccessIsSet(boolean value) {
34429       if (!value) {
34430         this.success = null;
34431       }
34432     }
34433 
34434     public IOError getIo() {
34435       return this.io;
34436     }
34437 
34438     public scannerGetList_result setIo(IOError io) {
34439       this.io = io;
34440       return this;
34441     }
34442 
34443     public void unsetIo() {
34444       this.io = null;
34445     }
34446 
34447     /** Returns true if field io is set (has been asigned a value) and false otherwise */
34448     public boolean isSetIo() {
34449       return this.io != null;
34450     }
34451 
34452     public void setIoIsSet(boolean value) {
34453       if (!value) {
34454         this.io = null;
34455       }
34456     }
34457 
34458     public IllegalArgument getIa() {
34459       return this.ia;
34460     }
34461 
34462     public scannerGetList_result setIa(IllegalArgument ia) {
34463       this.ia = ia;
34464       return this;
34465     }
34466 
34467     public void unsetIa() {
34468       this.ia = null;
34469     }
34470 
34471     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
34472     public boolean isSetIa() {
34473       return this.ia != null;
34474     }
34475 
34476     public void setIaIsSet(boolean value) {
34477       if (!value) {
34478         this.ia = null;
34479       }
34480     }
34481 
34482     public void setFieldValue(_Fields field, Object value) {
34483       switch (field) {
34484       case SUCCESS:
34485         if (value == null) {
34486           unsetSuccess();
34487         } else {
34488           setSuccess((List<TRowResult>)value);
34489         }
34490         break;
34491 
34492       case IO:
34493         if (value == null) {
34494           unsetIo();
34495         } else {
34496           setIo((IOError)value);
34497         }
34498         break;
34499 
34500       case IA:
34501         if (value == null) {
34502           unsetIa();
34503         } else {
34504           setIa((IllegalArgument)value);
34505         }
34506         break;
34507 
34508       }
34509     }
34510 
34511     public void setFieldValue(int fieldID, Object value) {
34512       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
34513     }
34514 
34515     public Object getFieldValue(_Fields field) {
34516       switch (field) {
34517       case SUCCESS:
34518         return getSuccess();
34519 
34520       case IO:
34521         return getIo();
34522 
34523       case IA:
34524         return getIa();
34525 
34526       }
34527       throw new IllegalStateException();
34528     }
34529 
34530     public Object getFieldValue(int fieldId) {
34531       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
34532     }
34533 
34534     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
34535     public boolean isSet(_Fields field) {
34536       switch (field) {
34537       case SUCCESS:
34538         return isSetSuccess();
34539       case IO:
34540         return isSetIo();
34541       case IA:
34542         return isSetIa();
34543       }
34544       throw new IllegalStateException();
34545     }
34546 
34547     public boolean isSet(int fieldID) {
34548       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
34549     }
34550 
34551     @Override
34552     public boolean equals(Object that) {
34553       if (that == null)
34554         return false;
34555       if (that instanceof scannerGetList_result)
34556         return this.equals((scannerGetList_result)that);
34557       return false;
34558     }
34559 
34560     public boolean equals(scannerGetList_result that) {
34561       if (that == null)
34562         return false;
34563 
34564       boolean this_present_success = true && this.isSetSuccess();
34565       boolean that_present_success = true && that.isSetSuccess();
34566       if (this_present_success || that_present_success) {
34567         if (!(this_present_success && that_present_success))
34568           return false;
34569         if (!this.success.equals(that.success))
34570           return false;
34571       }
34572 
34573       boolean this_present_io = true && this.isSetIo();
34574       boolean that_present_io = true && that.isSetIo();
34575       if (this_present_io || that_present_io) {
34576         if (!(this_present_io && that_present_io))
34577           return false;
34578         if (!this.io.equals(that.io))
34579           return false;
34580       }
34581 
34582       boolean this_present_ia = true && this.isSetIa();
34583       boolean that_present_ia = true && that.isSetIa();
34584       if (this_present_ia || that_present_ia) {
34585         if (!(this_present_ia && that_present_ia))
34586           return false;
34587         if (!this.ia.equals(that.ia))
34588           return false;
34589       }
34590 
34591       return true;
34592     }
34593 
34594     @Override
34595     public int hashCode() {
34596       HashCodeBuilder builder = new HashCodeBuilder();
34597 
34598       boolean present_success = true && (isSetSuccess());
34599       builder.append(present_success);
34600       if (present_success)
34601         builder.append(success);
34602 
34603       boolean present_io = true && (isSetIo());
34604       builder.append(present_io);
34605       if (present_io)
34606         builder.append(io);
34607 
34608       boolean present_ia = true && (isSetIa());
34609       builder.append(present_ia);
34610       if (present_ia)
34611         builder.append(ia);
34612 
34613       return builder.toHashCode();
34614     }
34615 
34616     public void read(TProtocol iprot) throws TException {
34617       TField field;
34618       iprot.readStructBegin();
34619       while (true)
34620       {
34621         field = iprot.readFieldBegin();
34622         if (field.type == TType.STOP) {
34623           break;
34624         }
34625         _Fields fieldId = _Fields.findByThriftId(field.id);
34626         if (fieldId == null) {
34627           TProtocolUtil.skip(iprot, field.type);
34628         } else {
34629           switch (fieldId) {
34630             case SUCCESS:
34631               if (field.type == TType.LIST) {
34632                 {
34633                   TList _list142 = iprot.readListBegin();
34634                   this.success = new ArrayList<TRowResult>(_list142.size);
34635                   for (int _i143 = 0; _i143 < _list142.size; ++_i143)
34636                   {
34637                     TRowResult _elem144;
34638                     _elem144 = new TRowResult();
34639                     _elem144.read(iprot);
34640                     this.success.add(_elem144);
34641                   }
34642                   iprot.readListEnd();
34643                 }
34644               } else {
34645                 TProtocolUtil.skip(iprot, field.type);
34646               }
34647               break;
34648             case IO:
34649               if (field.type == TType.STRUCT) {
34650                 this.io = new IOError();
34651                 this.io.read(iprot);
34652               } else {
34653                 TProtocolUtil.skip(iprot, field.type);
34654               }
34655               break;
34656             case IA:
34657               if (field.type == TType.STRUCT) {
34658                 this.ia = new IllegalArgument();
34659                 this.ia.read(iprot);
34660               } else {
34661                 TProtocolUtil.skip(iprot, field.type);
34662               }
34663               break;
34664           }
34665           iprot.readFieldEnd();
34666         }
34667       }
34668       iprot.readStructEnd();
34669 
34670       // check for required fields of primitive type, which can't be checked in the validate method
34671       validate();
34672     }
34673 
34674     public void write(TProtocol oprot) throws TException {
34675       oprot.writeStructBegin(STRUCT_DESC);
34676 
34677       if (this.isSetSuccess()) {
34678         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
34679         {
34680           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
34681           for (TRowResult _iter145 : this.success)
34682           {
34683             _iter145.write(oprot);
34684           }
34685           oprot.writeListEnd();
34686         }
34687         oprot.writeFieldEnd();
34688       } else if (this.isSetIo()) {
34689         oprot.writeFieldBegin(IO_FIELD_DESC);
34690         this.io.write(oprot);
34691         oprot.writeFieldEnd();
34692       } else if (this.isSetIa()) {
34693         oprot.writeFieldBegin(IA_FIELD_DESC);
34694         this.ia.write(oprot);
34695         oprot.writeFieldEnd();
34696       }
34697       oprot.writeFieldStop();
34698       oprot.writeStructEnd();
34699     }
34700 
34701     @Override
34702     public String toString() {
34703       StringBuilder sb = new StringBuilder("scannerGetList_result(");
34704       boolean first = true;
34705 
34706       sb.append("success:");
34707       if (this.success == null) {
34708         sb.append("null");
34709       } else {
34710         sb.append(this.success);
34711       }
34712       first = false;
34713       if (!first) sb.append(", ");
34714       sb.append("io:");
34715       if (this.io == null) {
34716         sb.append("null");
34717       } else {
34718         sb.append(this.io);
34719       }
34720       first = false;
34721       if (!first) sb.append(", ");
34722       sb.append("ia:");
34723       if (this.ia == null) {
34724         sb.append("null");
34725       } else {
34726         sb.append(this.ia);
34727       }
34728       first = false;
34729       sb.append(")");
34730       return sb.toString();
34731     }
34732 
34733     public void validate() throws TException {
34734       // check for required fields
34735     }
34736 
34737   }
34738 
34739   public static class scannerClose_args implements TBase<scannerClose_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_args>   {
34740     private static final TStruct STRUCT_DESC = new TStruct("scannerClose_args");
34741 
34742     private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
34743 
34744     /**
34745      * id of a scanner returned by scannerOpen
34746      */
34747     public int id;
34748 
34749     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
34750     public enum _Fields implements TFieldIdEnum {
34751       /**
34752        * id of a scanner returned by scannerOpen
34753        */
34754       ID((short)1, "id");
34755 
34756       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
34757       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
34758 
34759       static {
34760         for (_Fields field : EnumSet.allOf(_Fields.class)) {
34761           byId.put((int)field._thriftId, field);
34762           byName.put(field.getFieldName(), field);
34763         }
34764       }
34765 
34766       /**
34767        * Find the _Fields constant that matches fieldId, or null if its not found.
34768        */
34769       public static _Fields findByThriftId(int fieldId) {
34770         return byId.get(fieldId);
34771       }
34772 
34773       /**
34774        * Find the _Fields constant that matches fieldId, throwing an exception
34775        * if it is not found.
34776        */
34777       public static _Fields findByThriftIdOrThrow(int fieldId) {
34778         _Fields fields = findByThriftId(fieldId);
34779         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
34780         return fields;
34781       }
34782 
34783       /**
34784        * Find the _Fields constant that matches name, or null if its not found.
34785        */
34786       public static _Fields findByName(String name) {
34787         return byName.get(name);
34788       }
34789 
34790       private final short _thriftId;
34791       private final String _fieldName;
34792 
34793       _Fields(short thriftId, String fieldName) {
34794         _thriftId = thriftId;
34795         _fieldName = fieldName;
34796       }
34797 
34798       public short getThriftFieldId() {
34799         return _thriftId;
34800       }
34801 
34802       public String getFieldName() {
34803         return _fieldName;
34804       }
34805     }
34806 
34807     // isset id assignments
34808     private static final int __ID_ISSET_ID = 0;
34809     private BitSet __isset_bit_vector = new BitSet(1);
34810 
34811     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
34812       put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
34813           new FieldValueMetaData(TType.I32)));
34814     }});
34815 
34816     static {
34817       FieldMetaData.addStructMetaDataMap(scannerClose_args.class, metaDataMap);
34818     }
34819 
34820     public scannerClose_args() {
34821     }
34822 
34823     public scannerClose_args(
34824       int id)
34825     {
34826       this();
34827       this.id = id;
34828       setIdIsSet(true);
34829     }
34830 
34831     /**
34832      * Performs a deep copy on <i>other</i>.
34833      */
34834     public scannerClose_args(scannerClose_args other) {
34835       __isset_bit_vector.clear();
34836       __isset_bit_vector.or(other.__isset_bit_vector);
34837       this.id = other.id;
34838     }
34839 
34840     public scannerClose_args deepCopy() {
34841       return new scannerClose_args(this);
34842     }
34843 
34844     @Deprecated
34845     public scannerClose_args clone() {
34846       return new scannerClose_args(this);
34847     }
34848 
34849     /**
34850      * id of a scanner returned by scannerOpen
34851      */
34852     public int getId() {
34853       return this.id;
34854     }
34855 
34856     /**
34857      * id of a scanner returned by scannerOpen
34858      */
34859     public scannerClose_args setId(int id) {
34860       this.id = id;
34861       setIdIsSet(true);
34862       return this;
34863     }
34864 
34865     public void unsetId() {
34866       __isset_bit_vector.clear(__ID_ISSET_ID);
34867     }
34868 
34869     /** Returns true if field id is set (has been asigned a value) and false otherwise */
34870     public boolean isSetId() {
34871       return __isset_bit_vector.get(__ID_ISSET_ID);
34872     }
34873 
34874     public void setIdIsSet(boolean value) {
34875       __isset_bit_vector.set(__ID_ISSET_ID, value);
34876     }
34877 
34878     public void setFieldValue(_Fields field, Object value) {
34879       switch (field) {
34880       case ID:
34881         if (value == null) {
34882           unsetId();
34883         } else {
34884           setId((Integer)value);
34885         }
34886         break;
34887 
34888       }
34889     }
34890 
34891     public void setFieldValue(int fieldID, Object value) {
34892       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
34893     }
34894 
34895     public Object getFieldValue(_Fields field) {
34896       switch (field) {
34897       case ID:
34898         return new Integer(getId());
34899 
34900       }
34901       throw new IllegalStateException();
34902     }
34903 
34904     public Object getFieldValue(int fieldId) {
34905       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
34906     }
34907 
34908     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
34909     public boolean isSet(_Fields field) {
34910       switch (field) {
34911       case ID:
34912         return isSetId();
34913       }
34914       throw new IllegalStateException();
34915     }
34916 
34917     public boolean isSet(int fieldID) {
34918       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
34919     }
34920 
34921     @Override
34922     public boolean equals(Object that) {
34923       if (that == null)
34924         return false;
34925       if (that instanceof scannerClose_args)
34926         return this.equals((scannerClose_args)that);
34927       return false;
34928     }
34929 
34930     public boolean equals(scannerClose_args that) {
34931       if (that == null)
34932         return false;
34933 
34934       boolean this_present_id = true;
34935       boolean that_present_id = true;
34936       if (this_present_id || that_present_id) {
34937         if (!(this_present_id && that_present_id))
34938           return false;
34939         if (this.id != that.id)
34940           return false;
34941       }
34942 
34943       return true;
34944     }
34945 
34946     @Override
34947     public int hashCode() {
34948       HashCodeBuilder builder = new HashCodeBuilder();
34949 
34950       boolean present_id = true;
34951       builder.append(present_id);
34952       if (present_id)
34953         builder.append(id);
34954 
34955       return builder.toHashCode();
34956     }
34957 
34958     public int compareTo(scannerClose_args other) {
34959       if (!getClass().equals(other.getClass())) {
34960         return getClass().getName().compareTo(other.getClass().getName());
34961       }
34962 
34963       int lastComparison = 0;
34964       scannerClose_args typedOther = (scannerClose_args)other;
34965 
34966       lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
34967       if (lastComparison != 0) {
34968         return lastComparison;
34969       }
34970       lastComparison = TBaseHelper.compareTo(id, typedOther.id);
34971       if (lastComparison != 0) {
34972         return lastComparison;
34973       }
34974       return 0;
34975     }
34976 
34977     public void read(TProtocol iprot) throws TException {
34978       TField field;
34979       iprot.readStructBegin();
34980       while (true)
34981       {
34982         field = iprot.readFieldBegin();
34983         if (field.type == TType.STOP) {
34984           break;
34985         }
34986         _Fields fieldId = _Fields.findByThriftId(field.id);
34987         if (fieldId == null) {
34988           TProtocolUtil.skip(iprot, field.type);
34989         } else {
34990           switch (fieldId) {
34991             case ID:
34992               if (field.type == TType.I32) {
34993                 this.id = iprot.readI32();
34994                 setIdIsSet(true);
34995               } else {
34996                 TProtocolUtil.skip(iprot, field.type);
34997               }
34998               break;
34999           }
35000           iprot.readFieldEnd();
35001         }
35002       }
35003       iprot.readStructEnd();
35004 
35005       // check for required fields of primitive type, which can't be checked in the validate method
35006       validate();
35007     }
35008 
35009     public void write(TProtocol oprot) throws TException {
35010       validate();
35011 
35012       oprot.writeStructBegin(STRUCT_DESC);
35013       oprot.writeFieldBegin(ID_FIELD_DESC);
35014       oprot.writeI32(this.id);
35015       oprot.writeFieldEnd();
35016       oprot.writeFieldStop();
35017       oprot.writeStructEnd();
35018     }
35019 
35020     @Override
35021     public String toString() {
35022       StringBuilder sb = new StringBuilder("scannerClose_args(");
35023       boolean first = true;
35024 
35025       sb.append("id:");
35026       sb.append(this.id);
35027       first = false;
35028       sb.append(")");
35029       return sb.toString();
35030     }
35031 
35032     public void validate() throws TException {
35033       // check for required fields
35034     }
35035 
35036   }
35037 
35038   public static class scannerClose_result implements TBase<scannerClose_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_result>   {
35039     private static final TStruct STRUCT_DESC = new TStruct("scannerClose_result");
35040 
35041     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
35042     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
35043 
35044     public IOError io;
35045     public IllegalArgument ia;
35046 
35047     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
35048     public enum _Fields implements TFieldIdEnum {
35049       IO((short)1, "io"),
35050       IA((short)2, "ia");
35051 
35052       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
35053       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
35054 
35055       static {
35056         for (_Fields field : EnumSet.allOf(_Fields.class)) {
35057           byId.put((int)field._thriftId, field);
35058           byName.put(field.getFieldName(), field);
35059         }
35060       }
35061 
35062       /**
35063        * Find the _Fields constant that matches fieldId, or null if its not found.
35064        */
35065       public static _Fields findByThriftId(int fieldId) {
35066         return byId.get(fieldId);
35067       }
35068 
35069       /**
35070        * Find the _Fields constant that matches fieldId, throwing an exception
35071        * if it is not found.
35072        */
35073       public static _Fields findByThriftIdOrThrow(int fieldId) {
35074         _Fields fields = findByThriftId(fieldId);
35075         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
35076         return fields;
35077       }
35078 
35079       /**
35080        * Find the _Fields constant that matches name, or null if its not found.
35081        */
35082       public static _Fields findByName(String name) {
35083         return byName.get(name);
35084       }
35085 
35086       private final short _thriftId;
35087       private final String _fieldName;
35088 
35089       _Fields(short thriftId, String fieldName) {
35090         _thriftId = thriftId;
35091         _fieldName = fieldName;
35092       }
35093 
35094       public short getThriftFieldId() {
35095         return _thriftId;
35096       }
35097 
35098       public String getFieldName() {
35099         return _fieldName;
35100       }
35101     }
35102 
35103     // isset id assignments
35104 
35105     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
35106       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
35107           new FieldValueMetaData(TType.STRUCT)));
35108       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
35109           new FieldValueMetaData(TType.STRUCT)));
35110     }});
35111 
35112     static {
35113       FieldMetaData.addStructMetaDataMap(scannerClose_result.class, metaDataMap);
35114     }
35115 
35116     public scannerClose_result() {
35117     }
35118 
35119     public scannerClose_result(
35120       IOError io,
35121       IllegalArgument ia)
35122     {
35123       this();
35124       this.io = io;
35125       this.ia = ia;
35126     }
35127 
35128     /**
35129      * Performs a deep copy on <i>other</i>.
35130      */
35131     public scannerClose_result(scannerClose_result other) {
35132       if (other.isSetIo()) {
35133         this.io = new IOError(other.io);
35134       }
35135       if (other.isSetIa()) {
35136         this.ia = new IllegalArgument(other.ia);
35137       }
35138     }
35139 
35140     public scannerClose_result deepCopy() {
35141       return new scannerClose_result(this);
35142     }
35143 
35144     @Deprecated
35145     public scannerClose_result clone() {
35146       return new scannerClose_result(this);
35147     }
35148 
35149     public IOError getIo() {
35150       return this.io;
35151     }
35152 
35153     public scannerClose_result setIo(IOError io) {
35154       this.io = io;
35155       return this;
35156     }
35157 
35158     public void unsetIo() {
35159       this.io = null;
35160     }
35161 
35162     /** Returns true if field io is set (has been asigned a value) and false otherwise */
35163     public boolean isSetIo() {
35164       return this.io != null;
35165     }
35166 
35167     public void setIoIsSet(boolean value) {
35168       if (!value) {
35169         this.io = null;
35170       }
35171     }
35172 
35173     public IllegalArgument getIa() {
35174       return this.ia;
35175     }
35176 
35177     public scannerClose_result setIa(IllegalArgument ia) {
35178       this.ia = ia;
35179       return this;
35180     }
35181 
35182     public void unsetIa() {
35183       this.ia = null;
35184     }
35185 
35186     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
35187     public boolean isSetIa() {
35188       return this.ia != null;
35189     }
35190 
35191     public void setIaIsSet(boolean value) {
35192       if (!value) {
35193         this.ia = null;
35194       }
35195     }
35196 
35197     public void setFieldValue(_Fields field, Object value) {
35198       switch (field) {
35199       case IO:
35200         if (value == null) {
35201           unsetIo();
35202         } else {
35203           setIo((IOError)value);
35204         }
35205         break;
35206 
35207       case IA:
35208         if (value == null) {
35209           unsetIa();
35210         } else {
35211           setIa((IllegalArgument)value);
35212         }
35213         break;
35214 
35215       }
35216     }
35217 
35218     public void setFieldValue(int fieldID, Object value) {
35219       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
35220     }
35221 
35222     public Object getFieldValue(_Fields field) {
35223       switch (field) {
35224       case IO:
35225         return getIo();
35226 
35227       case IA:
35228         return getIa();
35229 
35230       }
35231       throw new IllegalStateException();
35232     }
35233 
35234     public Object getFieldValue(int fieldId) {
35235       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
35236     }
35237 
35238     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
35239     public boolean isSet(_Fields field) {
35240       switch (field) {
35241       case IO:
35242         return isSetIo();
35243       case IA:
35244         return isSetIa();
35245       }
35246       throw new IllegalStateException();
35247     }
35248 
35249     public boolean isSet(int fieldID) {
35250       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
35251     }
35252 
35253     @Override
35254     public boolean equals(Object that) {
35255       if (that == null)
35256         return false;
35257       if (that instanceof scannerClose_result)
35258         return this.equals((scannerClose_result)that);
35259       return false;
35260     }
35261 
35262     public boolean equals(scannerClose_result that) {
35263       if (that == null)
35264         return false;
35265 
35266       boolean this_present_io = true && this.isSetIo();
35267       boolean that_present_io = true && that.isSetIo();
35268       if (this_present_io || that_present_io) {
35269         if (!(this_present_io && that_present_io))
35270           return false;
35271         if (!this.io.equals(that.io))
35272           return false;
35273       }
35274 
35275       boolean this_present_ia = true && this.isSetIa();
35276       boolean that_present_ia = true && that.isSetIa();
35277       if (this_present_ia || that_present_ia) {
35278         if (!(this_present_ia && that_present_ia))
35279           return false;
35280         if (!this.ia.equals(that.ia))
35281           return false;
35282       }
35283 
35284       return true;
35285     }
35286 
35287     @Override
35288     public int hashCode() {
35289       HashCodeBuilder builder = new HashCodeBuilder();
35290 
35291       boolean present_io = true && (isSetIo());
35292       builder.append(present_io);
35293       if (present_io)
35294         builder.append(io);
35295 
35296       boolean present_ia = true && (isSetIa());
35297       builder.append(present_ia);
35298       if (present_ia)
35299         builder.append(ia);
35300 
35301       return builder.toHashCode();
35302     }
35303 
35304     public int compareTo(scannerClose_result other) {
35305       if (!getClass().equals(other.getClass())) {
35306         return getClass().getName().compareTo(other.getClass().getName());
35307       }
35308 
35309       int lastComparison = 0;
35310       scannerClose_result typedOther = (scannerClose_result)other;
35311 
35312       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
35313       if (lastComparison != 0) {
35314         return lastComparison;
35315       }
35316       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
35317       if (lastComparison != 0) {
35318         return lastComparison;
35319       }
35320       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
35321       if (lastComparison != 0) {
35322         return lastComparison;
35323       }
35324       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
35325       if (lastComparison != 0) {
35326         return lastComparison;
35327       }
35328       return 0;
35329     }
35330 
35331     public void read(TProtocol iprot) throws TException {
35332       TField field;
35333       iprot.readStructBegin();
35334       while (true)
35335       {
35336         field = iprot.readFieldBegin();
35337         if (field.type == TType.STOP) {
35338           break;
35339         }
35340         _Fields fieldId = _Fields.findByThriftId(field.id);
35341         if (fieldId == null) {
35342           TProtocolUtil.skip(iprot, field.type);
35343         } else {
35344           switch (fieldId) {
35345             case IO:
35346               if (field.type == TType.STRUCT) {
35347                 this.io = new IOError();
35348                 this.io.read(iprot);
35349               } else {
35350                 TProtocolUtil.skip(iprot, field.type);
35351               }
35352               break;
35353             case IA:
35354               if (field.type == TType.STRUCT) {
35355                 this.ia = new IllegalArgument();
35356                 this.ia.read(iprot);
35357               } else {
35358                 TProtocolUtil.skip(iprot, field.type);
35359               }
35360               break;
35361           }
35362           iprot.readFieldEnd();
35363         }
35364       }
35365       iprot.readStructEnd();
35366 
35367       // check for required fields of primitive type, which can't be checked in the validate method
35368       validate();
35369     }
35370 
35371     public void write(TProtocol oprot) throws TException {
35372       oprot.writeStructBegin(STRUCT_DESC);
35373 
35374       if (this.isSetIo()) {
35375         oprot.writeFieldBegin(IO_FIELD_DESC);
35376         this.io.write(oprot);
35377         oprot.writeFieldEnd();
35378       } else if (this.isSetIa()) {
35379         oprot.writeFieldBegin(IA_FIELD_DESC);
35380         this.ia.write(oprot);
35381         oprot.writeFieldEnd();
35382       }
35383       oprot.writeFieldStop();
35384       oprot.writeStructEnd();
35385     }
35386 
35387     @Override
35388     public String toString() {
35389       StringBuilder sb = new StringBuilder("scannerClose_result(");
35390       boolean first = true;
35391 
35392       sb.append("io:");
35393       if (this.io == null) {
35394         sb.append("null");
35395       } else {
35396         sb.append(this.io);
35397       }
35398       first = false;
35399       if (!first) sb.append(", ");
35400       sb.append("ia:");
35401       if (this.ia == null) {
35402         sb.append("null");
35403       } else {
35404         sb.append(this.ia);
35405       }
35406       first = false;
35407       sb.append(")");
35408       return sb.toString();
35409     }
35410 
35411     public void validate() throws TException {
35412       // check for required fields
35413     }
35414 
35415   }
35416 
35417 }