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       * @return returns a list of names
72       */
73      public List<byte[]> getTableNames() throws IOError, TException;
74  
75      /**
76       * List all the column families assoicated with a table.
77       * @return list of column family descriptors
78       *
79       * @param tableName table name
80       */
81      public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException;
82  
83      /**
84       * List the regions associated with a table.
85       * @return list of region descriptors
86       *
87       * @param tableName table name
88       */
89      public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException;
90  
91      /**
92       * Create a table with the specified column families.  The name
93       * field for each ColumnDescriptor must be set and must end in a
94       * colon (:). All other fields are optional and will get default
95       * values if not explicitly specified.
96       *
97       * @throws IllegalArgument if an input parameter is invalid
98       * @throws AlreadyExists if the table name already exists
99       *
100      * @param tableName name of table to create
101      *
102      * @param columnFamilies list of column family descriptors
103      */
104     public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException;
105 
106     /**
107      * Deletes a table
108      *
109      * @throws IOError if table doesn't exist on server or there was some other
110      * problem
111      *
112      * @param tableName name of table to delete
113      */
114     public void deleteTable(byte[] tableName) throws IOError, TException;
115 
116     /**
117      * Get a single TCell for the specified table, row, and column at the
118      * latest timestamp. Returns an empty list if no such value exists.
119      *
120      * @return value for specified row/column
121      *
122      * @param tableName name of table
123      *
124      * @param row row key
125      *
126      * @param column column name
127      */
128     public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
129 
130     /**
131      * Get the specified number of versions for the specified table,
132      * row, and column.
133      *
134      * @return list of cells for specified row/column
135      *
136      * @param tableName name of table
137      *
138      * @param row row key
139      *
140      * @param column column name
141      *
142      * @param numVersions number of versions to retrieve
143      */
144     public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException;
145 
146     /**
147      * Get the specified number of versions for the specified table,
148      * row, and column.  Only versions less than or equal to the specified
149      * timestamp will be returned.
150      *
151      * @return list of cells for specified row/column
152      *
153      * @param tableName name of table
154      *
155      * @param row row key
156      *
157      * @param column column name
158      *
159      * @param timestamp timestamp
160      *
161      * @param numVersions number of versions to retrieve
162      */
163     public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException;
164 
165     /**
166      * Get all the data for the specified table and row at the latest
167      * timestamp. Returns an empty list if the row does not exist.
168      *
169      * @return TRowResult containing the row and map of columns to TCells
170      *
171      * @param tableName name of table
172      *
173      * @param row row key
174      */
175     public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException;
176 
177     /**
178      * Get the specified columns for the specified table and row at the latest
179      * timestamp. Returns an empty list if the row does not exist.
180      *
181      * @return TRowResult containing the row and map of columns to TCells
182      *
183      * @param tableName name of table
184      *
185      * @param row row key
186      *
187      * @param columns List of columns to return, null for all columns
188      */
189     public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException;
190 
191     /**
192      * Get all the data for the specified table and row at the specified
193      * timestamp. Returns an empty list if the row does not exist.
194      *
195      * @return TRowResult containing the row and map of columns to TCells
196      *
197      * @param tableName name of the table
198      *
199      * @param row row key
200      *
201      * @param timestamp timestamp
202      */
203     public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
204 
205     /**
206      * Get the specified columns for the specified table and row at the specified
207      * timestamp. Returns an empty list if the row does not exist.
208      *
209      * @return TRowResult containing the row and map of columns to TCells
210      *
211      * @param tableName name of table
212      *
213      * @param row row key
214      *
215      * @param columns List of columns to return, null for all columns
216      *
217      * @param timestamp
218      */
219     public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException;
220 
221     /**
222      * Apply a series of mutations (updates/deletes) to a row in a
223      * single transaction.  If an exception is thrown, then the
224      * transaction is aborted.  Default current timestamp is used, and
225      * all entries will have an identical timestamp.
226      *
227      * @param tableName name of table
228      *
229      * @param row row key
230      *
231      * @param mutations list of mutation commands
232      */
233     public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException;
234 
235     /**
236      * Apply a series of mutations (updates/deletes) to a row in a
237      * single transaction.  If an exception is thrown, then the
238      * transaction is aborted.  The specified timestamp is used, and
239      * all entries will have an identical timestamp.
240      *
241      * @param tableName name of table
242      *
243      * @param row row key
244      *
245      * @param mutations list of mutation commands
246      *
247      * @param timestamp timestamp
248      */
249     public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException;
250 
251     /**
252      * Apply a series of batches (each a series of mutations on a single row)
253      * in a single transaction.  If an exception is thrown, then the
254      * transaction is aborted.  Default current timestamp is used, and
255      * all entries will have an identical timestamp.
256      *
257      * @param tableName name of table
258      *
259      * @param rowBatches list of row batches
260      */
261     public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException;
262 
263     /**
264      * Apply a series of batches (each a series of mutations on a single row)
265      * in a single transaction.  If an exception is thrown, then the
266      * transaction is aborted.  The specified timestamp is used, and
267      * all entries will have an identical timestamp.
268      *
269      * @param tableName name of table
270      *
271      * @param rowBatches list of row batches
272      *
273      * @param timestamp timestamp
274      */
275     public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException;
276 
277     /**
278      * Atomically increment the column value specified.  Returns the next value post increment.
279      *
280      * @param tableName name of table
281      *
282      * @param row row to increment
283      *
284      * @param column name of column
285      *
286      * @param value amount to increment by
287      */
288     public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException;
289 
290     /**
291      * Delete all cells that match the passed row and column.
292      *
293      * @param tableName name of table
294      *
295      * @param row Row to update
296      *
297      * @param column name of column whose value is to be deleted
298      */
299     public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
300 
301     /**
302      * Delete all cells that match the passed row and column and whose
303      * timestamp is equal-to or older than the passed timestamp.
304      *
305      * @param tableName name of table
306      *
307      * @param row Row to update
308      *
309      * @param column name of column whose value is to be deleted
310      *
311      * @param timestamp timestamp
312      */
313     public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException;
314 
315     /**
316      * Completely delete the row's cells.
317      *
318      * @param tableName name of table
319      *
320      * @param row key of the row to be completely deleted.
321      */
322     public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException;
323 
324     /**
325      * Completely delete the row's cells marked with a timestamp
326      * equal-to or older than the passed timestamp.
327      *
328      * @param tableName name of table
329      *
330      * @param row key of the row to be completely deleted.
331      *
332      * @param timestamp timestamp
333      */
334     public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
335 
336     /**
337      * Get a scanner on the current table starting at the specified row and
338      * ending at the last row in the table.  Return the specified columns.
339      *
340      * @return scanner id to be used with other scanner procedures
341      *
342      * @param tableName name of table
343      *
344      * @param startRow Starting row in table to scan.
345      * Send "" (empty string) to start at the first row.
346      *
347      * @param columns columns to scan. If column name is a column family, all
348      * columns of the specified column family are returned. It's also possible
349      * to pass a regex in the column qualifier.
350      */
351     public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException;
352 
353     /**
354      * Get a scanner on the current table starting and stopping at the
355      * specified rows.  ending at the last row in the table.  Return the
356      * specified columns.
357      *
358      * @return scanner id to be used with other scanner procedures
359      *
360      * @param tableName name of table
361      *
362      * @param startRow Starting row in table to scan.
363      * Send "" (empty string) to start at the first row.
364      *
365      * @param stopRow row to stop scanning on. This row is *not* included in the
366      * scanner's results
367      *
368      * @param columns columns to scan. If column name is a column family, all
369      * columns of the specified column family are returned. It's also possible
370      * to pass a regex in the column qualifier.
371      */
372     public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException;
373 
374     /**
375      * Open a scanner for a given prefix.  That is all rows will have the specified
376      * prefix. No other rows will be returned.
377      *
378      * @return scanner id to use with other scanner calls
379      *
380      * @param tableName name of table
381      *
382      * @param startAndPrefix the prefix (and thus start row) of the keys you want
383      *
384      * @param columns the columns you want returned
385      */
386     public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException;
387 
388     /**
389      * Get a scanner on the current table starting at the specified row and
390      * ending at the last row in the table.  Return the specified columns.
391      * Only values with the specified timestamp are returned.
392      *
393      * @return scanner id to be used with other scanner procedures
394      *
395      * @param tableName name of table
396      *
397      * @param startRow Starting row in table to scan.
398      * Send "" (empty string) to start at the first row.
399      *
400      * @param columns columns to scan. If column name is a column family, all
401      * columns of the specified column family are returned. It's also possible
402      * to pass a regex in the column qualifier.
403      *
404      * @param timestamp timestamp
405      */
406     public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException;
407 
408     /**
409      * Get a scanner on the current table starting and stopping at the
410      * specified rows.  ending at the last row in the table.  Return the
411      * specified columns.  Only values with the specified timestamp are
412      * returned.
413      *
414      * @return scanner id to be used with other scanner procedures
415      *
416      * @param tableName name of table
417      *
418      * @param startRow Starting row in table to scan.
419      * Send "" (empty string) to start at the first row.
420      *
421      * @param stopRow row to stop scanning on. This row is *not* included in the
422      * scanner's results
423      *
424      * @param columns columns to scan. If column name is a column family, all
425      * columns of the specified column family are returned. It's also possible
426      * to pass a regex in the column qualifier.
427      *
428      * @param timestamp timestamp
429      */
430     public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException;
431 
432     /**
433      * Returns the scanner's current row value and advances to the next
434      * row in the table.  When there are no more rows in the table, or a key
435      * greater-than-or-equal-to the scanner's specified stopRow is reached,
436      * an empty list is returned.
437      *
438      * @return a TRowResult containing the current row and a map of the columns to TCells.
439      * @throws IllegalArgument if ScannerID is invalid
440      * @throws NotFound when the scanner reaches the end
441      *
442      * @param id id of a scanner returned by scannerOpen
443      */
444     public List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, TException;
445 
446     /**
447      * Returns, starting at the scanner's current row value nbRows worth of
448      * rows and advances to the next row in the table.  When there are no more
449      * rows in the table, or a key greater-than-or-equal-to the scanner's
450      * specified stopRow is reached,  an empty list is returned.
451      *
452      * @return a TRowResult containing the current row and a map of the columns to TCells.
453      * @throws IllegalArgument if ScannerID is invalid
454      * @throws NotFound when the scanner reaches the end
455      *
456      * @param id id of a scanner returned by scannerOpen
457      *
458      * @param nbRows number of results to return
459      */
460     public List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException;
461 
462     /**
463      * Closes the server-state associated with an open scanner.
464      *
465      * @throws IllegalArgument if ScannerID is invalid
466      *
467      * @param id id of a scanner returned by scannerOpen
468      */
469     public void scannerClose(int id) throws IOError, IllegalArgument, TException;
470 
471   }
472 
473   public static class Client implements Iface {
474     public Client(TProtocol prot)
475     {
476       this(prot, prot);
477     }
478 
479     public Client(TProtocol iprot, TProtocol oprot)
480     {
481       iprot_ = iprot;
482       oprot_ = oprot;
483     }
484 
485     protected TProtocol iprot_;
486     protected TProtocol oprot_;
487 
488     protected int seqid_;
489 
490     public TProtocol getInputProtocol()
491     {
492       return this.iprot_;
493     }
494 
495     public TProtocol getOutputProtocol()
496     {
497       return this.oprot_;
498     }
499 
500     public void enableTable(byte[] tableName) throws IOError, TException
501     {
502       send_enableTable(tableName);
503       recv_enableTable();
504     }
505 
506     public void send_enableTable(byte[] tableName) throws TException
507     {
508       oprot_.writeMessageBegin(new TMessage("enableTable", TMessageType.CALL, seqid_));
509       enableTable_args args = new enableTable_args();
510       args.tableName = tableName;
511       args.write(oprot_);
512       oprot_.writeMessageEnd();
513       oprot_.getTransport().flush();
514     }
515 
516     public void recv_enableTable() throws IOError, TException
517     {
518       TMessage msg = iprot_.readMessageBegin();
519       if (msg.type == TMessageType.EXCEPTION) {
520         TApplicationException x = TApplicationException.read(iprot_);
521         iprot_.readMessageEnd();
522         throw x;
523       }
524       enableTable_result result = new enableTable_result();
525       result.read(iprot_);
526       iprot_.readMessageEnd();
527       if (result.io != null) {
528         throw result.io;
529       }
530       return;
531     }
532 
533     public void disableTable(byte[] tableName) throws IOError, TException
534     {
535       send_disableTable(tableName);
536       recv_disableTable();
537     }
538 
539     public void send_disableTable(byte[] tableName) throws TException
540     {
541       oprot_.writeMessageBegin(new TMessage("disableTable", TMessageType.CALL, seqid_));
542       disableTable_args args = new disableTable_args();
543       args.tableName = tableName;
544       args.write(oprot_);
545       oprot_.writeMessageEnd();
546       oprot_.getTransport().flush();
547     }
548 
549     public void recv_disableTable() throws IOError, TException
550     {
551       TMessage msg = iprot_.readMessageBegin();
552       if (msg.type == TMessageType.EXCEPTION) {
553         TApplicationException x = TApplicationException.read(iprot_);
554         iprot_.readMessageEnd();
555         throw x;
556       }
557       disableTable_result result = new disableTable_result();
558       result.read(iprot_);
559       iprot_.readMessageEnd();
560       if (result.io != null) {
561         throw result.io;
562       }
563       return;
564     }
565 
566     public boolean isTableEnabled(byte[] tableName) throws IOError, TException
567     {
568       send_isTableEnabled(tableName);
569       return recv_isTableEnabled();
570     }
571 
572     public void send_isTableEnabled(byte[] tableName) throws TException
573     {
574       oprot_.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.CALL, seqid_));
575       isTableEnabled_args args = new isTableEnabled_args();
576       args.tableName = tableName;
577       args.write(oprot_);
578       oprot_.writeMessageEnd();
579       oprot_.getTransport().flush();
580     }
581 
582     public boolean recv_isTableEnabled() throws IOError, TException
583     {
584       TMessage msg = iprot_.readMessageBegin();
585       if (msg.type == TMessageType.EXCEPTION) {
586         TApplicationException x = TApplicationException.read(iprot_);
587         iprot_.readMessageEnd();
588         throw x;
589       }
590       isTableEnabled_result result = new isTableEnabled_result();
591       result.read(iprot_);
592       iprot_.readMessageEnd();
593       if (result.isSetSuccess()) {
594         return result.success;
595       }
596       if (result.io != null) {
597         throw result.io;
598       }
599       throw new TApplicationException(TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result");
600     }
601 
602     public void compact(byte[] tableNameOrRegionName) throws IOError, TException
603     {
604       send_compact(tableNameOrRegionName);
605       recv_compact();
606     }
607 
608     public void send_compact(byte[] tableNameOrRegionName) throws TException
609     {
610       oprot_.writeMessageBegin(new TMessage("compact", TMessageType.CALL, seqid_));
611       compact_args args = new compact_args();
612       args.tableNameOrRegionName = tableNameOrRegionName;
613       args.write(oprot_);
614       oprot_.writeMessageEnd();
615       oprot_.getTransport().flush();
616     }
617 
618     public void recv_compact() throws IOError, TException
619     {
620       TMessage msg = iprot_.readMessageBegin();
621       if (msg.type == TMessageType.EXCEPTION) {
622         TApplicationException x = TApplicationException.read(iprot_);
623         iprot_.readMessageEnd();
624         throw x;
625       }
626       compact_result result = new compact_result();
627       result.read(iprot_);
628       iprot_.readMessageEnd();
629       if (result.io != null) {
630         throw result.io;
631       }
632       return;
633     }
634 
635     public void majorCompact(byte[] tableNameOrRegionName) throws IOError, TException
636     {
637       send_majorCompact(tableNameOrRegionName);
638       recv_majorCompact();
639     }
640 
641     public void send_majorCompact(byte[] tableNameOrRegionName) throws TException
642     {
643       oprot_.writeMessageBegin(new TMessage("majorCompact", TMessageType.CALL, seqid_));
644       majorCompact_args args = new majorCompact_args();
645       args.tableNameOrRegionName = tableNameOrRegionName;
646       args.write(oprot_);
647       oprot_.writeMessageEnd();
648       oprot_.getTransport().flush();
649     }
650 
651     public void recv_majorCompact() throws IOError, TException
652     {
653       TMessage msg = iprot_.readMessageBegin();
654       if (msg.type == TMessageType.EXCEPTION) {
655         TApplicationException x = TApplicationException.read(iprot_);
656         iprot_.readMessageEnd();
657         throw x;
658       }
659       majorCompact_result result = new majorCompact_result();
660       result.read(iprot_);
661       iprot_.readMessageEnd();
662       if (result.io != null) {
663         throw result.io;
664       }
665       return;
666     }
667 
668     public List<byte[]> getTableNames() throws IOError, TException
669     {
670       send_getTableNames();
671       return recv_getTableNames();
672     }
673 
674     public void send_getTableNames() throws TException
675     {
676       oprot_.writeMessageBegin(new TMessage("getTableNames", TMessageType.CALL, seqid_));
677       getTableNames_args args = new getTableNames_args();
678       args.write(oprot_);
679       oprot_.writeMessageEnd();
680       oprot_.getTransport().flush();
681     }
682 
683     public List<byte[]> recv_getTableNames() throws IOError, TException
684     {
685       TMessage msg = iprot_.readMessageBegin();
686       if (msg.type == TMessageType.EXCEPTION) {
687         TApplicationException x = TApplicationException.read(iprot_);
688         iprot_.readMessageEnd();
689         throw x;
690       }
691       getTableNames_result result = new getTableNames_result();
692       result.read(iprot_);
693       iprot_.readMessageEnd();
694       if (result.isSetSuccess()) {
695         return result.success;
696       }
697       if (result.io != null) {
698         throw result.io;
699       }
700       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result");
701     }
702 
703     public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException
704     {
705       send_getColumnDescriptors(tableName);
706       return recv_getColumnDescriptors();
707     }
708 
709     public void send_getColumnDescriptors(byte[] tableName) throws TException
710     {
711       oprot_.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.CALL, seqid_));
712       getColumnDescriptors_args args = new getColumnDescriptors_args();
713       args.tableName = tableName;
714       args.write(oprot_);
715       oprot_.writeMessageEnd();
716       oprot_.getTransport().flush();
717     }
718 
719     public Map<byte[],ColumnDescriptor> recv_getColumnDescriptors() throws IOError, TException
720     {
721       TMessage msg = iprot_.readMessageBegin();
722       if (msg.type == TMessageType.EXCEPTION) {
723         TApplicationException x = TApplicationException.read(iprot_);
724         iprot_.readMessageEnd();
725         throw x;
726       }
727       getColumnDescriptors_result result = new getColumnDescriptors_result();
728       result.read(iprot_);
729       iprot_.readMessageEnd();
730       if (result.isSetSuccess()) {
731         return result.success;
732       }
733       if (result.io != null) {
734         throw result.io;
735       }
736       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result");
737     }
738 
739     public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException
740     {
741       send_getTableRegions(tableName);
742       return recv_getTableRegions();
743     }
744 
745     public void send_getTableRegions(byte[] tableName) throws TException
746     {
747       oprot_.writeMessageBegin(new TMessage("getTableRegions", TMessageType.CALL, seqid_));
748       getTableRegions_args args = new getTableRegions_args();
749       args.tableName = tableName;
750       args.write(oprot_);
751       oprot_.writeMessageEnd();
752       oprot_.getTransport().flush();
753     }
754 
755     public List<TRegionInfo> recv_getTableRegions() throws IOError, TException
756     {
757       TMessage msg = iprot_.readMessageBegin();
758       if (msg.type == TMessageType.EXCEPTION) {
759         TApplicationException x = TApplicationException.read(iprot_);
760         iprot_.readMessageEnd();
761         throw x;
762       }
763       getTableRegions_result result = new getTableRegions_result();
764       result.read(iprot_);
765       iprot_.readMessageEnd();
766       if (result.isSetSuccess()) {
767         return result.success;
768       }
769       if (result.io != null) {
770         throw result.io;
771       }
772       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result");
773     }
774 
775     public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException
776     {
777       send_createTable(tableName, columnFamilies);
778       recv_createTable();
779     }
780 
781     public void send_createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws TException
782     {
783       oprot_.writeMessageBegin(new TMessage("createTable", TMessageType.CALL, seqid_));
784       createTable_args args = new createTable_args();
785       args.tableName = tableName;
786       args.columnFamilies = columnFamilies;
787       args.write(oprot_);
788       oprot_.writeMessageEnd();
789       oprot_.getTransport().flush();
790     }
791 
792     public void recv_createTable() throws IOError, IllegalArgument, AlreadyExists, TException
793     {
794       TMessage msg = iprot_.readMessageBegin();
795       if (msg.type == TMessageType.EXCEPTION) {
796         TApplicationException x = TApplicationException.read(iprot_);
797         iprot_.readMessageEnd();
798         throw x;
799       }
800       createTable_result result = new createTable_result();
801       result.read(iprot_);
802       iprot_.readMessageEnd();
803       if (result.io != null) {
804         throw result.io;
805       }
806       if (result.ia != null) {
807         throw result.ia;
808       }
809       if (result.exist != null) {
810         throw result.exist;
811       }
812       return;
813     }
814 
815     public void deleteTable(byte[] tableName) throws IOError, TException
816     {
817       send_deleteTable(tableName);
818       recv_deleteTable();
819     }
820 
821     public void send_deleteTable(byte[] tableName) throws TException
822     {
823       oprot_.writeMessageBegin(new TMessage("deleteTable", TMessageType.CALL, seqid_));
824       deleteTable_args args = new deleteTable_args();
825       args.tableName = tableName;
826       args.write(oprot_);
827       oprot_.writeMessageEnd();
828       oprot_.getTransport().flush();
829     }
830 
831     public void recv_deleteTable() throws IOError, TException
832     {
833       TMessage msg = iprot_.readMessageBegin();
834       if (msg.type == TMessageType.EXCEPTION) {
835         TApplicationException x = TApplicationException.read(iprot_);
836         iprot_.readMessageEnd();
837         throw x;
838       }
839       deleteTable_result result = new deleteTable_result();
840       result.read(iprot_);
841       iprot_.readMessageEnd();
842       if (result.io != null) {
843         throw result.io;
844       }
845       return;
846     }
847 
848     public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
849     {
850       send_get(tableName, row, column);
851       return recv_get();
852     }
853 
854     public void send_get(byte[] tableName, byte[] row, byte[] column) throws TException
855     {
856       oprot_.writeMessageBegin(new TMessage("get", TMessageType.CALL, seqid_));
857       get_args args = new get_args();
858       args.tableName = tableName;
859       args.row = row;
860       args.column = column;
861       args.write(oprot_);
862       oprot_.writeMessageEnd();
863       oprot_.getTransport().flush();
864     }
865 
866     public List<TCell> recv_get() throws IOError, TException
867     {
868       TMessage msg = iprot_.readMessageBegin();
869       if (msg.type == TMessageType.EXCEPTION) {
870         TApplicationException x = TApplicationException.read(iprot_);
871         iprot_.readMessageEnd();
872         throw x;
873       }
874       get_result result = new get_result();
875       result.read(iprot_);
876       iprot_.readMessageEnd();
877       if (result.isSetSuccess()) {
878         return result.success;
879       }
880       if (result.io != null) {
881         throw result.io;
882       }
883       throw new TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result");
884     }
885 
886     public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException
887     {
888       send_getVer(tableName, row, column, numVersions);
889       return recv_getVer();
890     }
891 
892     public void send_getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws TException
893     {
894       oprot_.writeMessageBegin(new TMessage("getVer", TMessageType.CALL, seqid_));
895       getVer_args args = new getVer_args();
896       args.tableName = tableName;
897       args.row = row;
898       args.column = column;
899       args.numVersions = numVersions;
900       args.write(oprot_);
901       oprot_.writeMessageEnd();
902       oprot_.getTransport().flush();
903     }
904 
905     public List<TCell> recv_getVer() throws IOError, TException
906     {
907       TMessage msg = iprot_.readMessageBegin();
908       if (msg.type == TMessageType.EXCEPTION) {
909         TApplicationException x = TApplicationException.read(iprot_);
910         iprot_.readMessageEnd();
911         throw x;
912       }
913       getVer_result result = new getVer_result();
914       result.read(iprot_);
915       iprot_.readMessageEnd();
916       if (result.isSetSuccess()) {
917         return result.success;
918       }
919       if (result.io != null) {
920         throw result.io;
921       }
922       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVer failed: unknown result");
923     }
924 
925     public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException
926     {
927       send_getVerTs(tableName, row, column, timestamp, numVersions);
928       return recv_getVerTs();
929     }
930 
931     public void send_getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws TException
932     {
933       oprot_.writeMessageBegin(new TMessage("getVerTs", TMessageType.CALL, seqid_));
934       getVerTs_args args = new getVerTs_args();
935       args.tableName = tableName;
936       args.row = row;
937       args.column = column;
938       args.timestamp = timestamp;
939       args.numVersions = numVersions;
940       args.write(oprot_);
941       oprot_.writeMessageEnd();
942       oprot_.getTransport().flush();
943     }
944 
945     public List<TCell> recv_getVerTs() throws IOError, TException
946     {
947       TMessage msg = iprot_.readMessageBegin();
948       if (msg.type == TMessageType.EXCEPTION) {
949         TApplicationException x = TApplicationException.read(iprot_);
950         iprot_.readMessageEnd();
951         throw x;
952       }
953       getVerTs_result result = new getVerTs_result();
954       result.read(iprot_);
955       iprot_.readMessageEnd();
956       if (result.isSetSuccess()) {
957         return result.success;
958       }
959       if (result.io != null) {
960         throw result.io;
961       }
962       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result");
963     }
964 
965     public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException
966     {
967       send_getRow(tableName, row);
968       return recv_getRow();
969     }
970 
971     public void send_getRow(byte[] tableName, byte[] row) throws TException
972     {
973       oprot_.writeMessageBegin(new TMessage("getRow", TMessageType.CALL, seqid_));
974       getRow_args args = new getRow_args();
975       args.tableName = tableName;
976       args.row = row;
977       args.write(oprot_);
978       oprot_.writeMessageEnd();
979       oprot_.getTransport().flush();
980     }
981 
982     public List<TRowResult> recv_getRow() throws IOError, TException
983     {
984       TMessage msg = iprot_.readMessageBegin();
985       if (msg.type == TMessageType.EXCEPTION) {
986         TApplicationException x = TApplicationException.read(iprot_);
987         iprot_.readMessageEnd();
988         throw x;
989       }
990       getRow_result result = new getRow_result();
991       result.read(iprot_);
992       iprot_.readMessageEnd();
993       if (result.isSetSuccess()) {
994         return result.success;
995       }
996       if (result.io != null) {
997         throw result.io;
998       }
999       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRow failed: unknown result");
1000     }
1001 
1002     public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException
1003     {
1004       send_getRowWithColumns(tableName, row, columns);
1005       return recv_getRowWithColumns();
1006     }
1007 
1008     public void send_getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws TException
1009     {
1010       oprot_.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.CALL, seqid_));
1011       getRowWithColumns_args args = new getRowWithColumns_args();
1012       args.tableName = tableName;
1013       args.row = row;
1014       args.columns = columns;
1015       args.write(oprot_);
1016       oprot_.writeMessageEnd();
1017       oprot_.getTransport().flush();
1018     }
1019 
1020     public List<TRowResult> recv_getRowWithColumns() throws IOError, TException
1021     {
1022       TMessage msg = iprot_.readMessageBegin();
1023       if (msg.type == TMessageType.EXCEPTION) {
1024         TApplicationException x = TApplicationException.read(iprot_);
1025         iprot_.readMessageEnd();
1026         throw x;
1027       }
1028       getRowWithColumns_result result = new getRowWithColumns_result();
1029       result.read(iprot_);
1030       iprot_.readMessageEnd();
1031       if (result.isSetSuccess()) {
1032         return result.success;
1033       }
1034       if (result.io != null) {
1035         throw result.io;
1036       }
1037       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result");
1038     }
1039 
1040     public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
1041     {
1042       send_getRowTs(tableName, row, timestamp);
1043       return recv_getRowTs();
1044     }
1045 
1046     public void send_getRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
1047     {
1048       oprot_.writeMessageBegin(new TMessage("getRowTs", TMessageType.CALL, seqid_));
1049       getRowTs_args args = new getRowTs_args();
1050       args.tableName = tableName;
1051       args.row = row;
1052       args.timestamp = timestamp;
1053       args.write(oprot_);
1054       oprot_.writeMessageEnd();
1055       oprot_.getTransport().flush();
1056     }
1057 
1058     public List<TRowResult> recv_getRowTs() throws IOError, TException
1059     {
1060       TMessage msg = iprot_.readMessageBegin();
1061       if (msg.type == TMessageType.EXCEPTION) {
1062         TApplicationException x = TApplicationException.read(iprot_);
1063         iprot_.readMessageEnd();
1064         throw x;
1065       }
1066       getRowTs_result result = new getRowTs_result();
1067       result.read(iprot_);
1068       iprot_.readMessageEnd();
1069       if (result.isSetSuccess()) {
1070         return result.success;
1071       }
1072       if (result.io != null) {
1073         throw result.io;
1074       }
1075       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result");
1076     }
1077 
1078     public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException
1079     {
1080       send_getRowWithColumnsTs(tableName, row, columns, timestamp);
1081       return recv_getRowWithColumnsTs();
1082     }
1083 
1084     public void send_getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws TException
1085     {
1086       oprot_.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.CALL, seqid_));
1087       getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
1088       args.tableName = tableName;
1089       args.row = row;
1090       args.columns = columns;
1091       args.timestamp = timestamp;
1092       args.write(oprot_);
1093       oprot_.writeMessageEnd();
1094       oprot_.getTransport().flush();
1095     }
1096 
1097     public List<TRowResult> recv_getRowWithColumnsTs() throws IOError, TException
1098     {
1099       TMessage msg = iprot_.readMessageBegin();
1100       if (msg.type == TMessageType.EXCEPTION) {
1101         TApplicationException x = TApplicationException.read(iprot_);
1102         iprot_.readMessageEnd();
1103         throw x;
1104       }
1105       getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
1106       result.read(iprot_);
1107       iprot_.readMessageEnd();
1108       if (result.isSetSuccess()) {
1109         return result.success;
1110       }
1111       if (result.io != null) {
1112         throw result.io;
1113       }
1114       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
1115     }
1116 
1117     public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException
1118     {
1119       send_mutateRow(tableName, row, mutations);
1120       recv_mutateRow();
1121     }
1122 
1123     public void send_mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws TException
1124     {
1125       oprot_.writeMessageBegin(new TMessage("mutateRow", TMessageType.CALL, seqid_));
1126       mutateRow_args args = new mutateRow_args();
1127       args.tableName = tableName;
1128       args.row = row;
1129       args.mutations = mutations;
1130       args.write(oprot_);
1131       oprot_.writeMessageEnd();
1132       oprot_.getTransport().flush();
1133     }
1134 
1135     public void recv_mutateRow() throws IOError, IllegalArgument, TException
1136     {
1137       TMessage msg = iprot_.readMessageBegin();
1138       if (msg.type == TMessageType.EXCEPTION) {
1139         TApplicationException x = TApplicationException.read(iprot_);
1140         iprot_.readMessageEnd();
1141         throw x;
1142       }
1143       mutateRow_result result = new mutateRow_result();
1144       result.read(iprot_);
1145       iprot_.readMessageEnd();
1146       if (result.io != null) {
1147         throw result.io;
1148       }
1149       if (result.ia != null) {
1150         throw result.ia;
1151       }
1152       return;
1153     }
1154 
1155     public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException
1156     {
1157       send_mutateRowTs(tableName, row, mutations, timestamp);
1158       recv_mutateRowTs();
1159     }
1160 
1161     public void send_mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws TException
1162     {
1163       oprot_.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.CALL, seqid_));
1164       mutateRowTs_args args = new mutateRowTs_args();
1165       args.tableName = tableName;
1166       args.row = row;
1167       args.mutations = mutations;
1168       args.timestamp = timestamp;
1169       args.write(oprot_);
1170       oprot_.writeMessageEnd();
1171       oprot_.getTransport().flush();
1172     }
1173 
1174     public void recv_mutateRowTs() throws IOError, IllegalArgument, TException
1175     {
1176       TMessage msg = iprot_.readMessageBegin();
1177       if (msg.type == TMessageType.EXCEPTION) {
1178         TApplicationException x = TApplicationException.read(iprot_);
1179         iprot_.readMessageEnd();
1180         throw x;
1181       }
1182       mutateRowTs_result result = new mutateRowTs_result();
1183       result.read(iprot_);
1184       iprot_.readMessageEnd();
1185       if (result.io != null) {
1186         throw result.io;
1187       }
1188       if (result.ia != null) {
1189         throw result.ia;
1190       }
1191       return;
1192     }
1193 
1194     public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException
1195     {
1196       send_mutateRows(tableName, rowBatches);
1197       recv_mutateRows();
1198     }
1199 
1200     public void send_mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws TException
1201     {
1202       oprot_.writeMessageBegin(new TMessage("mutateRows", TMessageType.CALL, seqid_));
1203       mutateRows_args args = new mutateRows_args();
1204       args.tableName = tableName;
1205       args.rowBatches = rowBatches;
1206       args.write(oprot_);
1207       oprot_.writeMessageEnd();
1208       oprot_.getTransport().flush();
1209     }
1210 
1211     public void recv_mutateRows() throws IOError, IllegalArgument, TException
1212     {
1213       TMessage msg = iprot_.readMessageBegin();
1214       if (msg.type == TMessageType.EXCEPTION) {
1215         TApplicationException x = TApplicationException.read(iprot_);
1216         iprot_.readMessageEnd();
1217         throw x;
1218       }
1219       mutateRows_result result = new mutateRows_result();
1220       result.read(iprot_);
1221       iprot_.readMessageEnd();
1222       if (result.io != null) {
1223         throw result.io;
1224       }
1225       if (result.ia != null) {
1226         throw result.ia;
1227       }
1228       return;
1229     }
1230 
1231     public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException
1232     {
1233       send_mutateRowsTs(tableName, rowBatches, timestamp);
1234       recv_mutateRowsTs();
1235     }
1236 
1237     public void send_mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws TException
1238     {
1239       oprot_.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.CALL, seqid_));
1240       mutateRowsTs_args args = new mutateRowsTs_args();
1241       args.tableName = tableName;
1242       args.rowBatches = rowBatches;
1243       args.timestamp = timestamp;
1244       args.write(oprot_);
1245       oprot_.writeMessageEnd();
1246       oprot_.getTransport().flush();
1247     }
1248 
1249     public void recv_mutateRowsTs() throws IOError, IllegalArgument, TException
1250     {
1251       TMessage msg = iprot_.readMessageBegin();
1252       if (msg.type == TMessageType.EXCEPTION) {
1253         TApplicationException x = TApplicationException.read(iprot_);
1254         iprot_.readMessageEnd();
1255         throw x;
1256       }
1257       mutateRowsTs_result result = new mutateRowsTs_result();
1258       result.read(iprot_);
1259       iprot_.readMessageEnd();
1260       if (result.io != null) {
1261         throw result.io;
1262       }
1263       if (result.ia != null) {
1264         throw result.ia;
1265       }
1266       return;
1267     }
1268 
1269     public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException
1270     {
1271       send_atomicIncrement(tableName, row, column, value);
1272       return recv_atomicIncrement();
1273     }
1274 
1275     public void send_atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws TException
1276     {
1277       oprot_.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.CALL, seqid_));
1278       atomicIncrement_args args = new atomicIncrement_args();
1279       args.tableName = tableName;
1280       args.row = row;
1281       args.column = column;
1282       args.value = value;
1283       args.write(oprot_);
1284       oprot_.writeMessageEnd();
1285       oprot_.getTransport().flush();
1286     }
1287 
1288     public long recv_atomicIncrement() throws IOError, IllegalArgument, TException
1289     {
1290       TMessage msg = iprot_.readMessageBegin();
1291       if (msg.type == TMessageType.EXCEPTION) {
1292         TApplicationException x = TApplicationException.read(iprot_);
1293         iprot_.readMessageEnd();
1294         throw x;
1295       }
1296       atomicIncrement_result result = new atomicIncrement_result();
1297       result.read(iprot_);
1298       iprot_.readMessageEnd();
1299       if (result.isSetSuccess()) {
1300         return result.success;
1301       }
1302       if (result.io != null) {
1303         throw result.io;
1304       }
1305       if (result.ia != null) {
1306         throw result.ia;
1307       }
1308       throw new TApplicationException(TApplicationException.MISSING_RESULT, "atomicIncrement failed: unknown result");
1309     }
1310 
1311     public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
1312     {
1313       send_deleteAll(tableName, row, column);
1314       recv_deleteAll();
1315     }
1316 
1317     public void send_deleteAll(byte[] tableName, byte[] row, byte[] column) throws TException
1318     {
1319       oprot_.writeMessageBegin(new TMessage("deleteAll", TMessageType.CALL, seqid_));
1320       deleteAll_args args = new deleteAll_args();
1321       args.tableName = tableName;
1322       args.row = row;
1323       args.column = column;
1324       args.write(oprot_);
1325       oprot_.writeMessageEnd();
1326       oprot_.getTransport().flush();
1327     }
1328 
1329     public void recv_deleteAll() throws IOError, TException
1330     {
1331       TMessage msg = iprot_.readMessageBegin();
1332       if (msg.type == TMessageType.EXCEPTION) {
1333         TApplicationException x = TApplicationException.read(iprot_);
1334         iprot_.readMessageEnd();
1335         throw x;
1336       }
1337       deleteAll_result result = new deleteAll_result();
1338       result.read(iprot_);
1339       iprot_.readMessageEnd();
1340       if (result.io != null) {
1341         throw result.io;
1342       }
1343       return;
1344     }
1345 
1346     public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException
1347     {
1348       send_deleteAllTs(tableName, row, column, timestamp);
1349       recv_deleteAllTs();
1350     }
1351 
1352     public void send_deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws TException
1353     {
1354       oprot_.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.CALL, seqid_));
1355       deleteAllTs_args args = new deleteAllTs_args();
1356       args.tableName = tableName;
1357       args.row = row;
1358       args.column = column;
1359       args.timestamp = timestamp;
1360       args.write(oprot_);
1361       oprot_.writeMessageEnd();
1362       oprot_.getTransport().flush();
1363     }
1364 
1365     public void recv_deleteAllTs() throws IOError, TException
1366     {
1367       TMessage msg = iprot_.readMessageBegin();
1368       if (msg.type == TMessageType.EXCEPTION) {
1369         TApplicationException x = TApplicationException.read(iprot_);
1370         iprot_.readMessageEnd();
1371         throw x;
1372       }
1373       deleteAllTs_result result = new deleteAllTs_result();
1374       result.read(iprot_);
1375       iprot_.readMessageEnd();
1376       if (result.io != null) {
1377         throw result.io;
1378       }
1379       return;
1380     }
1381 
1382     public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException
1383     {
1384       send_deleteAllRow(tableName, row);
1385       recv_deleteAllRow();
1386     }
1387 
1388     public void send_deleteAllRow(byte[] tableName, byte[] row) throws TException
1389     {
1390       oprot_.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.CALL, seqid_));
1391       deleteAllRow_args args = new deleteAllRow_args();
1392       args.tableName = tableName;
1393       args.row = row;
1394       args.write(oprot_);
1395       oprot_.writeMessageEnd();
1396       oprot_.getTransport().flush();
1397     }
1398 
1399     public void recv_deleteAllRow() throws IOError, TException
1400     {
1401       TMessage msg = iprot_.readMessageBegin();
1402       if (msg.type == TMessageType.EXCEPTION) {
1403         TApplicationException x = TApplicationException.read(iprot_);
1404         iprot_.readMessageEnd();
1405         throw x;
1406       }
1407       deleteAllRow_result result = new deleteAllRow_result();
1408       result.read(iprot_);
1409       iprot_.readMessageEnd();
1410       if (result.io != null) {
1411         throw result.io;
1412       }
1413       return;
1414     }
1415 
1416     public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
1417     {
1418       send_deleteAllRowTs(tableName, row, timestamp);
1419       recv_deleteAllRowTs();
1420     }
1421 
1422     public void send_deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
1423     {
1424       oprot_.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.CALL, seqid_));
1425       deleteAllRowTs_args args = new deleteAllRowTs_args();
1426       args.tableName = tableName;
1427       args.row = row;
1428       args.timestamp = timestamp;
1429       args.write(oprot_);
1430       oprot_.writeMessageEnd();
1431       oprot_.getTransport().flush();
1432     }
1433 
1434     public void recv_deleteAllRowTs() throws IOError, TException
1435     {
1436       TMessage msg = iprot_.readMessageBegin();
1437       if (msg.type == TMessageType.EXCEPTION) {
1438         TApplicationException x = TApplicationException.read(iprot_);
1439         iprot_.readMessageEnd();
1440         throw x;
1441       }
1442       deleteAllRowTs_result result = new deleteAllRowTs_result();
1443       result.read(iprot_);
1444       iprot_.readMessageEnd();
1445       if (result.io != null) {
1446         throw result.io;
1447       }
1448       return;
1449     }
1450 
1451     public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException
1452     {
1453       send_scannerOpen(tableName, startRow, columns);
1454       return recv_scannerOpen();
1455     }
1456 
1457     public void send_scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws TException
1458     {
1459       oprot_.writeMessageBegin(new TMessage("scannerOpen", TMessageType.CALL, seqid_));
1460       scannerOpen_args args = new scannerOpen_args();
1461       args.tableName = tableName;
1462       args.startRow = startRow;
1463       args.columns = columns;
1464       args.write(oprot_);
1465       oprot_.writeMessageEnd();
1466       oprot_.getTransport().flush();
1467     }
1468 
1469     public int recv_scannerOpen() throws IOError, TException
1470     {
1471       TMessage msg = iprot_.readMessageBegin();
1472       if (msg.type == TMessageType.EXCEPTION) {
1473         TApplicationException x = TApplicationException.read(iprot_);
1474         iprot_.readMessageEnd();
1475         throw x;
1476       }
1477       scannerOpen_result result = new scannerOpen_result();
1478       result.read(iprot_);
1479       iprot_.readMessageEnd();
1480       if (result.isSetSuccess()) {
1481         return result.success;
1482       }
1483       if (result.io != null) {
1484         throw result.io;
1485       }
1486       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result");
1487     }
1488 
1489     public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException
1490     {
1491       send_scannerOpenWithStop(tableName, startRow, stopRow, columns);
1492       return recv_scannerOpenWithStop();
1493     }
1494 
1495     public void send_scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws TException
1496     {
1497       oprot_.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.CALL, seqid_));
1498       scannerOpenWithStop_args args = new scannerOpenWithStop_args();
1499       args.tableName = tableName;
1500       args.startRow = startRow;
1501       args.stopRow = stopRow;
1502       args.columns = columns;
1503       args.write(oprot_);
1504       oprot_.writeMessageEnd();
1505       oprot_.getTransport().flush();
1506     }
1507 
1508     public int recv_scannerOpenWithStop() throws IOError, TException
1509     {
1510       TMessage msg = iprot_.readMessageBegin();
1511       if (msg.type == TMessageType.EXCEPTION) {
1512         TApplicationException x = TApplicationException.read(iprot_);
1513         iprot_.readMessageEnd();
1514         throw x;
1515       }
1516       scannerOpenWithStop_result result = new scannerOpenWithStop_result();
1517       result.read(iprot_);
1518       iprot_.readMessageEnd();
1519       if (result.isSetSuccess()) {
1520         return result.success;
1521       }
1522       if (result.io != null) {
1523         throw result.io;
1524       }
1525       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
1526     }
1527 
1528     public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException
1529     {
1530       send_scannerOpenWithPrefix(tableName, startAndPrefix, columns);
1531       return recv_scannerOpenWithPrefix();
1532     }
1533 
1534     public void send_scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws TException
1535     {
1536       oprot_.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.CALL, seqid_));
1537       scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
1538       args.tableName = tableName;
1539       args.startAndPrefix = startAndPrefix;
1540       args.columns = columns;
1541       args.write(oprot_);
1542       oprot_.writeMessageEnd();
1543       oprot_.getTransport().flush();
1544     }
1545 
1546     public int recv_scannerOpenWithPrefix() throws IOError, TException
1547     {
1548       TMessage msg = iprot_.readMessageBegin();
1549       if (msg.type == TMessageType.EXCEPTION) {
1550         TApplicationException x = TApplicationException.read(iprot_);
1551         iprot_.readMessageEnd();
1552         throw x;
1553       }
1554       scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
1555       result.read(iprot_);
1556       iprot_.readMessageEnd();
1557       if (result.isSetSuccess()) {
1558         return result.success;
1559       }
1560       if (result.io != null) {
1561         throw result.io;
1562       }
1563       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
1564     }
1565 
1566     public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException
1567     {
1568       send_scannerOpenTs(tableName, startRow, columns, timestamp);
1569       return recv_scannerOpenTs();
1570     }
1571 
1572     public void send_scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws TException
1573     {
1574       oprot_.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.CALL, seqid_));
1575       scannerOpenTs_args args = new scannerOpenTs_args();
1576       args.tableName = tableName;
1577       args.startRow = startRow;
1578       args.columns = columns;
1579       args.timestamp = timestamp;
1580       args.write(oprot_);
1581       oprot_.writeMessageEnd();
1582       oprot_.getTransport().flush();
1583     }
1584 
1585     public int recv_scannerOpenTs() throws IOError, TException
1586     {
1587       TMessage msg = iprot_.readMessageBegin();
1588       if (msg.type == TMessageType.EXCEPTION) {
1589         TApplicationException x = TApplicationException.read(iprot_);
1590         iprot_.readMessageEnd();
1591         throw x;
1592       }
1593       scannerOpenTs_result result = new scannerOpenTs_result();
1594       result.read(iprot_);
1595       iprot_.readMessageEnd();
1596       if (result.isSetSuccess()) {
1597         return result.success;
1598       }
1599       if (result.io != null) {
1600         throw result.io;
1601       }
1602       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result");
1603     }
1604 
1605     public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException
1606     {
1607       send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
1608       return recv_scannerOpenWithStopTs();
1609     }
1610 
1611     public void send_scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws TException
1612     {
1613       oprot_.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.CALL, seqid_));
1614       scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
1615       args.tableName = tableName;
1616       args.startRow = startRow;
1617       args.stopRow = stopRow;
1618       args.columns = columns;
1619       args.timestamp = timestamp;
1620       args.write(oprot_);
1621       oprot_.writeMessageEnd();
1622       oprot_.getTransport().flush();
1623     }
1624 
1625     public int recv_scannerOpenWithStopTs() throws IOError, TException
1626     {
1627       TMessage msg = iprot_.readMessageBegin();
1628       if (msg.type == TMessageType.EXCEPTION) {
1629         TApplicationException x = TApplicationException.read(iprot_);
1630         iprot_.readMessageEnd();
1631         throw x;
1632       }
1633       scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
1634       result.read(iprot_);
1635       iprot_.readMessageEnd();
1636       if (result.isSetSuccess()) {
1637         return result.success;
1638       }
1639       if (result.io != null) {
1640         throw result.io;
1641       }
1642       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
1643     }
1644 
1645     public List<TRowResult> scannerGet(int id) throws IOError, IllegalArgument, TException
1646     {
1647       send_scannerGet(id);
1648       return recv_scannerGet();
1649     }
1650 
1651     public void send_scannerGet(int id) throws TException
1652     {
1653       oprot_.writeMessageBegin(new TMessage("scannerGet", TMessageType.CALL, seqid_));
1654       scannerGet_args args = new scannerGet_args();
1655       args.id = id;
1656       args.write(oprot_);
1657       oprot_.writeMessageEnd();
1658       oprot_.getTransport().flush();
1659     }
1660 
1661     public List<TRowResult> recv_scannerGet() throws IOError, IllegalArgument, TException
1662     {
1663       TMessage msg = iprot_.readMessageBegin();
1664       if (msg.type == TMessageType.EXCEPTION) {
1665         TApplicationException x = TApplicationException.read(iprot_);
1666         iprot_.readMessageEnd();
1667         throw x;
1668       }
1669       scannerGet_result result = new scannerGet_result();
1670       result.read(iprot_);
1671       iprot_.readMessageEnd();
1672       if (result.isSetSuccess()) {
1673         return result.success;
1674       }
1675       if (result.io != null) {
1676         throw result.io;
1677       }
1678       if (result.ia != null) {
1679         throw result.ia;
1680       }
1681       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGet failed: unknown result");
1682     }
1683 
1684     public List<TRowResult> scannerGetList(int id, int nbRows) throws IOError, IllegalArgument, TException
1685     {
1686       send_scannerGetList(id, nbRows);
1687       return recv_scannerGetList();
1688     }
1689 
1690     public void send_scannerGetList(int id, int nbRows) throws TException
1691     {
1692       oprot_.writeMessageBegin(new TMessage("scannerGetList", TMessageType.CALL, seqid_));
1693       scannerGetList_args args = new scannerGetList_args();
1694       args.id = id;
1695       args.nbRows = nbRows;
1696       args.write(oprot_);
1697       oprot_.writeMessageEnd();
1698       oprot_.getTransport().flush();
1699     }
1700 
1701     public List<TRowResult> recv_scannerGetList() throws IOError, IllegalArgument, TException
1702     {
1703       TMessage msg = iprot_.readMessageBegin();
1704       if (msg.type == TMessageType.EXCEPTION) {
1705         TApplicationException x = TApplicationException.read(iprot_);
1706         iprot_.readMessageEnd();
1707         throw x;
1708       }
1709       scannerGetList_result result = new scannerGetList_result();
1710       result.read(iprot_);
1711       iprot_.readMessageEnd();
1712       if (result.isSetSuccess()) {
1713         return result.success;
1714       }
1715       if (result.io != null) {
1716         throw result.io;
1717       }
1718       if (result.ia != null) {
1719         throw result.ia;
1720       }
1721       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerGetList failed: unknown result");
1722     }
1723 
1724     public void scannerClose(int id) throws IOError, IllegalArgument, TException
1725     {
1726       send_scannerClose(id);
1727       recv_scannerClose();
1728     }
1729 
1730     public void send_scannerClose(int id) throws TException
1731     {
1732       oprot_.writeMessageBegin(new TMessage("scannerClose", TMessageType.CALL, seqid_));
1733       scannerClose_args args = new scannerClose_args();
1734       args.id = id;
1735       args.write(oprot_);
1736       oprot_.writeMessageEnd();
1737       oprot_.getTransport().flush();
1738     }
1739 
1740     public void recv_scannerClose() throws IOError, IllegalArgument, TException
1741     {
1742       TMessage msg = iprot_.readMessageBegin();
1743       if (msg.type == TMessageType.EXCEPTION) {
1744         TApplicationException x = TApplicationException.read(iprot_);
1745         iprot_.readMessageEnd();
1746         throw x;
1747       }
1748       scannerClose_result result = new scannerClose_result();
1749       result.read(iprot_);
1750       iprot_.readMessageEnd();
1751       if (result.io != null) {
1752         throw result.io;
1753       }
1754       if (result.ia != null) {
1755         throw result.ia;
1756       }
1757       return;
1758     }
1759 
1760   }
1761   public static class Processor implements TProcessor {
1762     private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1763     public Processor(Iface iface)
1764     {
1765       iface_ = iface;
1766       processMap_.put("enableTable", new enableTable());
1767       processMap_.put("disableTable", new disableTable());
1768       processMap_.put("isTableEnabled", new isTableEnabled());
1769       processMap_.put("compact", new compact());
1770       processMap_.put("majorCompact", new majorCompact());
1771       processMap_.put("getTableNames", new getTableNames());
1772       processMap_.put("getColumnDescriptors", new getColumnDescriptors());
1773       processMap_.put("getTableRegions", new getTableRegions());
1774       processMap_.put("createTable", new createTable());
1775       processMap_.put("deleteTable", new deleteTable());
1776       processMap_.put("get", new get());
1777       processMap_.put("getVer", new getVer());
1778       processMap_.put("getVerTs", new getVerTs());
1779       processMap_.put("getRow", new getRow());
1780       processMap_.put("getRowWithColumns", new getRowWithColumns());
1781       processMap_.put("getRowTs", new getRowTs());
1782       processMap_.put("getRowWithColumnsTs", new getRowWithColumnsTs());
1783       processMap_.put("mutateRow", new mutateRow());
1784       processMap_.put("mutateRowTs", new mutateRowTs());
1785       processMap_.put("mutateRows", new mutateRows());
1786       processMap_.put("mutateRowsTs", new mutateRowsTs());
1787       processMap_.put("atomicIncrement", new atomicIncrement());
1788       processMap_.put("deleteAll", new deleteAll());
1789       processMap_.put("deleteAllTs", new deleteAllTs());
1790       processMap_.put("deleteAllRow", new deleteAllRow());
1791       processMap_.put("deleteAllRowTs", new deleteAllRowTs());
1792       processMap_.put("scannerOpen", new scannerOpen());
1793       processMap_.put("scannerOpenWithStop", new scannerOpenWithStop());
1794       processMap_.put("scannerOpenWithPrefix", new scannerOpenWithPrefix());
1795       processMap_.put("scannerOpenTs", new scannerOpenTs());
1796       processMap_.put("scannerOpenWithStopTs", new scannerOpenWithStopTs());
1797       processMap_.put("scannerGet", new scannerGet());
1798       processMap_.put("scannerGetList", new scannerGetList());
1799       processMap_.put("scannerClose", new scannerClose());
1800     }
1801 
1802     protected static interface ProcessFunction {
1803       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException;
1804     }
1805 
1806     private Iface iface_;
1807     protected final HashMap<String,ProcessFunction> processMap_ = new HashMap<String,ProcessFunction>();
1808 
1809     public boolean process(TProtocol iprot, TProtocol oprot) throws TException
1810     {
1811       TMessage msg = iprot.readMessageBegin();
1812       ProcessFunction fn = processMap_.get(msg.name);
1813       if (fn == null) {
1814         TProtocolUtil.skip(iprot, TType.STRUCT);
1815         iprot.readMessageEnd();
1816         TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'");
1817         oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));
1818         x.write(oprot);
1819         oprot.writeMessageEnd();
1820         oprot.getTransport().flush();
1821         return true;
1822       }
1823       fn.process(msg.seqid, iprot, oprot);
1824       return true;
1825     }
1826 
1827     private class enableTable implements ProcessFunction {
1828       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1829       {
1830         enableTable_args args = new enableTable_args();
1831         args.read(iprot);
1832         iprot.readMessageEnd();
1833         enableTable_result result = new enableTable_result();
1834         try {
1835           iface_.enableTable(args.tableName);
1836         } catch (IOError io) {
1837           result.io = io;
1838         } catch (Throwable th) {
1839           LOGGER.error("Internal error processing enableTable", th);
1840           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing enableTable");
1841           oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.EXCEPTION, seqid));
1842           x.write(oprot);
1843           oprot.writeMessageEnd();
1844           oprot.getTransport().flush();
1845           return;
1846         }
1847         oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.REPLY, seqid));
1848         result.write(oprot);
1849         oprot.writeMessageEnd();
1850         oprot.getTransport().flush();
1851       }
1852 
1853     }
1854 
1855     private class disableTable implements ProcessFunction {
1856       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1857       {
1858         disableTable_args args = new disableTable_args();
1859         args.read(iprot);
1860         iprot.readMessageEnd();
1861         disableTable_result result = new disableTable_result();
1862         try {
1863           iface_.disableTable(args.tableName);
1864         } catch (IOError io) {
1865           result.io = io;
1866         } catch (Throwable th) {
1867           LOGGER.error("Internal error processing disableTable", th);
1868           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing disableTable");
1869           oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.EXCEPTION, seqid));
1870           x.write(oprot);
1871           oprot.writeMessageEnd();
1872           oprot.getTransport().flush();
1873           return;
1874         }
1875         oprot.writeMessageBegin(new TMessage("disableTable", TMessageType.REPLY, seqid));
1876         result.write(oprot);
1877         oprot.writeMessageEnd();
1878         oprot.getTransport().flush();
1879       }
1880 
1881     }
1882 
1883     private class isTableEnabled implements ProcessFunction {
1884       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1885       {
1886         isTableEnabled_args args = new isTableEnabled_args();
1887         args.read(iprot);
1888         iprot.readMessageEnd();
1889         isTableEnabled_result result = new isTableEnabled_result();
1890         try {
1891           result.success = iface_.isTableEnabled(args.tableName);
1892           result.setSuccessIsSet(true);
1893         } catch (IOError io) {
1894           result.io = io;
1895         } catch (Throwable th) {
1896           LOGGER.error("Internal error processing isTableEnabled", th);
1897           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing isTableEnabled");
1898           oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.EXCEPTION, seqid));
1899           x.write(oprot);
1900           oprot.writeMessageEnd();
1901           oprot.getTransport().flush();
1902           return;
1903         }
1904         oprot.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.REPLY, seqid));
1905         result.write(oprot);
1906         oprot.writeMessageEnd();
1907         oprot.getTransport().flush();
1908       }
1909 
1910     }
1911 
1912     private class compact implements ProcessFunction {
1913       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1914       {
1915         compact_args args = new compact_args();
1916         args.read(iprot);
1917         iprot.readMessageEnd();
1918         compact_result result = new compact_result();
1919         try {
1920           iface_.compact(args.tableNameOrRegionName);
1921         } catch (IOError io) {
1922           result.io = io;
1923         } catch (Throwable th) {
1924           LOGGER.error("Internal error processing compact", th);
1925           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing compact");
1926           oprot.writeMessageBegin(new TMessage("compact", TMessageType.EXCEPTION, seqid));
1927           x.write(oprot);
1928           oprot.writeMessageEnd();
1929           oprot.getTransport().flush();
1930           return;
1931         }
1932         oprot.writeMessageBegin(new TMessage("compact", TMessageType.REPLY, seqid));
1933         result.write(oprot);
1934         oprot.writeMessageEnd();
1935         oprot.getTransport().flush();
1936       }
1937 
1938     }
1939 
1940     private class majorCompact implements ProcessFunction {
1941       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1942       {
1943         majorCompact_args args = new majorCompact_args();
1944         args.read(iprot);
1945         iprot.readMessageEnd();
1946         majorCompact_result result = new majorCompact_result();
1947         try {
1948           iface_.majorCompact(args.tableNameOrRegionName);
1949         } catch (IOError io) {
1950           result.io = io;
1951         } catch (Throwable th) {
1952           LOGGER.error("Internal error processing majorCompact", th);
1953           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing majorCompact");
1954           oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.EXCEPTION, seqid));
1955           x.write(oprot);
1956           oprot.writeMessageEnd();
1957           oprot.getTransport().flush();
1958           return;
1959         }
1960         oprot.writeMessageBegin(new TMessage("majorCompact", TMessageType.REPLY, seqid));
1961         result.write(oprot);
1962         oprot.writeMessageEnd();
1963         oprot.getTransport().flush();
1964       }
1965 
1966     }
1967 
1968     private class getTableNames implements ProcessFunction {
1969       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1970       {
1971         getTableNames_args args = new getTableNames_args();
1972         args.read(iprot);
1973         iprot.readMessageEnd();
1974         getTableNames_result result = new getTableNames_result();
1975         try {
1976           result.success = iface_.getTableNames();
1977         } catch (IOError io) {
1978           result.io = io;
1979         } catch (Throwable th) {
1980           LOGGER.error("Internal error processing getTableNames", th);
1981           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableNames");
1982           oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.EXCEPTION, seqid));
1983           x.write(oprot);
1984           oprot.writeMessageEnd();
1985           oprot.getTransport().flush();
1986           return;
1987         }
1988         oprot.writeMessageBegin(new TMessage("getTableNames", TMessageType.REPLY, seqid));
1989         result.write(oprot);
1990         oprot.writeMessageEnd();
1991         oprot.getTransport().flush();
1992       }
1993 
1994     }
1995 
1996     private class getColumnDescriptors implements ProcessFunction {
1997       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
1998       {
1999         getColumnDescriptors_args args = new getColumnDescriptors_args();
2000         args.read(iprot);
2001         iprot.readMessageEnd();
2002         getColumnDescriptors_result result = new getColumnDescriptors_result();
2003         try {
2004           result.success = iface_.getColumnDescriptors(args.tableName);
2005         } catch (IOError io) {
2006           result.io = io;
2007         } catch (Throwable th) {
2008           LOGGER.error("Internal error processing getColumnDescriptors", th);
2009           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getColumnDescriptors");
2010           oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.EXCEPTION, seqid));
2011           x.write(oprot);
2012           oprot.writeMessageEnd();
2013           oprot.getTransport().flush();
2014           return;
2015         }
2016         oprot.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.REPLY, seqid));
2017         result.write(oprot);
2018         oprot.writeMessageEnd();
2019         oprot.getTransport().flush();
2020       }
2021 
2022     }
2023 
2024     private class getTableRegions implements ProcessFunction {
2025       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2026       {
2027         getTableRegions_args args = new getTableRegions_args();
2028         args.read(iprot);
2029         iprot.readMessageEnd();
2030         getTableRegions_result result = new getTableRegions_result();
2031         try {
2032           result.success = iface_.getTableRegions(args.tableName);
2033         } catch (IOError io) {
2034           result.io = io;
2035         } catch (Throwable th) {
2036           LOGGER.error("Internal error processing getTableRegions", th);
2037           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTableRegions");
2038           oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.EXCEPTION, seqid));
2039           x.write(oprot);
2040           oprot.writeMessageEnd();
2041           oprot.getTransport().flush();
2042           return;
2043         }
2044         oprot.writeMessageBegin(new TMessage("getTableRegions", TMessageType.REPLY, seqid));
2045         result.write(oprot);
2046         oprot.writeMessageEnd();
2047         oprot.getTransport().flush();
2048       }
2049 
2050     }
2051 
2052     private class createTable implements ProcessFunction {
2053       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2054       {
2055         createTable_args args = new createTable_args();
2056         args.read(iprot);
2057         iprot.readMessageEnd();
2058         createTable_result result = new createTable_result();
2059         try {
2060           iface_.createTable(args.tableName, args.columnFamilies);
2061         } catch (IOError io) {
2062           result.io = io;
2063         } catch (IllegalArgument ia) {
2064           result.ia = ia;
2065         } catch (AlreadyExists exist) {
2066           result.exist = exist;
2067         } catch (Throwable th) {
2068           LOGGER.error("Internal error processing createTable", th);
2069           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing createTable");
2070           oprot.writeMessageBegin(new TMessage("createTable", TMessageType.EXCEPTION, seqid));
2071           x.write(oprot);
2072           oprot.writeMessageEnd();
2073           oprot.getTransport().flush();
2074           return;
2075         }
2076         oprot.writeMessageBegin(new TMessage("createTable", TMessageType.REPLY, seqid));
2077         result.write(oprot);
2078         oprot.writeMessageEnd();
2079         oprot.getTransport().flush();
2080       }
2081 
2082     }
2083 
2084     private class deleteTable implements ProcessFunction {
2085       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2086       {
2087         deleteTable_args args = new deleteTable_args();
2088         args.read(iprot);
2089         iprot.readMessageEnd();
2090         deleteTable_result result = new deleteTable_result();
2091         try {
2092           iface_.deleteTable(args.tableName);
2093         } catch (IOError io) {
2094           result.io = io;
2095         } catch (Throwable th) {
2096           LOGGER.error("Internal error processing deleteTable", th);
2097           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteTable");
2098           oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.EXCEPTION, seqid));
2099           x.write(oprot);
2100           oprot.writeMessageEnd();
2101           oprot.getTransport().flush();
2102           return;
2103         }
2104         oprot.writeMessageBegin(new TMessage("deleteTable", TMessageType.REPLY, seqid));
2105         result.write(oprot);
2106         oprot.writeMessageEnd();
2107         oprot.getTransport().flush();
2108       }
2109 
2110     }
2111 
2112     private class get implements ProcessFunction {
2113       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2114       {
2115         get_args args = new get_args();
2116         args.read(iprot);
2117         iprot.readMessageEnd();
2118         get_result result = new get_result();
2119         try {
2120           result.success = iface_.get(args.tableName, args.row, args.column);
2121         } catch (IOError io) {
2122           result.io = io;
2123         } catch (Throwable th) {
2124           LOGGER.error("Internal error processing get", th);
2125           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing get");
2126           oprot.writeMessageBegin(new TMessage("get", TMessageType.EXCEPTION, seqid));
2127           x.write(oprot);
2128           oprot.writeMessageEnd();
2129           oprot.getTransport().flush();
2130           return;
2131         }
2132         oprot.writeMessageBegin(new TMessage("get", TMessageType.REPLY, seqid));
2133         result.write(oprot);
2134         oprot.writeMessageEnd();
2135         oprot.getTransport().flush();
2136       }
2137 
2138     }
2139 
2140     private class getVer implements ProcessFunction {
2141       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2142       {
2143         getVer_args args = new getVer_args();
2144         args.read(iprot);
2145         iprot.readMessageEnd();
2146         getVer_result result = new getVer_result();
2147         try {
2148           result.success = iface_.getVer(args.tableName, args.row, args.column, args.numVersions);
2149         } catch (IOError io) {
2150           result.io = io;
2151         } catch (Throwable th) {
2152           LOGGER.error("Internal error processing getVer", th);
2153           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVer");
2154           oprot.writeMessageBegin(new TMessage("getVer", TMessageType.EXCEPTION, seqid));
2155           x.write(oprot);
2156           oprot.writeMessageEnd();
2157           oprot.getTransport().flush();
2158           return;
2159         }
2160         oprot.writeMessageBegin(new TMessage("getVer", TMessageType.REPLY, seqid));
2161         result.write(oprot);
2162         oprot.writeMessageEnd();
2163         oprot.getTransport().flush();
2164       }
2165 
2166     }
2167 
2168     private class getVerTs implements ProcessFunction {
2169       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2170       {
2171         getVerTs_args args = new getVerTs_args();
2172         args.read(iprot);
2173         iprot.readMessageEnd();
2174         getVerTs_result result = new getVerTs_result();
2175         try {
2176           result.success = iface_.getVerTs(args.tableName, args.row, args.column, args.timestamp, args.numVersions);
2177         } catch (IOError io) {
2178           result.io = io;
2179         } catch (Throwable th) {
2180           LOGGER.error("Internal error processing getVerTs", th);
2181           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getVerTs");
2182           oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.EXCEPTION, seqid));
2183           x.write(oprot);
2184           oprot.writeMessageEnd();
2185           oprot.getTransport().flush();
2186           return;
2187         }
2188         oprot.writeMessageBegin(new TMessage("getVerTs", TMessageType.REPLY, seqid));
2189         result.write(oprot);
2190         oprot.writeMessageEnd();
2191         oprot.getTransport().flush();
2192       }
2193 
2194     }
2195 
2196     private class getRow implements ProcessFunction {
2197       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2198       {
2199         getRow_args args = new getRow_args();
2200         args.read(iprot);
2201         iprot.readMessageEnd();
2202         getRow_result result = new getRow_result();
2203         try {
2204           result.success = iface_.getRow(args.tableName, args.row);
2205         } catch (IOError io) {
2206           result.io = io;
2207         } catch (Throwable th) {
2208           LOGGER.error("Internal error processing getRow", th);
2209           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRow");
2210           oprot.writeMessageBegin(new TMessage("getRow", TMessageType.EXCEPTION, seqid));
2211           x.write(oprot);
2212           oprot.writeMessageEnd();
2213           oprot.getTransport().flush();
2214           return;
2215         }
2216         oprot.writeMessageBegin(new TMessage("getRow", TMessageType.REPLY, seqid));
2217         result.write(oprot);
2218         oprot.writeMessageEnd();
2219         oprot.getTransport().flush();
2220       }
2221 
2222     }
2223 
2224     private class getRowWithColumns implements ProcessFunction {
2225       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2226       {
2227         getRowWithColumns_args args = new getRowWithColumns_args();
2228         args.read(iprot);
2229         iprot.readMessageEnd();
2230         getRowWithColumns_result result = new getRowWithColumns_result();
2231         try {
2232           result.success = iface_.getRowWithColumns(args.tableName, args.row, args.columns);
2233         } catch (IOError io) {
2234           result.io = io;
2235         } catch (Throwable th) {
2236           LOGGER.error("Internal error processing getRowWithColumns", th);
2237           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumns");
2238           oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.EXCEPTION, seqid));
2239           x.write(oprot);
2240           oprot.writeMessageEnd();
2241           oprot.getTransport().flush();
2242           return;
2243         }
2244         oprot.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.REPLY, seqid));
2245         result.write(oprot);
2246         oprot.writeMessageEnd();
2247         oprot.getTransport().flush();
2248       }
2249 
2250     }
2251 
2252     private class getRowTs implements ProcessFunction {
2253       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2254       {
2255         getRowTs_args args = new getRowTs_args();
2256         args.read(iprot);
2257         iprot.readMessageEnd();
2258         getRowTs_result result = new getRowTs_result();
2259         try {
2260           result.success = iface_.getRowTs(args.tableName, args.row, args.timestamp);
2261         } catch (IOError io) {
2262           result.io = io;
2263         } catch (Throwable th) {
2264           LOGGER.error("Internal error processing getRowTs", th);
2265           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowTs");
2266           oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.EXCEPTION, seqid));
2267           x.write(oprot);
2268           oprot.writeMessageEnd();
2269           oprot.getTransport().flush();
2270           return;
2271         }
2272         oprot.writeMessageBegin(new TMessage("getRowTs", TMessageType.REPLY, seqid));
2273         result.write(oprot);
2274         oprot.writeMessageEnd();
2275         oprot.getTransport().flush();
2276       }
2277 
2278     }
2279 
2280     private class getRowWithColumnsTs implements ProcessFunction {
2281       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2282       {
2283         getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
2284         args.read(iprot);
2285         iprot.readMessageEnd();
2286         getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
2287         try {
2288           result.success = iface_.getRowWithColumnsTs(args.tableName, args.row, args.columns, args.timestamp);
2289         } catch (IOError io) {
2290           result.io = io;
2291         } catch (Throwable th) {
2292           LOGGER.error("Internal error processing getRowWithColumnsTs", th);
2293           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumnsTs");
2294           oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.EXCEPTION, seqid));
2295           x.write(oprot);
2296           oprot.writeMessageEnd();
2297           oprot.getTransport().flush();
2298           return;
2299         }
2300         oprot.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.REPLY, seqid));
2301         result.write(oprot);
2302         oprot.writeMessageEnd();
2303         oprot.getTransport().flush();
2304       }
2305 
2306     }
2307 
2308     private class mutateRow implements ProcessFunction {
2309       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2310       {
2311         mutateRow_args args = new mutateRow_args();
2312         args.read(iprot);
2313         iprot.readMessageEnd();
2314         mutateRow_result result = new mutateRow_result();
2315         try {
2316           iface_.mutateRow(args.tableName, args.row, args.mutations);
2317         } catch (IOError io) {
2318           result.io = io;
2319         } catch (IllegalArgument ia) {
2320           result.ia = ia;
2321         } catch (Throwable th) {
2322           LOGGER.error("Internal error processing mutateRow", th);
2323           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRow");
2324           oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.EXCEPTION, seqid));
2325           x.write(oprot);
2326           oprot.writeMessageEnd();
2327           oprot.getTransport().flush();
2328           return;
2329         }
2330         oprot.writeMessageBegin(new TMessage("mutateRow", TMessageType.REPLY, seqid));
2331         result.write(oprot);
2332         oprot.writeMessageEnd();
2333         oprot.getTransport().flush();
2334       }
2335 
2336     }
2337 
2338     private class mutateRowTs implements ProcessFunction {
2339       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2340       {
2341         mutateRowTs_args args = new mutateRowTs_args();
2342         args.read(iprot);
2343         iprot.readMessageEnd();
2344         mutateRowTs_result result = new mutateRowTs_result();
2345         try {
2346           iface_.mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp);
2347         } catch (IOError io) {
2348           result.io = io;
2349         } catch (IllegalArgument ia) {
2350           result.ia = ia;
2351         } catch (Throwable th) {
2352           LOGGER.error("Internal error processing mutateRowTs", th);
2353           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowTs");
2354           oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.EXCEPTION, seqid));
2355           x.write(oprot);
2356           oprot.writeMessageEnd();
2357           oprot.getTransport().flush();
2358           return;
2359         }
2360         oprot.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.REPLY, seqid));
2361         result.write(oprot);
2362         oprot.writeMessageEnd();
2363         oprot.getTransport().flush();
2364       }
2365 
2366     }
2367 
2368     private class mutateRows implements ProcessFunction {
2369       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2370       {
2371         mutateRows_args args = new mutateRows_args();
2372         args.read(iprot);
2373         iprot.readMessageEnd();
2374         mutateRows_result result = new mutateRows_result();
2375         try {
2376           iface_.mutateRows(args.tableName, args.rowBatches);
2377         } catch (IOError io) {
2378           result.io = io;
2379         } catch (IllegalArgument ia) {
2380           result.ia = ia;
2381         } catch (Throwable th) {
2382           LOGGER.error("Internal error processing mutateRows", th);
2383           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRows");
2384           oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.EXCEPTION, seqid));
2385           x.write(oprot);
2386           oprot.writeMessageEnd();
2387           oprot.getTransport().flush();
2388           return;
2389         }
2390         oprot.writeMessageBegin(new TMessage("mutateRows", TMessageType.REPLY, seqid));
2391         result.write(oprot);
2392         oprot.writeMessageEnd();
2393         oprot.getTransport().flush();
2394       }
2395 
2396     }
2397 
2398     private class mutateRowsTs implements ProcessFunction {
2399       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2400       {
2401         mutateRowsTs_args args = new mutateRowsTs_args();
2402         args.read(iprot);
2403         iprot.readMessageEnd();
2404         mutateRowsTs_result result = new mutateRowsTs_result();
2405         try {
2406           iface_.mutateRowsTs(args.tableName, args.rowBatches, args.timestamp);
2407         } catch (IOError io) {
2408           result.io = io;
2409         } catch (IllegalArgument ia) {
2410           result.ia = ia;
2411         } catch (Throwable th) {
2412           LOGGER.error("Internal error processing mutateRowsTs", th);
2413           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing mutateRowsTs");
2414           oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.EXCEPTION, seqid));
2415           x.write(oprot);
2416           oprot.writeMessageEnd();
2417           oprot.getTransport().flush();
2418           return;
2419         }
2420         oprot.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.REPLY, seqid));
2421         result.write(oprot);
2422         oprot.writeMessageEnd();
2423         oprot.getTransport().flush();
2424       }
2425 
2426     }
2427 
2428     private class atomicIncrement implements ProcessFunction {
2429       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2430       {
2431         atomicIncrement_args args = new atomicIncrement_args();
2432         args.read(iprot);
2433         iprot.readMessageEnd();
2434         atomicIncrement_result result = new atomicIncrement_result();
2435         try {
2436           result.success = iface_.atomicIncrement(args.tableName, args.row, args.column, args.value);
2437           result.setSuccessIsSet(true);
2438         } catch (IOError io) {
2439           result.io = io;
2440         } catch (IllegalArgument ia) {
2441           result.ia = ia;
2442         } catch (Throwable th) {
2443           LOGGER.error("Internal error processing atomicIncrement", th);
2444           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing atomicIncrement");
2445           oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.EXCEPTION, seqid));
2446           x.write(oprot);
2447           oprot.writeMessageEnd();
2448           oprot.getTransport().flush();
2449           return;
2450         }
2451         oprot.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.REPLY, seqid));
2452         result.write(oprot);
2453         oprot.writeMessageEnd();
2454         oprot.getTransport().flush();
2455       }
2456 
2457     }
2458 
2459     private class deleteAll implements ProcessFunction {
2460       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2461       {
2462         deleteAll_args args = new deleteAll_args();
2463         args.read(iprot);
2464         iprot.readMessageEnd();
2465         deleteAll_result result = new deleteAll_result();
2466         try {
2467           iface_.deleteAll(args.tableName, args.row, args.column);
2468         } catch (IOError io) {
2469           result.io = io;
2470         } catch (Throwable th) {
2471           LOGGER.error("Internal error processing deleteAll", th);
2472           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAll");
2473           oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.EXCEPTION, seqid));
2474           x.write(oprot);
2475           oprot.writeMessageEnd();
2476           oprot.getTransport().flush();
2477           return;
2478         }
2479         oprot.writeMessageBegin(new TMessage("deleteAll", TMessageType.REPLY, seqid));
2480         result.write(oprot);
2481         oprot.writeMessageEnd();
2482         oprot.getTransport().flush();
2483       }
2484 
2485     }
2486 
2487     private class deleteAllTs implements ProcessFunction {
2488       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2489       {
2490         deleteAllTs_args args = new deleteAllTs_args();
2491         args.read(iprot);
2492         iprot.readMessageEnd();
2493         deleteAllTs_result result = new deleteAllTs_result();
2494         try {
2495           iface_.deleteAllTs(args.tableName, args.row, args.column, args.timestamp);
2496         } catch (IOError io) {
2497           result.io = io;
2498         } catch (Throwable th) {
2499           LOGGER.error("Internal error processing deleteAllTs", th);
2500           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllTs");
2501           oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.EXCEPTION, seqid));
2502           x.write(oprot);
2503           oprot.writeMessageEnd();
2504           oprot.getTransport().flush();
2505           return;
2506         }
2507         oprot.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.REPLY, seqid));
2508         result.write(oprot);
2509         oprot.writeMessageEnd();
2510         oprot.getTransport().flush();
2511       }
2512 
2513     }
2514 
2515     private class deleteAllRow implements ProcessFunction {
2516       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2517       {
2518         deleteAllRow_args args = new deleteAllRow_args();
2519         args.read(iprot);
2520         iprot.readMessageEnd();
2521         deleteAllRow_result result = new deleteAllRow_result();
2522         try {
2523           iface_.deleteAllRow(args.tableName, args.row);
2524         } catch (IOError io) {
2525           result.io = io;
2526         } catch (Throwable th) {
2527           LOGGER.error("Internal error processing deleteAllRow", th);
2528           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRow");
2529           oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.EXCEPTION, seqid));
2530           x.write(oprot);
2531           oprot.writeMessageEnd();
2532           oprot.getTransport().flush();
2533           return;
2534         }
2535         oprot.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.REPLY, seqid));
2536         result.write(oprot);
2537         oprot.writeMessageEnd();
2538         oprot.getTransport().flush();
2539       }
2540 
2541     }
2542 
2543     private class deleteAllRowTs implements ProcessFunction {
2544       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2545       {
2546         deleteAllRowTs_args args = new deleteAllRowTs_args();
2547         args.read(iprot);
2548         iprot.readMessageEnd();
2549         deleteAllRowTs_result result = new deleteAllRowTs_result();
2550         try {
2551           iface_.deleteAllRowTs(args.tableName, args.row, args.timestamp);
2552         } catch (IOError io) {
2553           result.io = io;
2554         } catch (Throwable th) {
2555           LOGGER.error("Internal error processing deleteAllRowTs", th);
2556           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing deleteAllRowTs");
2557           oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.EXCEPTION, seqid));
2558           x.write(oprot);
2559           oprot.writeMessageEnd();
2560           oprot.getTransport().flush();
2561           return;
2562         }
2563         oprot.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.REPLY, seqid));
2564         result.write(oprot);
2565         oprot.writeMessageEnd();
2566         oprot.getTransport().flush();
2567       }
2568 
2569     }
2570 
2571     private class scannerOpen implements ProcessFunction {
2572       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2573       {
2574         scannerOpen_args args = new scannerOpen_args();
2575         args.read(iprot);
2576         iprot.readMessageEnd();
2577         scannerOpen_result result = new scannerOpen_result();
2578         try {
2579           result.success = iface_.scannerOpen(args.tableName, args.startRow, args.columns);
2580           result.setSuccessIsSet(true);
2581         } catch (IOError io) {
2582           result.io = io;
2583         } catch (Throwable th) {
2584           LOGGER.error("Internal error processing scannerOpen", th);
2585           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpen");
2586           oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.EXCEPTION, seqid));
2587           x.write(oprot);
2588           oprot.writeMessageEnd();
2589           oprot.getTransport().flush();
2590           return;
2591         }
2592         oprot.writeMessageBegin(new TMessage("scannerOpen", TMessageType.REPLY, seqid));
2593         result.write(oprot);
2594         oprot.writeMessageEnd();
2595         oprot.getTransport().flush();
2596       }
2597 
2598     }
2599 
2600     private class scannerOpenWithStop implements ProcessFunction {
2601       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2602       {
2603         scannerOpenWithStop_args args = new scannerOpenWithStop_args();
2604         args.read(iprot);
2605         iprot.readMessageEnd();
2606         scannerOpenWithStop_result result = new scannerOpenWithStop_result();
2607         try {
2608           result.success = iface_.scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns);
2609           result.setSuccessIsSet(true);
2610         } catch (IOError io) {
2611           result.io = io;
2612         } catch (Throwable th) {
2613           LOGGER.error("Internal error processing scannerOpenWithStop", th);
2614           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStop");
2615           oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.EXCEPTION, seqid));
2616           x.write(oprot);
2617           oprot.writeMessageEnd();
2618           oprot.getTransport().flush();
2619           return;
2620         }
2621         oprot.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.REPLY, seqid));
2622         result.write(oprot);
2623         oprot.writeMessageEnd();
2624         oprot.getTransport().flush();
2625       }
2626 
2627     }
2628 
2629     private class scannerOpenWithPrefix implements ProcessFunction {
2630       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2631       {
2632         scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
2633         args.read(iprot);
2634         iprot.readMessageEnd();
2635         scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
2636         try {
2637           result.success = iface_.scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns);
2638           result.setSuccessIsSet(true);
2639         } catch (IOError io) {
2640           result.io = io;
2641         } catch (Throwable th) {
2642           LOGGER.error("Internal error processing scannerOpenWithPrefix", th);
2643           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithPrefix");
2644           oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.EXCEPTION, seqid));
2645           x.write(oprot);
2646           oprot.writeMessageEnd();
2647           oprot.getTransport().flush();
2648           return;
2649         }
2650         oprot.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.REPLY, seqid));
2651         result.write(oprot);
2652         oprot.writeMessageEnd();
2653         oprot.getTransport().flush();
2654       }
2655 
2656     }
2657 
2658     private class scannerOpenTs implements ProcessFunction {
2659       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2660       {
2661         scannerOpenTs_args args = new scannerOpenTs_args();
2662         args.read(iprot);
2663         iprot.readMessageEnd();
2664         scannerOpenTs_result result = new scannerOpenTs_result();
2665         try {
2666           result.success = iface_.scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp);
2667           result.setSuccessIsSet(true);
2668         } catch (IOError io) {
2669           result.io = io;
2670         } catch (Throwable th) {
2671           LOGGER.error("Internal error processing scannerOpenTs", th);
2672           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenTs");
2673           oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.EXCEPTION, seqid));
2674           x.write(oprot);
2675           oprot.writeMessageEnd();
2676           oprot.getTransport().flush();
2677           return;
2678         }
2679         oprot.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.REPLY, seqid));
2680         result.write(oprot);
2681         oprot.writeMessageEnd();
2682         oprot.getTransport().flush();
2683       }
2684 
2685     }
2686 
2687     private class scannerOpenWithStopTs implements ProcessFunction {
2688       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2689       {
2690         scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
2691         args.read(iprot);
2692         iprot.readMessageEnd();
2693         scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
2694         try {
2695           result.success = iface_.scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp);
2696           result.setSuccessIsSet(true);
2697         } catch (IOError io) {
2698           result.io = io;
2699         } catch (Throwable th) {
2700           LOGGER.error("Internal error processing scannerOpenWithStopTs", th);
2701           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerOpenWithStopTs");
2702           oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.EXCEPTION, seqid));
2703           x.write(oprot);
2704           oprot.writeMessageEnd();
2705           oprot.getTransport().flush();
2706           return;
2707         }
2708         oprot.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.REPLY, seqid));
2709         result.write(oprot);
2710         oprot.writeMessageEnd();
2711         oprot.getTransport().flush();
2712       }
2713 
2714     }
2715 
2716     private class scannerGet implements ProcessFunction {
2717       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2718       {
2719         scannerGet_args args = new scannerGet_args();
2720         args.read(iprot);
2721         iprot.readMessageEnd();
2722         scannerGet_result result = new scannerGet_result();
2723         try {
2724           result.success = iface_.scannerGet(args.id);
2725         } catch (IOError io) {
2726           result.io = io;
2727         } catch (IllegalArgument ia) {
2728           result.ia = ia;
2729         } catch (Throwable th) {
2730           LOGGER.error("Internal error processing scannerGet", th);
2731           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGet");
2732           oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.EXCEPTION, seqid));
2733           x.write(oprot);
2734           oprot.writeMessageEnd();
2735           oprot.getTransport().flush();
2736           return;
2737         }
2738         oprot.writeMessageBegin(new TMessage("scannerGet", TMessageType.REPLY, seqid));
2739         result.write(oprot);
2740         oprot.writeMessageEnd();
2741         oprot.getTransport().flush();
2742       }
2743 
2744     }
2745 
2746     private class scannerGetList implements ProcessFunction {
2747       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2748       {
2749         scannerGetList_args args = new scannerGetList_args();
2750         args.read(iprot);
2751         iprot.readMessageEnd();
2752         scannerGetList_result result = new scannerGetList_result();
2753         try {
2754           result.success = iface_.scannerGetList(args.id, args.nbRows);
2755         } catch (IOError io) {
2756           result.io = io;
2757         } catch (IllegalArgument ia) {
2758           result.ia = ia;
2759         } catch (Throwable th) {
2760           LOGGER.error("Internal error processing scannerGetList", th);
2761           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerGetList");
2762           oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.EXCEPTION, seqid));
2763           x.write(oprot);
2764           oprot.writeMessageEnd();
2765           oprot.getTransport().flush();
2766           return;
2767         }
2768         oprot.writeMessageBegin(new TMessage("scannerGetList", TMessageType.REPLY, seqid));
2769         result.write(oprot);
2770         oprot.writeMessageEnd();
2771         oprot.getTransport().flush();
2772       }
2773 
2774     }
2775 
2776     private class scannerClose implements ProcessFunction {
2777       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2778       {
2779         scannerClose_args args = new scannerClose_args();
2780         args.read(iprot);
2781         iprot.readMessageEnd();
2782         scannerClose_result result = new scannerClose_result();
2783         try {
2784           iface_.scannerClose(args.id);
2785         } catch (IOError io) {
2786           result.io = io;
2787         } catch (IllegalArgument ia) {
2788           result.ia = ia;
2789         } catch (Throwable th) {
2790           LOGGER.error("Internal error processing scannerClose", th);
2791           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing scannerClose");
2792           oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.EXCEPTION, seqid));
2793           x.write(oprot);
2794           oprot.writeMessageEnd();
2795           oprot.getTransport().flush();
2796           return;
2797         }
2798         oprot.writeMessageBegin(new TMessage("scannerClose", TMessageType.REPLY, seqid));
2799         result.write(oprot);
2800         oprot.writeMessageEnd();
2801         oprot.getTransport().flush();
2802       }
2803 
2804     }
2805 
2806   }
2807 
2808   public static class enableTable_args implements TBase<enableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_args>   {
2809     private static final TStruct STRUCT_DESC = new TStruct("enableTable_args");
2810 
2811     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
2812 
2813     /**
2814      * name of the table
2815      */
2816     public byte[] tableName;
2817 
2818     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
2819     public enum _Fields implements TFieldIdEnum {
2820       /**
2821        * name of the table
2822        */
2823       TABLE_NAME((short)1, "tableName");
2824 
2825       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
2826       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
2827 
2828       static {
2829         for (_Fields field : EnumSet.allOf(_Fields.class)) {
2830           byId.put((int)field._thriftId, field);
2831           byName.put(field.getFieldName(), field);
2832         }
2833       }
2834 
2835       /**
2836        * Find the _Fields constant that matches fieldId, or null if its not found.
2837        */
2838       public static _Fields findByThriftId(int fieldId) {
2839         return byId.get(fieldId);
2840       }
2841 
2842       /**
2843        * Find the _Fields constant that matches fieldId, throwing an exception
2844        * if it is not found.
2845        */
2846       public static _Fields findByThriftIdOrThrow(int fieldId) {
2847         _Fields fields = findByThriftId(fieldId);
2848         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
2849         return fields;
2850       }
2851 
2852       /**
2853        * Find the _Fields constant that matches name, or null if its not found.
2854        */
2855       public static _Fields findByName(String name) {
2856         return byName.get(name);
2857       }
2858 
2859       private final short _thriftId;
2860       private final String _fieldName;
2861 
2862       _Fields(short thriftId, String fieldName) {
2863         _thriftId = thriftId;
2864         _fieldName = fieldName;
2865       }
2866 
2867       public short getThriftFieldId() {
2868         return _thriftId;
2869       }
2870 
2871       public String getFieldName() {
2872         return _fieldName;
2873       }
2874     }
2875 
2876     // isset id assignments
2877 
2878     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
2879       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
2880           new FieldValueMetaData(TType.STRING)));
2881     }});
2882 
2883     static {
2884       FieldMetaData.addStructMetaDataMap(enableTable_args.class, metaDataMap);
2885     }
2886 
2887     public enableTable_args() {
2888     }
2889 
2890     public enableTable_args(
2891       byte[] tableName)
2892     {
2893       this();
2894       this.tableName = tableName;
2895     }
2896 
2897     /**
2898      * Performs a deep copy on <i>other</i>.
2899      */
2900     public enableTable_args(enableTable_args other) {
2901       if (other.isSetTableName()) {
2902         this.tableName = other.tableName;
2903       }
2904     }
2905 
2906     public enableTable_args deepCopy() {
2907       return new enableTable_args(this);
2908     }
2909 
2910     @Deprecated
2911     public enableTable_args clone() {
2912       return new enableTable_args(this);
2913     }
2914 
2915     /**
2916      * name of the table
2917      */
2918     public byte[] getTableName() {
2919       return this.tableName;
2920     }
2921 
2922     /**
2923      * name of the table
2924      */
2925     public enableTable_args setTableName(byte[] tableName) {
2926       this.tableName = tableName;
2927       return this;
2928     }
2929 
2930     public void unsetTableName() {
2931       this.tableName = null;
2932     }
2933 
2934     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
2935     public boolean isSetTableName() {
2936       return this.tableName != null;
2937     }
2938 
2939     public void setTableNameIsSet(boolean value) {
2940       if (!value) {
2941         this.tableName = null;
2942       }
2943     }
2944 
2945     public void setFieldValue(_Fields field, Object value) {
2946       switch (field) {
2947       case TABLE_NAME:
2948         if (value == null) {
2949           unsetTableName();
2950         } else {
2951           setTableName((byte[])value);
2952         }
2953         break;
2954 
2955       }
2956     }
2957 
2958     public void setFieldValue(int fieldID, Object value) {
2959       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
2960     }
2961 
2962     public Object getFieldValue(_Fields field) {
2963       switch (field) {
2964       case TABLE_NAME:
2965         return getTableName();
2966 
2967       }
2968       throw new IllegalStateException();
2969     }
2970 
2971     public Object getFieldValue(int fieldId) {
2972       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
2973     }
2974 
2975     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
2976     public boolean isSet(_Fields field) {
2977       switch (field) {
2978       case TABLE_NAME:
2979         return isSetTableName();
2980       }
2981       throw new IllegalStateException();
2982     }
2983 
2984     public boolean isSet(int fieldID) {
2985       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
2986     }
2987 
2988     @Override
2989     public boolean equals(Object that) {
2990       if (that == null)
2991         return false;
2992       if (that instanceof enableTable_args)
2993         return this.equals((enableTable_args)that);
2994       return false;
2995     }
2996 
2997     public boolean equals(enableTable_args that) {
2998       if (that == null)
2999         return false;
3000 
3001       boolean this_present_tableName = true && this.isSetTableName();
3002       boolean that_present_tableName = true && that.isSetTableName();
3003       if (this_present_tableName || that_present_tableName) {
3004         if (!(this_present_tableName && that_present_tableName))
3005           return false;
3006         if (!java.util.Arrays.equals(this.tableName, that.tableName))
3007           return false;
3008       }
3009 
3010       return true;
3011     }
3012 
3013     @Override
3014     public int hashCode() {
3015       HashCodeBuilder builder = new HashCodeBuilder();
3016 
3017       boolean present_tableName = true && (isSetTableName());
3018       builder.append(present_tableName);
3019       if (present_tableName)
3020         builder.append(tableName);
3021 
3022       return builder.toHashCode();
3023     }
3024 
3025     public int compareTo(enableTable_args other) {
3026       if (!getClass().equals(other.getClass())) {
3027         return getClass().getName().compareTo(other.getClass().getName());
3028       }
3029 
3030       int lastComparison = 0;
3031       enableTable_args typedOther = (enableTable_args)other;
3032 
3033       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
3034       if (lastComparison != 0) {
3035         return lastComparison;
3036       }
3037       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
3038       if (lastComparison != 0) {
3039         return lastComparison;
3040       }
3041       return 0;
3042     }
3043 
3044     public void read(TProtocol iprot) throws TException {
3045       TField field;
3046       iprot.readStructBegin();
3047       while (true)
3048       {
3049         field = iprot.readFieldBegin();
3050         if (field.type == TType.STOP) {
3051           break;
3052         }
3053         _Fields fieldId = _Fields.findByThriftId(field.id);
3054         if (fieldId == null) {
3055           TProtocolUtil.skip(iprot, field.type);
3056         } else {
3057           switch (fieldId) {
3058             case TABLE_NAME:
3059               if (field.type == TType.STRING) {
3060                 this.tableName = iprot.readBinary();
3061               } else {
3062                 TProtocolUtil.skip(iprot, field.type);
3063               }
3064               break;
3065           }
3066           iprot.readFieldEnd();
3067         }
3068       }
3069       iprot.readStructEnd();
3070 
3071       // check for required fields of primitive type, which can't be checked in the validate method
3072       validate();
3073     }
3074 
3075     public void write(TProtocol oprot) throws TException {
3076       validate();
3077 
3078       oprot.writeStructBegin(STRUCT_DESC);
3079       if (this.tableName != null) {
3080         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
3081         oprot.writeBinary(this.tableName);
3082         oprot.writeFieldEnd();
3083       }
3084       oprot.writeFieldStop();
3085       oprot.writeStructEnd();
3086     }
3087 
3088     @Override
3089     public String toString() {
3090       StringBuilder sb = new StringBuilder("enableTable_args(");
3091       boolean first = true;
3092 
3093       sb.append("tableName:");
3094       if (this.tableName == null) {
3095         sb.append("null");
3096       } else {
3097         sb.append(this.tableName);
3098       }
3099       first = false;
3100       sb.append(")");
3101       return sb.toString();
3102     }
3103 
3104     public void validate() throws TException {
3105       // check for required fields
3106     }
3107 
3108   }
3109 
3110   public static class enableTable_result implements TBase<enableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<enableTable_result>   {
3111     private static final TStruct STRUCT_DESC = new TStruct("enableTable_result");
3112 
3113     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
3114 
3115     public IOError io;
3116 
3117     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
3118     public enum _Fields implements TFieldIdEnum {
3119       IO((short)1, "io");
3120 
3121       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3122       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3123 
3124       static {
3125         for (_Fields field : EnumSet.allOf(_Fields.class)) {
3126           byId.put((int)field._thriftId, field);
3127           byName.put(field.getFieldName(), field);
3128         }
3129       }
3130 
3131       /**
3132        * Find the _Fields constant that matches fieldId, or null if its not found.
3133        */
3134       public static _Fields findByThriftId(int fieldId) {
3135         return byId.get(fieldId);
3136       }
3137 
3138       /**
3139        * Find the _Fields constant that matches fieldId, throwing an exception
3140        * if it is not found.
3141        */
3142       public static _Fields findByThriftIdOrThrow(int fieldId) {
3143         _Fields fields = findByThriftId(fieldId);
3144         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3145         return fields;
3146       }
3147 
3148       /**
3149        * Find the _Fields constant that matches name, or null if its not found.
3150        */
3151       public static _Fields findByName(String name) {
3152         return byName.get(name);
3153       }
3154 
3155       private final short _thriftId;
3156       private final String _fieldName;
3157 
3158       _Fields(short thriftId, String fieldName) {
3159         _thriftId = thriftId;
3160         _fieldName = fieldName;
3161       }
3162 
3163       public short getThriftFieldId() {
3164         return _thriftId;
3165       }
3166 
3167       public String getFieldName() {
3168         return _fieldName;
3169       }
3170     }
3171 
3172     // isset id assignments
3173 
3174     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3175       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
3176           new FieldValueMetaData(TType.STRUCT)));
3177     }});
3178 
3179     static {
3180       FieldMetaData.addStructMetaDataMap(enableTable_result.class, metaDataMap);
3181     }
3182 
3183     public enableTable_result() {
3184     }
3185 
3186     public enableTable_result(
3187       IOError io)
3188     {
3189       this();
3190       this.io = io;
3191     }
3192 
3193     /**
3194      * Performs a deep copy on <i>other</i>.
3195      */
3196     public enableTable_result(enableTable_result other) {
3197       if (other.isSetIo()) {
3198         this.io = new IOError(other.io);
3199       }
3200     }
3201 
3202     public enableTable_result deepCopy() {
3203       return new enableTable_result(this);
3204     }
3205 
3206     @Deprecated
3207     public enableTable_result clone() {
3208       return new enableTable_result(this);
3209     }
3210 
3211     public IOError getIo() {
3212       return this.io;
3213     }
3214 
3215     public enableTable_result setIo(IOError io) {
3216       this.io = io;
3217       return this;
3218     }
3219 
3220     public void unsetIo() {
3221       this.io = null;
3222     }
3223 
3224     /** Returns true if field io is set (has been asigned a value) and false otherwise */
3225     public boolean isSetIo() {
3226       return this.io != null;
3227     }
3228 
3229     public void setIoIsSet(boolean value) {
3230       if (!value) {
3231         this.io = null;
3232       }
3233     }
3234 
3235     public void setFieldValue(_Fields field, Object value) {
3236       switch (field) {
3237       case IO:
3238         if (value == null) {
3239           unsetIo();
3240         } else {
3241           setIo((IOError)value);
3242         }
3243         break;
3244 
3245       }
3246     }
3247 
3248     public void setFieldValue(int fieldID, Object value) {
3249       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3250     }
3251 
3252     public Object getFieldValue(_Fields field) {
3253       switch (field) {
3254       case IO:
3255         return getIo();
3256 
3257       }
3258       throw new IllegalStateException();
3259     }
3260 
3261     public Object getFieldValue(int fieldId) {
3262       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3263     }
3264 
3265     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
3266     public boolean isSet(_Fields field) {
3267       switch (field) {
3268       case IO:
3269         return isSetIo();
3270       }
3271       throw new IllegalStateException();
3272     }
3273 
3274     public boolean isSet(int fieldID) {
3275       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3276     }
3277 
3278     @Override
3279     public boolean equals(Object that) {
3280       if (that == null)
3281         return false;
3282       if (that instanceof enableTable_result)
3283         return this.equals((enableTable_result)that);
3284       return false;
3285     }
3286 
3287     public boolean equals(enableTable_result that) {
3288       if (that == null)
3289         return false;
3290 
3291       boolean this_present_io = true && this.isSetIo();
3292       boolean that_present_io = true && that.isSetIo();
3293       if (this_present_io || that_present_io) {
3294         if (!(this_present_io && that_present_io))
3295           return false;
3296         if (!this.io.equals(that.io))
3297           return false;
3298       }
3299 
3300       return true;
3301     }
3302 
3303     @Override
3304     public int hashCode() {
3305       HashCodeBuilder builder = new HashCodeBuilder();
3306 
3307       boolean present_io = true && (isSetIo());
3308       builder.append(present_io);
3309       if (present_io)
3310         builder.append(io);
3311 
3312       return builder.toHashCode();
3313     }
3314 
3315     public int compareTo(enableTable_result other) {
3316       if (!getClass().equals(other.getClass())) {
3317         return getClass().getName().compareTo(other.getClass().getName());
3318       }
3319 
3320       int lastComparison = 0;
3321       enableTable_result typedOther = (enableTable_result)other;
3322 
3323       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
3324       if (lastComparison != 0) {
3325         return lastComparison;
3326       }
3327       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
3328       if (lastComparison != 0) {
3329         return lastComparison;
3330       }
3331       return 0;
3332     }
3333 
3334     public void read(TProtocol iprot) throws TException {
3335       TField field;
3336       iprot.readStructBegin();
3337       while (true)
3338       {
3339         field = iprot.readFieldBegin();
3340         if (field.type == TType.STOP) {
3341           break;
3342         }
3343         _Fields fieldId = _Fields.findByThriftId(field.id);
3344         if (fieldId == null) {
3345           TProtocolUtil.skip(iprot, field.type);
3346         } else {
3347           switch (fieldId) {
3348             case IO:
3349               if (field.type == TType.STRUCT) {
3350                 this.io = new IOError();
3351                 this.io.read(iprot);
3352               } else {
3353                 TProtocolUtil.skip(iprot, field.type);
3354               }
3355               break;
3356           }
3357           iprot.readFieldEnd();
3358         }
3359       }
3360       iprot.readStructEnd();
3361 
3362       // check for required fields of primitive type, which can't be checked in the validate method
3363       validate();
3364     }
3365 
3366     public void write(TProtocol oprot) throws TException {
3367       oprot.writeStructBegin(STRUCT_DESC);
3368 
3369       if (this.isSetIo()) {
3370         oprot.writeFieldBegin(IO_FIELD_DESC);
3371         this.io.write(oprot);
3372         oprot.writeFieldEnd();
3373       }
3374       oprot.writeFieldStop();
3375       oprot.writeStructEnd();
3376     }
3377 
3378     @Override
3379     public String toString() {
3380       StringBuilder sb = new StringBuilder("enableTable_result(");
3381       boolean first = true;
3382 
3383       sb.append("io:");
3384       if (this.io == null) {
3385         sb.append("null");
3386       } else {
3387         sb.append(this.io);
3388       }
3389       first = false;
3390       sb.append(")");
3391       return sb.toString();
3392     }
3393 
3394     public void validate() throws TException {
3395       // check for required fields
3396     }
3397 
3398   }
3399 
3400   public static class disableTable_args implements TBase<disableTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_args>   {
3401     private static final TStruct STRUCT_DESC = new TStruct("disableTable_args");
3402 
3403     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
3404 
3405     /**
3406      * name of the table
3407      */
3408     public byte[] tableName;
3409 
3410     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
3411     public enum _Fields implements TFieldIdEnum {
3412       /**
3413        * name of the table
3414        */
3415       TABLE_NAME((short)1, "tableName");
3416 
3417       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3418       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3419 
3420       static {
3421         for (_Fields field : EnumSet.allOf(_Fields.class)) {
3422           byId.put((int)field._thriftId, field);
3423           byName.put(field.getFieldName(), field);
3424         }
3425       }
3426 
3427       /**
3428        * Find the _Fields constant that matches fieldId, or null if its not found.
3429        */
3430       public static _Fields findByThriftId(int fieldId) {
3431         return byId.get(fieldId);
3432       }
3433 
3434       /**
3435        * Find the _Fields constant that matches fieldId, throwing an exception
3436        * if it is not found.
3437        */
3438       public static _Fields findByThriftIdOrThrow(int fieldId) {
3439         _Fields fields = findByThriftId(fieldId);
3440         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3441         return fields;
3442       }
3443 
3444       /**
3445        * Find the _Fields constant that matches name, or null if its not found.
3446        */
3447       public static _Fields findByName(String name) {
3448         return byName.get(name);
3449       }
3450 
3451       private final short _thriftId;
3452       private final String _fieldName;
3453 
3454       _Fields(short thriftId, String fieldName) {
3455         _thriftId = thriftId;
3456         _fieldName = fieldName;
3457       }
3458 
3459       public short getThriftFieldId() {
3460         return _thriftId;
3461       }
3462 
3463       public String getFieldName() {
3464         return _fieldName;
3465       }
3466     }
3467 
3468     // isset id assignments
3469 
3470     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3471       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
3472           new FieldValueMetaData(TType.STRING)));
3473     }});
3474 
3475     static {
3476       FieldMetaData.addStructMetaDataMap(disableTable_args.class, metaDataMap);
3477     }
3478 
3479     public disableTable_args() {
3480     }
3481 
3482     public disableTable_args(
3483       byte[] tableName)
3484     {
3485       this();
3486       this.tableName = tableName;
3487     }
3488 
3489     /**
3490      * Performs a deep copy on <i>other</i>.
3491      */
3492     public disableTable_args(disableTable_args other) {
3493       if (other.isSetTableName()) {
3494         this.tableName = other.tableName;
3495       }
3496     }
3497 
3498     public disableTable_args deepCopy() {
3499       return new disableTable_args(this);
3500     }
3501 
3502     @Deprecated
3503     public disableTable_args clone() {
3504       return new disableTable_args(this);
3505     }
3506 
3507     /**
3508      * name of the table
3509      */
3510     public byte[] getTableName() {
3511       return this.tableName;
3512     }
3513 
3514     /**
3515      * name of the table
3516      */
3517     public disableTable_args setTableName(byte[] tableName) {
3518       this.tableName = tableName;
3519       return this;
3520     }
3521 
3522     public void unsetTableName() {
3523       this.tableName = null;
3524     }
3525 
3526     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
3527     public boolean isSetTableName() {
3528       return this.tableName != null;
3529     }
3530 
3531     public void setTableNameIsSet(boolean value) {
3532       if (!value) {
3533         this.tableName = null;
3534       }
3535     }
3536 
3537     public void setFieldValue(_Fields field, Object value) {
3538       switch (field) {
3539       case TABLE_NAME:
3540         if (value == null) {
3541           unsetTableName();
3542         } else {
3543           setTableName((byte[])value);
3544         }
3545         break;
3546 
3547       }
3548     }
3549 
3550     public void setFieldValue(int fieldID, Object value) {
3551       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3552     }
3553 
3554     public Object getFieldValue(_Fields field) {
3555       switch (field) {
3556       case TABLE_NAME:
3557         return getTableName();
3558 
3559       }
3560       throw new IllegalStateException();
3561     }
3562 
3563     public Object getFieldValue(int fieldId) {
3564       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3565     }
3566 
3567     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
3568     public boolean isSet(_Fields field) {
3569       switch (field) {
3570       case TABLE_NAME:
3571         return isSetTableName();
3572       }
3573       throw new IllegalStateException();
3574     }
3575 
3576     public boolean isSet(int fieldID) {
3577       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3578     }
3579 
3580     @Override
3581     public boolean equals(Object that) {
3582       if (that == null)
3583         return false;
3584       if (that instanceof disableTable_args)
3585         return this.equals((disableTable_args)that);
3586       return false;
3587     }
3588 
3589     public boolean equals(disableTable_args that) {
3590       if (that == null)
3591         return false;
3592 
3593       boolean this_present_tableName = true && this.isSetTableName();
3594       boolean that_present_tableName = true && that.isSetTableName();
3595       if (this_present_tableName || that_present_tableName) {
3596         if (!(this_present_tableName && that_present_tableName))
3597           return false;
3598         if (!java.util.Arrays.equals(this.tableName, that.tableName))
3599           return false;
3600       }
3601 
3602       return true;
3603     }
3604 
3605     @Override
3606     public int hashCode() {
3607       HashCodeBuilder builder = new HashCodeBuilder();
3608 
3609       boolean present_tableName = true && (isSetTableName());
3610       builder.append(present_tableName);
3611       if (present_tableName)
3612         builder.append(tableName);
3613 
3614       return builder.toHashCode();
3615     }
3616 
3617     public int compareTo(disableTable_args other) {
3618       if (!getClass().equals(other.getClass())) {
3619         return getClass().getName().compareTo(other.getClass().getName());
3620       }
3621 
3622       int lastComparison = 0;
3623       disableTable_args typedOther = (disableTable_args)other;
3624 
3625       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
3626       if (lastComparison != 0) {
3627         return lastComparison;
3628       }
3629       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
3630       if (lastComparison != 0) {
3631         return lastComparison;
3632       }
3633       return 0;
3634     }
3635 
3636     public void read(TProtocol iprot) throws TException {
3637       TField field;
3638       iprot.readStructBegin();
3639       while (true)
3640       {
3641         field = iprot.readFieldBegin();
3642         if (field.type == TType.STOP) {
3643           break;
3644         }
3645         _Fields fieldId = _Fields.findByThriftId(field.id);
3646         if (fieldId == null) {
3647           TProtocolUtil.skip(iprot, field.type);
3648         } else {
3649           switch (fieldId) {
3650             case TABLE_NAME:
3651               if (field.type == TType.STRING) {
3652                 this.tableName = iprot.readBinary();
3653               } else {
3654                 TProtocolUtil.skip(iprot, field.type);
3655               }
3656               break;
3657           }
3658           iprot.readFieldEnd();
3659         }
3660       }
3661       iprot.readStructEnd();
3662 
3663       // check for required fields of primitive type, which can't be checked in the validate method
3664       validate();
3665     }
3666 
3667     public void write(TProtocol oprot) throws TException {
3668       validate();
3669 
3670       oprot.writeStructBegin(STRUCT_DESC);
3671       if (this.tableName != null) {
3672         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
3673         oprot.writeBinary(this.tableName);
3674         oprot.writeFieldEnd();
3675       }
3676       oprot.writeFieldStop();
3677       oprot.writeStructEnd();
3678     }
3679 
3680     @Override
3681     public String toString() {
3682       StringBuilder sb = new StringBuilder("disableTable_args(");
3683       boolean first = true;
3684 
3685       sb.append("tableName:");
3686       if (this.tableName == null) {
3687         sb.append("null");
3688       } else {
3689         sb.append(this.tableName);
3690       }
3691       first = false;
3692       sb.append(")");
3693       return sb.toString();
3694     }
3695 
3696     public void validate() throws TException {
3697       // check for required fields
3698     }
3699 
3700   }
3701 
3702   public static class disableTable_result implements TBase<disableTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<disableTable_result>   {
3703     private static final TStruct STRUCT_DESC = new TStruct("disableTable_result");
3704 
3705     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
3706 
3707     public IOError io;
3708 
3709     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
3710     public enum _Fields implements TFieldIdEnum {
3711       IO((short)1, "io");
3712 
3713       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
3714       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
3715 
3716       static {
3717         for (_Fields field : EnumSet.allOf(_Fields.class)) {
3718           byId.put((int)field._thriftId, field);
3719           byName.put(field.getFieldName(), field);
3720         }
3721       }
3722 
3723       /**
3724        * Find the _Fields constant that matches fieldId, or null if its not found.
3725        */
3726       public static _Fields findByThriftId(int fieldId) {
3727         return byId.get(fieldId);
3728       }
3729 
3730       /**
3731        * Find the _Fields constant that matches fieldId, throwing an exception
3732        * if it is not found.
3733        */
3734       public static _Fields findByThriftIdOrThrow(int fieldId) {
3735         _Fields fields = findByThriftId(fieldId);
3736         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
3737         return fields;
3738       }
3739 
3740       /**
3741        * Find the _Fields constant that matches name, or null if its not found.
3742        */
3743       public static _Fields findByName(String name) {
3744         return byName.get(name);
3745       }
3746 
3747       private final short _thriftId;
3748       private final String _fieldName;
3749 
3750       _Fields(short thriftId, String fieldName) {
3751         _thriftId = thriftId;
3752         _fieldName = fieldName;
3753       }
3754 
3755       public short getThriftFieldId() {
3756         return _thriftId;
3757       }
3758 
3759       public String getFieldName() {
3760         return _fieldName;
3761       }
3762     }
3763 
3764     // isset id assignments
3765 
3766     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
3767       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
3768           new FieldValueMetaData(TType.STRUCT)));
3769     }});
3770 
3771     static {
3772       FieldMetaData.addStructMetaDataMap(disableTable_result.class, metaDataMap);
3773     }
3774 
3775     public disableTable_result() {
3776     }
3777 
3778     public disableTable_result(
3779       IOError io)
3780     {
3781       this();
3782       this.io = io;
3783     }
3784 
3785     /**
3786      * Performs a deep copy on <i>other</i>.
3787      */
3788     public disableTable_result(disableTable_result other) {
3789       if (other.isSetIo()) {
3790         this.io = new IOError(other.io);
3791       }
3792     }
3793 
3794     public disableTable_result deepCopy() {
3795       return new disableTable_result(this);
3796     }
3797 
3798     @Deprecated
3799     public disableTable_result clone() {
3800       return new disableTable_result(this);
3801     }
3802 
3803     public IOError getIo() {
3804       return this.io;
3805     }
3806 
3807     public disableTable_result setIo(IOError io) {
3808       this.io = io;
3809       return this;
3810     }
3811 
3812     public void unsetIo() {
3813       this.io = null;
3814     }
3815 
3816     /** Returns true if field io is set (has been asigned a value) and false otherwise */
3817     public boolean isSetIo() {
3818       return this.io != null;
3819     }
3820 
3821     public void setIoIsSet(boolean value) {
3822       if (!value) {
3823         this.io = null;
3824       }
3825     }
3826 
3827     public void setFieldValue(_Fields field, Object value) {
3828       switch (field) {
3829       case IO:
3830         if (value == null) {
3831           unsetIo();
3832         } else {
3833           setIo((IOError)value);
3834         }
3835         break;
3836 
3837       }
3838     }
3839 
3840     public void setFieldValue(int fieldID, Object value) {
3841       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
3842     }
3843 
3844     public Object getFieldValue(_Fields field) {
3845       switch (field) {
3846       case IO:
3847         return getIo();
3848 
3849       }
3850       throw new IllegalStateException();
3851     }
3852 
3853     public Object getFieldValue(int fieldId) {
3854       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
3855     }
3856 
3857     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
3858     public boolean isSet(_Fields field) {
3859       switch (field) {
3860       case IO:
3861         return isSetIo();
3862       }
3863       throw new IllegalStateException();
3864     }
3865 
3866     public boolean isSet(int fieldID) {
3867       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
3868     }
3869 
3870     @Override
3871     public boolean equals(Object that) {
3872       if (that == null)
3873         return false;
3874       if (that instanceof disableTable_result)
3875         return this.equals((disableTable_result)that);
3876       return false;
3877     }
3878 
3879     public boolean equals(disableTable_result that) {
3880       if (that == null)
3881         return false;
3882 
3883       boolean this_present_io = true && this.isSetIo();
3884       boolean that_present_io = true && that.isSetIo();
3885       if (this_present_io || that_present_io) {
3886         if (!(this_present_io && that_present_io))
3887           return false;
3888         if (!this.io.equals(that.io))
3889           return false;
3890       }
3891 
3892       return true;
3893     }
3894 
3895     @Override
3896     public int hashCode() {
3897       HashCodeBuilder builder = new HashCodeBuilder();
3898 
3899       boolean present_io = true && (isSetIo());
3900       builder.append(present_io);
3901       if (present_io)
3902         builder.append(io);
3903 
3904       return builder.toHashCode();
3905     }
3906 
3907     public int compareTo(disableTable_result other) {
3908       if (!getClass().equals(other.getClass())) {
3909         return getClass().getName().compareTo(other.getClass().getName());
3910       }
3911 
3912       int lastComparison = 0;
3913       disableTable_result typedOther = (disableTable_result)other;
3914 
3915       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
3916       if (lastComparison != 0) {
3917         return lastComparison;
3918       }
3919       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
3920       if (lastComparison != 0) {
3921         return lastComparison;
3922       }
3923       return 0;
3924     }
3925 
3926     public void read(TProtocol iprot) throws TException {
3927       TField field;
3928       iprot.readStructBegin();
3929       while (true)
3930       {
3931         field = iprot.readFieldBegin();
3932         if (field.type == TType.STOP) {
3933           break;
3934         }
3935         _Fields fieldId = _Fields.findByThriftId(field.id);
3936         if (fieldId == null) {
3937           TProtocolUtil.skip(iprot, field.type);
3938         } else {
3939           switch (fieldId) {
3940             case IO:
3941               if (field.type == TType.STRUCT) {
3942                 this.io = new IOError();
3943                 this.io.read(iprot);
3944               } else {
3945                 TProtocolUtil.skip(iprot, field.type);
3946               }
3947               break;
3948           }
3949           iprot.readFieldEnd();
3950         }
3951       }
3952       iprot.readStructEnd();
3953 
3954       // check for required fields of primitive type, which can't be checked in the validate method
3955       validate();
3956     }
3957 
3958     public void write(TProtocol oprot) throws TException {
3959       oprot.writeStructBegin(STRUCT_DESC);
3960 
3961       if (this.isSetIo()) {
3962         oprot.writeFieldBegin(IO_FIELD_DESC);
3963         this.io.write(oprot);
3964         oprot.writeFieldEnd();
3965       }
3966       oprot.writeFieldStop();
3967       oprot.writeStructEnd();
3968     }
3969 
3970     @Override
3971     public String toString() {
3972       StringBuilder sb = new StringBuilder("disableTable_result(");
3973       boolean first = true;
3974 
3975       sb.append("io:");
3976       if (this.io == null) {
3977         sb.append("null");
3978       } else {
3979         sb.append(this.io);
3980       }
3981       first = false;
3982       sb.append(")");
3983       return sb.toString();
3984     }
3985 
3986     public void validate() throws TException {
3987       // check for required fields
3988     }
3989 
3990   }
3991 
3992   public static class isTableEnabled_args implements TBase<isTableEnabled_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_args>   {
3993     private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_args");
3994 
3995     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
3996 
3997     /**
3998      * name of the table to check
3999      */
4000     public byte[] tableName;
4001 
4002     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4003     public enum _Fields implements TFieldIdEnum {
4004       /**
4005        * name of the table to check
4006        */
4007       TABLE_NAME((short)1, "tableName");
4008 
4009       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4010       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4011 
4012       static {
4013         for (_Fields field : EnumSet.allOf(_Fields.class)) {
4014           byId.put((int)field._thriftId, field);
4015           byName.put(field.getFieldName(), field);
4016         }
4017       }
4018 
4019       /**
4020        * Find the _Fields constant that matches fieldId, or null if its not found.
4021        */
4022       public static _Fields findByThriftId(int fieldId) {
4023         return byId.get(fieldId);
4024       }
4025 
4026       /**
4027        * Find the _Fields constant that matches fieldId, throwing an exception
4028        * if it is not found.
4029        */
4030       public static _Fields findByThriftIdOrThrow(int fieldId) {
4031         _Fields fields = findByThriftId(fieldId);
4032         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4033         return fields;
4034       }
4035 
4036       /**
4037        * Find the _Fields constant that matches name, or null if its not found.
4038        */
4039       public static _Fields findByName(String name) {
4040         return byName.get(name);
4041       }
4042 
4043       private final short _thriftId;
4044       private final String _fieldName;
4045 
4046       _Fields(short thriftId, String fieldName) {
4047         _thriftId = thriftId;
4048         _fieldName = fieldName;
4049       }
4050 
4051       public short getThriftFieldId() {
4052         return _thriftId;
4053       }
4054 
4055       public String getFieldName() {
4056         return _fieldName;
4057       }
4058     }
4059 
4060     // isset id assignments
4061 
4062     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4063       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
4064           new FieldValueMetaData(TType.STRING)));
4065     }});
4066 
4067     static {
4068       FieldMetaData.addStructMetaDataMap(isTableEnabled_args.class, metaDataMap);
4069     }
4070 
4071     public isTableEnabled_args() {
4072     }
4073 
4074     public isTableEnabled_args(
4075       byte[] tableName)
4076     {
4077       this();
4078       this.tableName = tableName;
4079     }
4080 
4081     /**
4082      * Performs a deep copy on <i>other</i>.
4083      */
4084     public isTableEnabled_args(isTableEnabled_args other) {
4085       if (other.isSetTableName()) {
4086         this.tableName = other.tableName;
4087       }
4088     }
4089 
4090     public isTableEnabled_args deepCopy() {
4091       return new isTableEnabled_args(this);
4092     }
4093 
4094     @Deprecated
4095     public isTableEnabled_args clone() {
4096       return new isTableEnabled_args(this);
4097     }
4098 
4099     /**
4100      * name of the table to check
4101      */
4102     public byte[] getTableName() {
4103       return this.tableName;
4104     }
4105 
4106     /**
4107      * name of the table to check
4108      */
4109     public isTableEnabled_args setTableName(byte[] tableName) {
4110       this.tableName = tableName;
4111       return this;
4112     }
4113 
4114     public void unsetTableName() {
4115       this.tableName = null;
4116     }
4117 
4118     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
4119     public boolean isSetTableName() {
4120       return this.tableName != null;
4121     }
4122 
4123     public void setTableNameIsSet(boolean value) {
4124       if (!value) {
4125         this.tableName = null;
4126       }
4127     }
4128 
4129     public void setFieldValue(_Fields field, Object value) {
4130       switch (field) {
4131       case TABLE_NAME:
4132         if (value == null) {
4133           unsetTableName();
4134         } else {
4135           setTableName((byte[])value);
4136         }
4137         break;
4138 
4139       }
4140     }
4141 
4142     public void setFieldValue(int fieldID, Object value) {
4143       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4144     }
4145 
4146     public Object getFieldValue(_Fields field) {
4147       switch (field) {
4148       case TABLE_NAME:
4149         return getTableName();
4150 
4151       }
4152       throw new IllegalStateException();
4153     }
4154 
4155     public Object getFieldValue(int fieldId) {
4156       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4157     }
4158 
4159     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
4160     public boolean isSet(_Fields field) {
4161       switch (field) {
4162       case TABLE_NAME:
4163         return isSetTableName();
4164       }
4165       throw new IllegalStateException();
4166     }
4167 
4168     public boolean isSet(int fieldID) {
4169       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4170     }
4171 
4172     @Override
4173     public boolean equals(Object that) {
4174       if (that == null)
4175         return false;
4176       if (that instanceof isTableEnabled_args)
4177         return this.equals((isTableEnabled_args)that);
4178       return false;
4179     }
4180 
4181     public boolean equals(isTableEnabled_args that) {
4182       if (that == null)
4183         return false;
4184 
4185       boolean this_present_tableName = true && this.isSetTableName();
4186       boolean that_present_tableName = true && that.isSetTableName();
4187       if (this_present_tableName || that_present_tableName) {
4188         if (!(this_present_tableName && that_present_tableName))
4189           return false;
4190         if (!java.util.Arrays.equals(this.tableName, that.tableName))
4191           return false;
4192       }
4193 
4194       return true;
4195     }
4196 
4197     @Override
4198     public int hashCode() {
4199       HashCodeBuilder builder = new HashCodeBuilder();
4200 
4201       boolean present_tableName = true && (isSetTableName());
4202       builder.append(present_tableName);
4203       if (present_tableName)
4204         builder.append(tableName);
4205 
4206       return builder.toHashCode();
4207     }
4208 
4209     public int compareTo(isTableEnabled_args other) {
4210       if (!getClass().equals(other.getClass())) {
4211         return getClass().getName().compareTo(other.getClass().getName());
4212       }
4213 
4214       int lastComparison = 0;
4215       isTableEnabled_args typedOther = (isTableEnabled_args)other;
4216 
4217       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
4218       if (lastComparison != 0) {
4219         return lastComparison;
4220       }
4221       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
4222       if (lastComparison != 0) {
4223         return lastComparison;
4224       }
4225       return 0;
4226     }
4227 
4228     public void read(TProtocol iprot) throws TException {
4229       TField field;
4230       iprot.readStructBegin();
4231       while (true)
4232       {
4233         field = iprot.readFieldBegin();
4234         if (field.type == TType.STOP) {
4235           break;
4236         }
4237         _Fields fieldId = _Fields.findByThriftId(field.id);
4238         if (fieldId == null) {
4239           TProtocolUtil.skip(iprot, field.type);
4240         } else {
4241           switch (fieldId) {
4242             case TABLE_NAME:
4243               if (field.type == TType.STRING) {
4244                 this.tableName = iprot.readBinary();
4245               } else {
4246                 TProtocolUtil.skip(iprot, field.type);
4247               }
4248               break;
4249           }
4250           iprot.readFieldEnd();
4251         }
4252       }
4253       iprot.readStructEnd();
4254 
4255       // check for required fields of primitive type, which can't be checked in the validate method
4256       validate();
4257     }
4258 
4259     public void write(TProtocol oprot) throws TException {
4260       validate();
4261 
4262       oprot.writeStructBegin(STRUCT_DESC);
4263       if (this.tableName != null) {
4264         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
4265         oprot.writeBinary(this.tableName);
4266         oprot.writeFieldEnd();
4267       }
4268       oprot.writeFieldStop();
4269       oprot.writeStructEnd();
4270     }
4271 
4272     @Override
4273     public String toString() {
4274       StringBuilder sb = new StringBuilder("isTableEnabled_args(");
4275       boolean first = true;
4276 
4277       sb.append("tableName:");
4278       if (this.tableName == null) {
4279         sb.append("null");
4280       } else {
4281         sb.append(this.tableName);
4282       }
4283       first = false;
4284       sb.append(")");
4285       return sb.toString();
4286     }
4287 
4288     public void validate() throws TException {
4289       // check for required fields
4290     }
4291 
4292   }
4293 
4294   public static class isTableEnabled_result implements TBase<isTableEnabled_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTableEnabled_result>   {
4295     private static final TStruct STRUCT_DESC = new TStruct("isTableEnabled_result");
4296 
4297     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0);
4298     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
4299 
4300     public boolean success;
4301     public IOError io;
4302 
4303     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4304     public enum _Fields implements TFieldIdEnum {
4305       SUCCESS((short)0, "success"),
4306       IO((short)1, "io");
4307 
4308       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4309       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4310 
4311       static {
4312         for (_Fields field : EnumSet.allOf(_Fields.class)) {
4313           byId.put((int)field._thriftId, field);
4314           byName.put(field.getFieldName(), field);
4315         }
4316       }
4317 
4318       /**
4319        * Find the _Fields constant that matches fieldId, or null if its not found.
4320        */
4321       public static _Fields findByThriftId(int fieldId) {
4322         return byId.get(fieldId);
4323       }
4324 
4325       /**
4326        * Find the _Fields constant that matches fieldId, throwing an exception
4327        * if it is not found.
4328        */
4329       public static _Fields findByThriftIdOrThrow(int fieldId) {
4330         _Fields fields = findByThriftId(fieldId);
4331         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4332         return fields;
4333       }
4334 
4335       /**
4336        * Find the _Fields constant that matches name, or null if its not found.
4337        */
4338       public static _Fields findByName(String name) {
4339         return byName.get(name);
4340       }
4341 
4342       private final short _thriftId;
4343       private final String _fieldName;
4344 
4345       _Fields(short thriftId, String fieldName) {
4346         _thriftId = thriftId;
4347         _fieldName = fieldName;
4348       }
4349 
4350       public short getThriftFieldId() {
4351         return _thriftId;
4352       }
4353 
4354       public String getFieldName() {
4355         return _fieldName;
4356       }
4357     }
4358 
4359     // isset id assignments
4360     private static final int __SUCCESS_ISSET_ID = 0;
4361     private BitSet __isset_bit_vector = new BitSet(1);
4362 
4363     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4364       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
4365           new FieldValueMetaData(TType.BOOL)));
4366       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
4367           new FieldValueMetaData(TType.STRUCT)));
4368     }});
4369 
4370     static {
4371       FieldMetaData.addStructMetaDataMap(isTableEnabled_result.class, metaDataMap);
4372     }
4373 
4374     public isTableEnabled_result() {
4375     }
4376 
4377     public isTableEnabled_result(
4378       boolean success,
4379       IOError io)
4380     {
4381       this();
4382       this.success = success;
4383       setSuccessIsSet(true);
4384       this.io = io;
4385     }
4386 
4387     /**
4388      * Performs a deep copy on <i>other</i>.
4389      */
4390     public isTableEnabled_result(isTableEnabled_result other) {
4391       __isset_bit_vector.clear();
4392       __isset_bit_vector.or(other.__isset_bit_vector);
4393       this.success = other.success;
4394       if (other.isSetIo()) {
4395         this.io = new IOError(other.io);
4396       }
4397     }
4398 
4399     public isTableEnabled_result deepCopy() {
4400       return new isTableEnabled_result(this);
4401     }
4402 
4403     @Deprecated
4404     public isTableEnabled_result clone() {
4405       return new isTableEnabled_result(this);
4406     }
4407 
4408     public boolean isSuccess() {
4409       return this.success;
4410     }
4411 
4412     public isTableEnabled_result setSuccess(boolean success) {
4413       this.success = success;
4414       setSuccessIsSet(true);
4415       return this;
4416     }
4417 
4418     public void unsetSuccess() {
4419       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
4420     }
4421 
4422     /** Returns true if field success is set (has been asigned a value) and false otherwise */
4423     public boolean isSetSuccess() {
4424       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
4425     }
4426 
4427     public void setSuccessIsSet(boolean value) {
4428       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
4429     }
4430 
4431     public IOError getIo() {
4432       return this.io;
4433     }
4434 
4435     public isTableEnabled_result setIo(IOError io) {
4436       this.io = io;
4437       return this;
4438     }
4439 
4440     public void unsetIo() {
4441       this.io = null;
4442     }
4443 
4444     /** Returns true if field io is set (has been asigned a value) and false otherwise */
4445     public boolean isSetIo() {
4446       return this.io != null;
4447     }
4448 
4449     public void setIoIsSet(boolean value) {
4450       if (!value) {
4451         this.io = null;
4452       }
4453     }
4454 
4455     public void setFieldValue(_Fields field, Object value) {
4456       switch (field) {
4457       case SUCCESS:
4458         if (value == null) {
4459           unsetSuccess();
4460         } else {
4461           setSuccess((Boolean)value);
4462         }
4463         break;
4464 
4465       case IO:
4466         if (value == null) {
4467           unsetIo();
4468         } else {
4469           setIo((IOError)value);
4470         }
4471         break;
4472 
4473       }
4474     }
4475 
4476     public void setFieldValue(int fieldID, Object value) {
4477       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4478     }
4479 
4480     public Object getFieldValue(_Fields field) {
4481       switch (field) {
4482       case SUCCESS:
4483         return new Boolean(isSuccess());
4484 
4485       case IO:
4486         return getIo();
4487 
4488       }
4489       throw new IllegalStateException();
4490     }
4491 
4492     public Object getFieldValue(int fieldId) {
4493       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4494     }
4495 
4496     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
4497     public boolean isSet(_Fields field) {
4498       switch (field) {
4499       case SUCCESS:
4500         return isSetSuccess();
4501       case IO:
4502         return isSetIo();
4503       }
4504       throw new IllegalStateException();
4505     }
4506 
4507     public boolean isSet(int fieldID) {
4508       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4509     }
4510 
4511     @Override
4512     public boolean equals(Object that) {
4513       if (that == null)
4514         return false;
4515       if (that instanceof isTableEnabled_result)
4516         return this.equals((isTableEnabled_result)that);
4517       return false;
4518     }
4519 
4520     public boolean equals(isTableEnabled_result that) {
4521       if (that == null)
4522         return false;
4523 
4524       boolean this_present_success = true;
4525       boolean that_present_success = true;
4526       if (this_present_success || that_present_success) {
4527         if (!(this_present_success && that_present_success))
4528           return false;
4529         if (this.success != that.success)
4530           return false;
4531       }
4532 
4533       boolean this_present_io = true && this.isSetIo();
4534       boolean that_present_io = true && that.isSetIo();
4535       if (this_present_io || that_present_io) {
4536         if (!(this_present_io && that_present_io))
4537           return false;
4538         if (!this.io.equals(that.io))
4539           return false;
4540       }
4541 
4542       return true;
4543     }
4544 
4545     @Override
4546     public int hashCode() {
4547       HashCodeBuilder builder = new HashCodeBuilder();
4548 
4549       boolean present_success = true;
4550       builder.append(present_success);
4551       if (present_success)
4552         builder.append(success);
4553 
4554       boolean present_io = true && (isSetIo());
4555       builder.append(present_io);
4556       if (present_io)
4557         builder.append(io);
4558 
4559       return builder.toHashCode();
4560     }
4561 
4562     public int compareTo(isTableEnabled_result other) {
4563       if (!getClass().equals(other.getClass())) {
4564         return getClass().getName().compareTo(other.getClass().getName());
4565       }
4566 
4567       int lastComparison = 0;
4568       isTableEnabled_result typedOther = (isTableEnabled_result)other;
4569 
4570       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
4571       if (lastComparison != 0) {
4572         return lastComparison;
4573       }
4574       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
4575       if (lastComparison != 0) {
4576         return lastComparison;
4577       }
4578       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
4579       if (lastComparison != 0) {
4580         return lastComparison;
4581       }
4582       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
4583       if (lastComparison != 0) {
4584         return lastComparison;
4585       }
4586       return 0;
4587     }
4588 
4589     public void read(TProtocol iprot) throws TException {
4590       TField field;
4591       iprot.readStructBegin();
4592       while (true)
4593       {
4594         field = iprot.readFieldBegin();
4595         if (field.type == TType.STOP) {
4596           break;
4597         }
4598         _Fields fieldId = _Fields.findByThriftId(field.id);
4599         if (fieldId == null) {
4600           TProtocolUtil.skip(iprot, field.type);
4601         } else {
4602           switch (fieldId) {
4603             case SUCCESS:
4604               if (field.type == TType.BOOL) {
4605                 this.success = iprot.readBool();
4606                 setSuccessIsSet(true);
4607               } else {
4608                 TProtocolUtil.skip(iprot, field.type);
4609               }
4610               break;
4611             case IO:
4612               if (field.type == TType.STRUCT) {
4613                 this.io = new IOError();
4614                 this.io.read(iprot);
4615               } else {
4616                 TProtocolUtil.skip(iprot, field.type);
4617               }
4618               break;
4619           }
4620           iprot.readFieldEnd();
4621         }
4622       }
4623       iprot.readStructEnd();
4624 
4625       // check for required fields of primitive type, which can't be checked in the validate method
4626       validate();
4627     }
4628 
4629     public void write(TProtocol oprot) throws TException {
4630       oprot.writeStructBegin(STRUCT_DESC);
4631 
4632       if (this.isSetSuccess()) {
4633         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4634         oprot.writeBool(this.success);
4635         oprot.writeFieldEnd();
4636       } else if (this.isSetIo()) {
4637         oprot.writeFieldBegin(IO_FIELD_DESC);
4638         this.io.write(oprot);
4639         oprot.writeFieldEnd();
4640       }
4641       oprot.writeFieldStop();
4642       oprot.writeStructEnd();
4643     }
4644 
4645     @Override
4646     public String toString() {
4647       StringBuilder sb = new StringBuilder("isTableEnabled_result(");
4648       boolean first = true;
4649 
4650       sb.append("success:");
4651       sb.append(this.success);
4652       first = false;
4653       if (!first) sb.append(", ");
4654       sb.append("io:");
4655       if (this.io == null) {
4656         sb.append("null");
4657       } else {
4658         sb.append(this.io);
4659       }
4660       first = false;
4661       sb.append(")");
4662       return sb.toString();
4663     }
4664 
4665     public void validate() throws TException {
4666       // check for required fields
4667     }
4668 
4669   }
4670 
4671   public static class compact_args implements TBase<compact_args._Fields>, java.io.Serializable, Cloneable, Comparable<compact_args>   {
4672     private static final TStruct STRUCT_DESC = new TStruct("compact_args");
4673 
4674     private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1);
4675 
4676     public byte[] tableNameOrRegionName;
4677 
4678     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4679     public enum _Fields implements TFieldIdEnum {
4680       TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
4681 
4682       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4683       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4684 
4685       static {
4686         for (_Fields field : EnumSet.allOf(_Fields.class)) {
4687           byId.put((int)field._thriftId, field);
4688           byName.put(field.getFieldName(), field);
4689         }
4690       }
4691 
4692       /**
4693        * Find the _Fields constant that matches fieldId, or null if its not found.
4694        */
4695       public static _Fields findByThriftId(int fieldId) {
4696         return byId.get(fieldId);
4697       }
4698 
4699       /**
4700        * Find the _Fields constant that matches fieldId, throwing an exception
4701        * if it is not found.
4702        */
4703       public static _Fields findByThriftIdOrThrow(int fieldId) {
4704         _Fields fields = findByThriftId(fieldId);
4705         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4706         return fields;
4707       }
4708 
4709       /**
4710        * Find the _Fields constant that matches name, or null if its not found.
4711        */
4712       public static _Fields findByName(String name) {
4713         return byName.get(name);
4714       }
4715 
4716       private final short _thriftId;
4717       private final String _fieldName;
4718 
4719       _Fields(short thriftId, String fieldName) {
4720         _thriftId = thriftId;
4721         _fieldName = fieldName;
4722       }
4723 
4724       public short getThriftFieldId() {
4725         return _thriftId;
4726       }
4727 
4728       public String getFieldName() {
4729         return _fieldName;
4730       }
4731     }
4732 
4733     // isset id assignments
4734 
4735     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
4736       put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT,
4737           new FieldValueMetaData(TType.STRING)));
4738     }});
4739 
4740     static {
4741       FieldMetaData.addStructMetaDataMap(compact_args.class, metaDataMap);
4742     }
4743 
4744     public compact_args() {
4745     }
4746 
4747     public compact_args(
4748       byte[] tableNameOrRegionName)
4749     {
4750       this();
4751       this.tableNameOrRegionName = tableNameOrRegionName;
4752     }
4753 
4754     /**
4755      * Performs a deep copy on <i>other</i>.
4756      */
4757     public compact_args(compact_args other) {
4758       if (other.isSetTableNameOrRegionName()) {
4759         this.tableNameOrRegionName = other.tableNameOrRegionName;
4760       }
4761     }
4762 
4763     public compact_args deepCopy() {
4764       return new compact_args(this);
4765     }
4766 
4767     @Deprecated
4768     public compact_args clone() {
4769       return new compact_args(this);
4770     }
4771 
4772     public byte[] getTableNameOrRegionName() {
4773       return this.tableNameOrRegionName;
4774     }
4775 
4776     public compact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
4777       this.tableNameOrRegionName = tableNameOrRegionName;
4778       return this;
4779     }
4780 
4781     public void unsetTableNameOrRegionName() {
4782       this.tableNameOrRegionName = null;
4783     }
4784 
4785     /** Returns true if field tableNameOrRegionName is set (has been asigned a value) and false otherwise */
4786     public boolean isSetTableNameOrRegionName() {
4787       return this.tableNameOrRegionName != null;
4788     }
4789 
4790     public void setTableNameOrRegionNameIsSet(boolean value) {
4791       if (!value) {
4792         this.tableNameOrRegionName = null;
4793       }
4794     }
4795 
4796     public void setFieldValue(_Fields field, Object value) {
4797       switch (field) {
4798       case TABLE_NAME_OR_REGION_NAME:
4799         if (value == null) {
4800           unsetTableNameOrRegionName();
4801         } else {
4802           setTableNameOrRegionName((byte[])value);
4803         }
4804         break;
4805 
4806       }
4807     }
4808 
4809     public void setFieldValue(int fieldID, Object value) {
4810       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
4811     }
4812 
4813     public Object getFieldValue(_Fields field) {
4814       switch (field) {
4815       case TABLE_NAME_OR_REGION_NAME:
4816         return getTableNameOrRegionName();
4817 
4818       }
4819       throw new IllegalStateException();
4820     }
4821 
4822     public Object getFieldValue(int fieldId) {
4823       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
4824     }
4825 
4826     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
4827     public boolean isSet(_Fields field) {
4828       switch (field) {
4829       case TABLE_NAME_OR_REGION_NAME:
4830         return isSetTableNameOrRegionName();
4831       }
4832       throw new IllegalStateException();
4833     }
4834 
4835     public boolean isSet(int fieldID) {
4836       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
4837     }
4838 
4839     @Override
4840     public boolean equals(Object that) {
4841       if (that == null)
4842         return false;
4843       if (that instanceof compact_args)
4844         return this.equals((compact_args)that);
4845       return false;
4846     }
4847 
4848     public boolean equals(compact_args that) {
4849       if (that == null)
4850         return false;
4851 
4852       boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
4853       boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
4854       if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
4855         if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
4856           return false;
4857         if (!java.util.Arrays.equals(this.tableNameOrRegionName, that.tableNameOrRegionName))
4858           return false;
4859       }
4860 
4861       return true;
4862     }
4863 
4864     @Override
4865     public int hashCode() {
4866       HashCodeBuilder builder = new HashCodeBuilder();
4867 
4868       boolean present_tableNameOrRegionName = true && (isSetTableNameOrRegionName());
4869       builder.append(present_tableNameOrRegionName);
4870       if (present_tableNameOrRegionName)
4871         builder.append(tableNameOrRegionName);
4872 
4873       return builder.toHashCode();
4874     }
4875 
4876     public int compareTo(compact_args other) {
4877       if (!getClass().equals(other.getClass())) {
4878         return getClass().getName().compareTo(other.getClass().getName());
4879       }
4880 
4881       int lastComparison = 0;
4882       compact_args typedOther = (compact_args)other;
4883 
4884       lastComparison = Boolean.valueOf(isSetTableNameOrRegionName()).compareTo(isSetTableNameOrRegionName());
4885       if (lastComparison != 0) {
4886         return lastComparison;
4887       }
4888       lastComparison = TBaseHelper.compareTo(tableNameOrRegionName, typedOther.tableNameOrRegionName);
4889       if (lastComparison != 0) {
4890         return lastComparison;
4891       }
4892       return 0;
4893     }
4894 
4895     public void read(TProtocol iprot) throws TException {
4896       TField field;
4897       iprot.readStructBegin();
4898       while (true)
4899       {
4900         field = iprot.readFieldBegin();
4901         if (field.type == TType.STOP) {
4902           break;
4903         }
4904         _Fields fieldId = _Fields.findByThriftId(field.id);
4905         if (fieldId == null) {
4906           TProtocolUtil.skip(iprot, field.type);
4907         } else {
4908           switch (fieldId) {
4909             case TABLE_NAME_OR_REGION_NAME:
4910               if (field.type == TType.STRING) {
4911                 this.tableNameOrRegionName = iprot.readBinary();
4912               } else {
4913                 TProtocolUtil.skip(iprot, field.type);
4914               }
4915               break;
4916           }
4917           iprot.readFieldEnd();
4918         }
4919       }
4920       iprot.readStructEnd();
4921 
4922       // check for required fields of primitive type, which can't be checked in the validate method
4923       validate();
4924     }
4925 
4926     public void write(TProtocol oprot) throws TException {
4927       validate();
4928 
4929       oprot.writeStructBegin(STRUCT_DESC);
4930       if (this.tableNameOrRegionName != null) {
4931         oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
4932         oprot.writeBinary(this.tableNameOrRegionName);
4933         oprot.writeFieldEnd();
4934       }
4935       oprot.writeFieldStop();
4936       oprot.writeStructEnd();
4937     }
4938 
4939     @Override
4940     public String toString() {
4941       StringBuilder sb = new StringBuilder("compact_args(");
4942       boolean first = true;
4943 
4944       sb.append("tableNameOrRegionName:");
4945       if (this.tableNameOrRegionName == null) {
4946         sb.append("null");
4947       } else {
4948         sb.append(this.tableNameOrRegionName);
4949       }
4950       first = false;
4951       sb.append(")");
4952       return sb.toString();
4953     }
4954 
4955     public void validate() throws TException {
4956       // check for required fields
4957     }
4958 
4959   }
4960 
4961   public static class compact_result implements TBase<compact_result._Fields>, java.io.Serializable, Cloneable, Comparable<compact_result>   {
4962     private static final TStruct STRUCT_DESC = new TStruct("compact_result");
4963 
4964     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
4965 
4966     public IOError io;
4967 
4968     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
4969     public enum _Fields implements TFieldIdEnum {
4970       IO((short)1, "io");
4971 
4972       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
4973       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
4974 
4975       static {
4976         for (_Fields field : EnumSet.allOf(_Fields.class)) {
4977           byId.put((int)field._thriftId, field);
4978           byName.put(field.getFieldName(), field);
4979         }
4980       }
4981 
4982       /**
4983        * Find the _Fields constant that matches fieldId, or null if its not found.
4984        */
4985       public static _Fields findByThriftId(int fieldId) {
4986         return byId.get(fieldId);
4987       }
4988 
4989       /**
4990        * Find the _Fields constant that matches fieldId, throwing an exception
4991        * if it is not found.
4992        */
4993       public static _Fields findByThriftIdOrThrow(int fieldId) {
4994         _Fields fields = findByThriftId(fieldId);
4995         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
4996         return fields;
4997       }
4998 
4999       /**
5000        * Find the _Fields constant that matches name, or null if its not found.
5001        */
5002       public static _Fields findByName(String name) {
5003         return byName.get(name);
5004       }
5005 
5006       private final short _thriftId;
5007       private final String _fieldName;
5008 
5009       _Fields(short thriftId, String fieldName) {
5010         _thriftId = thriftId;
5011         _fieldName = fieldName;
5012       }
5013 
5014       public short getThriftFieldId() {
5015         return _thriftId;
5016       }
5017 
5018       public String getFieldName() {
5019         return _fieldName;
5020       }
5021     }
5022 
5023     // isset id assignments
5024 
5025     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5026       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
5027           new FieldValueMetaData(TType.STRUCT)));
5028     }});
5029 
5030     static {
5031       FieldMetaData.addStructMetaDataMap(compact_result.class, metaDataMap);
5032     }
5033 
5034     public compact_result() {
5035     }
5036 
5037     public compact_result(
5038       IOError io)
5039     {
5040       this();
5041       this.io = io;
5042     }
5043 
5044     /**
5045      * Performs a deep copy on <i>other</i>.
5046      */
5047     public compact_result(compact_result other) {
5048       if (other.isSetIo()) {
5049         this.io = new IOError(other.io);
5050       }
5051     }
5052 
5053     public compact_result deepCopy() {
5054       return new compact_result(this);
5055     }
5056 
5057     @Deprecated
5058     public compact_result clone() {
5059       return new compact_result(this);
5060     }
5061 
5062     public IOError getIo() {
5063       return this.io;
5064     }
5065 
5066     public compact_result setIo(IOError io) {
5067       this.io = io;
5068       return this;
5069     }
5070 
5071     public void unsetIo() {
5072       this.io = null;
5073     }
5074 
5075     /** Returns true if field io is set (has been asigned a value) and false otherwise */
5076     public boolean isSetIo() {
5077       return this.io != null;
5078     }
5079 
5080     public void setIoIsSet(boolean value) {
5081       if (!value) {
5082         this.io = null;
5083       }
5084     }
5085 
5086     public void setFieldValue(_Fields field, Object value) {
5087       switch (field) {
5088       case IO:
5089         if (value == null) {
5090           unsetIo();
5091         } else {
5092           setIo((IOError)value);
5093         }
5094         break;
5095 
5096       }
5097     }
5098 
5099     public void setFieldValue(int fieldID, Object value) {
5100       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5101     }
5102 
5103     public Object getFieldValue(_Fields field) {
5104       switch (field) {
5105       case IO:
5106         return getIo();
5107 
5108       }
5109       throw new IllegalStateException();
5110     }
5111 
5112     public Object getFieldValue(int fieldId) {
5113       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5114     }
5115 
5116     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
5117     public boolean isSet(_Fields field) {
5118       switch (field) {
5119       case IO:
5120         return isSetIo();
5121       }
5122       throw new IllegalStateException();
5123     }
5124 
5125     public boolean isSet(int fieldID) {
5126       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5127     }
5128 
5129     @Override
5130     public boolean equals(Object that) {
5131       if (that == null)
5132         return false;
5133       if (that instanceof compact_result)
5134         return this.equals((compact_result)that);
5135       return false;
5136     }
5137 
5138     public boolean equals(compact_result that) {
5139       if (that == null)
5140         return false;
5141 
5142       boolean this_present_io = true && this.isSetIo();
5143       boolean that_present_io = true && that.isSetIo();
5144       if (this_present_io || that_present_io) {
5145         if (!(this_present_io && that_present_io))
5146           return false;
5147         if (!this.io.equals(that.io))
5148           return false;
5149       }
5150 
5151       return true;
5152     }
5153 
5154     @Override
5155     public int hashCode() {
5156       HashCodeBuilder builder = new HashCodeBuilder();
5157 
5158       boolean present_io = true && (isSetIo());
5159       builder.append(present_io);
5160       if (present_io)
5161         builder.append(io);
5162 
5163       return builder.toHashCode();
5164     }
5165 
5166     public int compareTo(compact_result other) {
5167       if (!getClass().equals(other.getClass())) {
5168         return getClass().getName().compareTo(other.getClass().getName());
5169       }
5170 
5171       int lastComparison = 0;
5172       compact_result typedOther = (compact_result)other;
5173 
5174       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
5175       if (lastComparison != 0) {
5176         return lastComparison;
5177       }
5178       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
5179       if (lastComparison != 0) {
5180         return lastComparison;
5181       }
5182       return 0;
5183     }
5184 
5185     public void read(TProtocol iprot) throws TException {
5186       TField field;
5187       iprot.readStructBegin();
5188       while (true)
5189       {
5190         field = iprot.readFieldBegin();
5191         if (field.type == TType.STOP) {
5192           break;
5193         }
5194         _Fields fieldId = _Fields.findByThriftId(field.id);
5195         if (fieldId == null) {
5196           TProtocolUtil.skip(iprot, field.type);
5197         } else {
5198           switch (fieldId) {
5199             case IO:
5200               if (field.type == TType.STRUCT) {
5201                 this.io = new IOError();
5202                 this.io.read(iprot);
5203               } else {
5204                 TProtocolUtil.skip(iprot, field.type);
5205               }
5206               break;
5207           }
5208           iprot.readFieldEnd();
5209         }
5210       }
5211       iprot.readStructEnd();
5212 
5213       // check for required fields of primitive type, which can't be checked in the validate method
5214       validate();
5215     }
5216 
5217     public void write(TProtocol oprot) throws TException {
5218       oprot.writeStructBegin(STRUCT_DESC);
5219 
5220       if (this.isSetIo()) {
5221         oprot.writeFieldBegin(IO_FIELD_DESC);
5222         this.io.write(oprot);
5223         oprot.writeFieldEnd();
5224       }
5225       oprot.writeFieldStop();
5226       oprot.writeStructEnd();
5227     }
5228 
5229     @Override
5230     public String toString() {
5231       StringBuilder sb = new StringBuilder("compact_result(");
5232       boolean first = true;
5233 
5234       sb.append("io:");
5235       if (this.io == null) {
5236         sb.append("null");
5237       } else {
5238         sb.append(this.io);
5239       }
5240       first = false;
5241       sb.append(")");
5242       return sb.toString();
5243     }
5244 
5245     public void validate() throws TException {
5246       // check for required fields
5247     }
5248 
5249   }
5250 
5251   public static class majorCompact_args implements TBase<majorCompact_args._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_args>   {
5252     private static final TStruct STRUCT_DESC = new TStruct("majorCompact_args");
5253 
5254     private static final TField TABLE_NAME_OR_REGION_NAME_FIELD_DESC = new TField("tableNameOrRegionName", TType.STRING, (short)1);
5255 
5256     public byte[] tableNameOrRegionName;
5257 
5258     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
5259     public enum _Fields implements TFieldIdEnum {
5260       TABLE_NAME_OR_REGION_NAME((short)1, "tableNameOrRegionName");
5261 
5262       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5263       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5264 
5265       static {
5266         for (_Fields field : EnumSet.allOf(_Fields.class)) {
5267           byId.put((int)field._thriftId, field);
5268           byName.put(field.getFieldName(), field);
5269         }
5270       }
5271 
5272       /**
5273        * Find the _Fields constant that matches fieldId, or null if its not found.
5274        */
5275       public static _Fields findByThriftId(int fieldId) {
5276         return byId.get(fieldId);
5277       }
5278 
5279       /**
5280        * Find the _Fields constant that matches fieldId, throwing an exception
5281        * if it is not found.
5282        */
5283       public static _Fields findByThriftIdOrThrow(int fieldId) {
5284         _Fields fields = findByThriftId(fieldId);
5285         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5286         return fields;
5287       }
5288 
5289       /**
5290        * Find the _Fields constant that matches name, or null if its not found.
5291        */
5292       public static _Fields findByName(String name) {
5293         return byName.get(name);
5294       }
5295 
5296       private final short _thriftId;
5297       private final String _fieldName;
5298 
5299       _Fields(short thriftId, String fieldName) {
5300         _thriftId = thriftId;
5301         _fieldName = fieldName;
5302       }
5303 
5304       public short getThriftFieldId() {
5305         return _thriftId;
5306       }
5307 
5308       public String getFieldName() {
5309         return _fieldName;
5310       }
5311     }
5312 
5313     // isset id assignments
5314 
5315     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5316       put(_Fields.TABLE_NAME_OR_REGION_NAME, new FieldMetaData("tableNameOrRegionName", TFieldRequirementType.DEFAULT,
5317           new FieldValueMetaData(TType.STRING)));
5318     }});
5319 
5320     static {
5321       FieldMetaData.addStructMetaDataMap(majorCompact_args.class, metaDataMap);
5322     }
5323 
5324     public majorCompact_args() {
5325     }
5326 
5327     public majorCompact_args(
5328       byte[] tableNameOrRegionName)
5329     {
5330       this();
5331       this.tableNameOrRegionName = tableNameOrRegionName;
5332     }
5333 
5334     /**
5335      * Performs a deep copy on <i>other</i>.
5336      */
5337     public majorCompact_args(majorCompact_args other) {
5338       if (other.isSetTableNameOrRegionName()) {
5339         this.tableNameOrRegionName = other.tableNameOrRegionName;
5340       }
5341     }
5342 
5343     public majorCompact_args deepCopy() {
5344       return new majorCompact_args(this);
5345     }
5346 
5347     @Deprecated
5348     public majorCompact_args clone() {
5349       return new majorCompact_args(this);
5350     }
5351 
5352     public byte[] getTableNameOrRegionName() {
5353       return this.tableNameOrRegionName;
5354     }
5355 
5356     public majorCompact_args setTableNameOrRegionName(byte[] tableNameOrRegionName) {
5357       this.tableNameOrRegionName = tableNameOrRegionName;
5358       return this;
5359     }
5360 
5361     public void unsetTableNameOrRegionName() {
5362       this.tableNameOrRegionName = null;
5363     }
5364 
5365     /** Returns true if field tableNameOrRegionName is set (has been asigned a value) and false otherwise */
5366     public boolean isSetTableNameOrRegionName() {
5367       return this.tableNameOrRegionName != null;
5368     }
5369 
5370     public void setTableNameOrRegionNameIsSet(boolean value) {
5371       if (!value) {
5372         this.tableNameOrRegionName = null;
5373       }
5374     }
5375 
5376     public void setFieldValue(_Fields field, Object value) {
5377       switch (field) {
5378       case TABLE_NAME_OR_REGION_NAME:
5379         if (value == null) {
5380           unsetTableNameOrRegionName();
5381         } else {
5382           setTableNameOrRegionName((byte[])value);
5383         }
5384         break;
5385 
5386       }
5387     }
5388 
5389     public void setFieldValue(int fieldID, Object value) {
5390       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5391     }
5392 
5393     public Object getFieldValue(_Fields field) {
5394       switch (field) {
5395       case TABLE_NAME_OR_REGION_NAME:
5396         return getTableNameOrRegionName();
5397 
5398       }
5399       throw new IllegalStateException();
5400     }
5401 
5402     public Object getFieldValue(int fieldId) {
5403       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5404     }
5405 
5406     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
5407     public boolean isSet(_Fields field) {
5408       switch (field) {
5409       case TABLE_NAME_OR_REGION_NAME:
5410         return isSetTableNameOrRegionName();
5411       }
5412       throw new IllegalStateException();
5413     }
5414 
5415     public boolean isSet(int fieldID) {
5416       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5417     }
5418 
5419     @Override
5420     public boolean equals(Object that) {
5421       if (that == null)
5422         return false;
5423       if (that instanceof majorCompact_args)
5424         return this.equals((majorCompact_args)that);
5425       return false;
5426     }
5427 
5428     public boolean equals(majorCompact_args that) {
5429       if (that == null)
5430         return false;
5431 
5432       boolean this_present_tableNameOrRegionName = true && this.isSetTableNameOrRegionName();
5433       boolean that_present_tableNameOrRegionName = true && that.isSetTableNameOrRegionName();
5434       if (this_present_tableNameOrRegionName || that_present_tableNameOrRegionName) {
5435         if (!(this_present_tableNameOrRegionName && that_present_tableNameOrRegionName))
5436           return false;
5437         if (!java.util.Arrays.equals(this.tableNameOrRegionName, that.tableNameOrRegionName))
5438           return false;
5439       }
5440 
5441       return true;
5442     }
5443 
5444     @Override
5445     public int hashCode() {
5446       HashCodeBuilder builder = new HashCodeBuilder();
5447 
5448       boolean present_tableNameOrRegionName = true && (isSetTableNameOrRegionName());
5449       builder.append(present_tableNameOrRegionName);
5450       if (present_tableNameOrRegionName)
5451         builder.append(tableNameOrRegionName);
5452 
5453       return builder.toHashCode();
5454     }
5455 
5456     public int compareTo(majorCompact_args other) {
5457       if (!getClass().equals(other.getClass())) {
5458         return getClass().getName().compareTo(other.getClass().getName());
5459       }
5460 
5461       int lastComparison = 0;
5462       majorCompact_args typedOther = (majorCompact_args)other;
5463 
5464       lastComparison = Boolean.valueOf(isSetTableNameOrRegionName()).compareTo(isSetTableNameOrRegionName());
5465       if (lastComparison != 0) {
5466         return lastComparison;
5467       }
5468       lastComparison = TBaseHelper.compareTo(tableNameOrRegionName, typedOther.tableNameOrRegionName);
5469       if (lastComparison != 0) {
5470         return lastComparison;
5471       }
5472       return 0;
5473     }
5474 
5475     public void read(TProtocol iprot) throws TException {
5476       TField field;
5477       iprot.readStructBegin();
5478       while (true)
5479       {
5480         field = iprot.readFieldBegin();
5481         if (field.type == TType.STOP) {
5482           break;
5483         }
5484         _Fields fieldId = _Fields.findByThriftId(field.id);
5485         if (fieldId == null) {
5486           TProtocolUtil.skip(iprot, field.type);
5487         } else {
5488           switch (fieldId) {
5489             case TABLE_NAME_OR_REGION_NAME:
5490               if (field.type == TType.STRING) {
5491                 this.tableNameOrRegionName = iprot.readBinary();
5492               } else {
5493                 TProtocolUtil.skip(iprot, field.type);
5494               }
5495               break;
5496           }
5497           iprot.readFieldEnd();
5498         }
5499       }
5500       iprot.readStructEnd();
5501 
5502       // check for required fields of primitive type, which can't be checked in the validate method
5503       validate();
5504     }
5505 
5506     public void write(TProtocol oprot) throws TException {
5507       validate();
5508 
5509       oprot.writeStructBegin(STRUCT_DESC);
5510       if (this.tableNameOrRegionName != null) {
5511         oprot.writeFieldBegin(TABLE_NAME_OR_REGION_NAME_FIELD_DESC);
5512         oprot.writeBinary(this.tableNameOrRegionName);
5513         oprot.writeFieldEnd();
5514       }
5515       oprot.writeFieldStop();
5516       oprot.writeStructEnd();
5517     }
5518 
5519     @Override
5520     public String toString() {
5521       StringBuilder sb = new StringBuilder("majorCompact_args(");
5522       boolean first = true;
5523 
5524       sb.append("tableNameOrRegionName:");
5525       if (this.tableNameOrRegionName == null) {
5526         sb.append("null");
5527       } else {
5528         sb.append(this.tableNameOrRegionName);
5529       }
5530       first = false;
5531       sb.append(")");
5532       return sb.toString();
5533     }
5534 
5535     public void validate() throws TException {
5536       // check for required fields
5537     }
5538 
5539   }
5540 
5541   public static class majorCompact_result implements TBase<majorCompact_result._Fields>, java.io.Serializable, Cloneable, Comparable<majorCompact_result>   {
5542     private static final TStruct STRUCT_DESC = new TStruct("majorCompact_result");
5543 
5544     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
5545 
5546     public IOError io;
5547 
5548     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
5549     public enum _Fields implements TFieldIdEnum {
5550       IO((short)1, "io");
5551 
5552       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5553       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5554 
5555       static {
5556         for (_Fields field : EnumSet.allOf(_Fields.class)) {
5557           byId.put((int)field._thriftId, field);
5558           byName.put(field.getFieldName(), field);
5559         }
5560       }
5561 
5562       /**
5563        * Find the _Fields constant that matches fieldId, or null if its not found.
5564        */
5565       public static _Fields findByThriftId(int fieldId) {
5566         return byId.get(fieldId);
5567       }
5568 
5569       /**
5570        * Find the _Fields constant that matches fieldId, throwing an exception
5571        * if it is not found.
5572        */
5573       public static _Fields findByThriftIdOrThrow(int fieldId) {
5574         _Fields fields = findByThriftId(fieldId);
5575         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5576         return fields;
5577       }
5578 
5579       /**
5580        * Find the _Fields constant that matches name, or null if its not found.
5581        */
5582       public static _Fields findByName(String name) {
5583         return byName.get(name);
5584       }
5585 
5586       private final short _thriftId;
5587       private final String _fieldName;
5588 
5589       _Fields(short thriftId, String fieldName) {
5590         _thriftId = thriftId;
5591         _fieldName = fieldName;
5592       }
5593 
5594       public short getThriftFieldId() {
5595         return _thriftId;
5596       }
5597 
5598       public String getFieldName() {
5599         return _fieldName;
5600       }
5601     }
5602 
5603     // isset id assignments
5604 
5605     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5606       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
5607           new FieldValueMetaData(TType.STRUCT)));
5608     }});
5609 
5610     static {
5611       FieldMetaData.addStructMetaDataMap(majorCompact_result.class, metaDataMap);
5612     }
5613 
5614     public majorCompact_result() {
5615     }
5616 
5617     public majorCompact_result(
5618       IOError io)
5619     {
5620       this();
5621       this.io = io;
5622     }
5623 
5624     /**
5625      * Performs a deep copy on <i>other</i>.
5626      */
5627     public majorCompact_result(majorCompact_result other) {
5628       if (other.isSetIo()) {
5629         this.io = new IOError(other.io);
5630       }
5631     }
5632 
5633     public majorCompact_result deepCopy() {
5634       return new majorCompact_result(this);
5635     }
5636 
5637     @Deprecated
5638     public majorCompact_result clone() {
5639       return new majorCompact_result(this);
5640     }
5641 
5642     public IOError getIo() {
5643       return this.io;
5644     }
5645 
5646     public majorCompact_result setIo(IOError io) {
5647       this.io = io;
5648       return this;
5649     }
5650 
5651     public void unsetIo() {
5652       this.io = null;
5653     }
5654 
5655     /** Returns true if field io is set (has been asigned a value) and false otherwise */
5656     public boolean isSetIo() {
5657       return this.io != null;
5658     }
5659 
5660     public void setIoIsSet(boolean value) {
5661       if (!value) {
5662         this.io = null;
5663       }
5664     }
5665 
5666     public void setFieldValue(_Fields field, Object value) {
5667       switch (field) {
5668       case IO:
5669         if (value == null) {
5670           unsetIo();
5671         } else {
5672           setIo((IOError)value);
5673         }
5674         break;
5675 
5676       }
5677     }
5678 
5679     public void setFieldValue(int fieldID, Object value) {
5680       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5681     }
5682 
5683     public Object getFieldValue(_Fields field) {
5684       switch (field) {
5685       case IO:
5686         return getIo();
5687 
5688       }
5689       throw new IllegalStateException();
5690     }
5691 
5692     public Object getFieldValue(int fieldId) {
5693       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5694     }
5695 
5696     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
5697     public boolean isSet(_Fields field) {
5698       switch (field) {
5699       case IO:
5700         return isSetIo();
5701       }
5702       throw new IllegalStateException();
5703     }
5704 
5705     public boolean isSet(int fieldID) {
5706       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5707     }
5708 
5709     @Override
5710     public boolean equals(Object that) {
5711       if (that == null)
5712         return false;
5713       if (that instanceof majorCompact_result)
5714         return this.equals((majorCompact_result)that);
5715       return false;
5716     }
5717 
5718     public boolean equals(majorCompact_result that) {
5719       if (that == null)
5720         return false;
5721 
5722       boolean this_present_io = true && this.isSetIo();
5723       boolean that_present_io = true && that.isSetIo();
5724       if (this_present_io || that_present_io) {
5725         if (!(this_present_io && that_present_io))
5726           return false;
5727         if (!this.io.equals(that.io))
5728           return false;
5729       }
5730 
5731       return true;
5732     }
5733 
5734     @Override
5735     public int hashCode() {
5736       HashCodeBuilder builder = new HashCodeBuilder();
5737 
5738       boolean present_io = true && (isSetIo());
5739       builder.append(present_io);
5740       if (present_io)
5741         builder.append(io);
5742 
5743       return builder.toHashCode();
5744     }
5745 
5746     public int compareTo(majorCompact_result other) {
5747       if (!getClass().equals(other.getClass())) {
5748         return getClass().getName().compareTo(other.getClass().getName());
5749       }
5750 
5751       int lastComparison = 0;
5752       majorCompact_result typedOther = (majorCompact_result)other;
5753 
5754       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
5755       if (lastComparison != 0) {
5756         return lastComparison;
5757       }
5758       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
5759       if (lastComparison != 0) {
5760         return lastComparison;
5761       }
5762       return 0;
5763     }
5764 
5765     public void read(TProtocol iprot) throws TException {
5766       TField field;
5767       iprot.readStructBegin();
5768       while (true)
5769       {
5770         field = iprot.readFieldBegin();
5771         if (field.type == TType.STOP) {
5772           break;
5773         }
5774         _Fields fieldId = _Fields.findByThriftId(field.id);
5775         if (fieldId == null) {
5776           TProtocolUtil.skip(iprot, field.type);
5777         } else {
5778           switch (fieldId) {
5779             case IO:
5780               if (field.type == TType.STRUCT) {
5781                 this.io = new IOError();
5782                 this.io.read(iprot);
5783               } else {
5784                 TProtocolUtil.skip(iprot, field.type);
5785               }
5786               break;
5787           }
5788           iprot.readFieldEnd();
5789         }
5790       }
5791       iprot.readStructEnd();
5792 
5793       // check for required fields of primitive type, which can't be checked in the validate method
5794       validate();
5795     }
5796 
5797     public void write(TProtocol oprot) throws TException {
5798       oprot.writeStructBegin(STRUCT_DESC);
5799 
5800       if (this.isSetIo()) {
5801         oprot.writeFieldBegin(IO_FIELD_DESC);
5802         this.io.write(oprot);
5803         oprot.writeFieldEnd();
5804       }
5805       oprot.writeFieldStop();
5806       oprot.writeStructEnd();
5807     }
5808 
5809     @Override
5810     public String toString() {
5811       StringBuilder sb = new StringBuilder("majorCompact_result(");
5812       boolean first = true;
5813 
5814       sb.append("io:");
5815       if (this.io == null) {
5816         sb.append("null");
5817       } else {
5818         sb.append(this.io);
5819       }
5820       first = false;
5821       sb.append(")");
5822       return sb.toString();
5823     }
5824 
5825     public void validate() throws TException {
5826       // check for required fields
5827     }
5828 
5829   }
5830 
5831   public static class getTableNames_args implements TBase<getTableNames_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_args>   {
5832     private static final TStruct STRUCT_DESC = new TStruct("getTableNames_args");
5833 
5834 
5835 
5836     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
5837     public enum _Fields implements TFieldIdEnum {
5838 ;
5839 
5840       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
5841       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
5842 
5843       static {
5844         for (_Fields field : EnumSet.allOf(_Fields.class)) {
5845           byId.put((int)field._thriftId, field);
5846           byName.put(field.getFieldName(), field);
5847         }
5848       }
5849 
5850       /**
5851        * Find the _Fields constant that matches fieldId, or null if its not found.
5852        */
5853       public static _Fields findByThriftId(int fieldId) {
5854         return byId.get(fieldId);
5855       }
5856 
5857       /**
5858        * Find the _Fields constant that matches fieldId, throwing an exception
5859        * if it is not found.
5860        */
5861       public static _Fields findByThriftIdOrThrow(int fieldId) {
5862         _Fields fields = findByThriftId(fieldId);
5863         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
5864         return fields;
5865       }
5866 
5867       /**
5868        * Find the _Fields constant that matches name, or null if its not found.
5869        */
5870       public static _Fields findByName(String name) {
5871         return byName.get(name);
5872       }
5873 
5874       private final short _thriftId;
5875       private final String _fieldName;
5876 
5877       _Fields(short thriftId, String fieldName) {
5878         _thriftId = thriftId;
5879         _fieldName = fieldName;
5880       }
5881 
5882       public short getThriftFieldId() {
5883         return _thriftId;
5884       }
5885 
5886       public String getFieldName() {
5887         return _fieldName;
5888       }
5889     }
5890     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
5891     }});
5892 
5893     static {
5894       FieldMetaData.addStructMetaDataMap(getTableNames_args.class, metaDataMap);
5895     }
5896 
5897     public getTableNames_args() {
5898     }
5899 
5900     /**
5901      * Performs a deep copy on <i>other</i>.
5902      */
5903     public getTableNames_args(getTableNames_args other) {
5904     }
5905 
5906     public getTableNames_args deepCopy() {
5907       return new getTableNames_args(this);
5908     }
5909 
5910     @Deprecated
5911     public getTableNames_args clone() {
5912       return new getTableNames_args(this);
5913     }
5914 
5915     public void setFieldValue(_Fields field, Object value) {
5916       switch (field) {
5917       }
5918     }
5919 
5920     public void setFieldValue(int fieldID, Object value) {
5921       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
5922     }
5923 
5924     public Object getFieldValue(_Fields field) {
5925       switch (field) {
5926       }
5927       throw new IllegalStateException();
5928     }
5929 
5930     public Object getFieldValue(int fieldId) {
5931       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
5932     }
5933 
5934     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
5935     public boolean isSet(_Fields field) {
5936       switch (field) {
5937       }
5938       throw new IllegalStateException();
5939     }
5940 
5941     public boolean isSet(int fieldID) {
5942       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
5943     }
5944 
5945     @Override
5946     public boolean equals(Object that) {
5947       if (that == null)
5948         return false;
5949       if (that instanceof getTableNames_args)
5950         return this.equals((getTableNames_args)that);
5951       return false;
5952     }
5953 
5954     public boolean equals(getTableNames_args that) {
5955       if (that == null)
5956         return false;
5957 
5958       return true;
5959     }
5960 
5961     @Override
5962     public int hashCode() {
5963       HashCodeBuilder builder = new HashCodeBuilder();
5964 
5965       return builder.toHashCode();
5966     }
5967 
5968     public int compareTo(getTableNames_args other) {
5969       if (!getClass().equals(other.getClass())) {
5970         return getClass().getName().compareTo(other.getClass().getName());
5971       }
5972 
5973       int lastComparison = 0;
5974       getTableNames_args typedOther = (getTableNames_args)other;
5975 
5976       return 0;
5977     }
5978 
5979     public void read(TProtocol iprot) throws TException {
5980       TField field;
5981       iprot.readStructBegin();
5982       while (true)
5983       {
5984         field = iprot.readFieldBegin();
5985         if (field.type == TType.STOP) {
5986           break;
5987         }
5988         _Fields fieldId = _Fields.findByThriftId(field.id);
5989         if (fieldId == null) {
5990           TProtocolUtil.skip(iprot, field.type);
5991         } else {
5992           switch (fieldId) {
5993           }
5994           iprot.readFieldEnd();
5995         }
5996       }
5997       iprot.readStructEnd();
5998 
5999       // check for required fields of primitive type, which can't be checked in the validate method
6000       validate();
6001     }
6002 
6003     public void write(TProtocol oprot) throws TException {
6004       validate();
6005 
6006       oprot.writeStructBegin(STRUCT_DESC);
6007       oprot.writeFieldStop();
6008       oprot.writeStructEnd();
6009     }
6010 
6011     @Override
6012     public String toString() {
6013       StringBuilder sb = new StringBuilder("getTableNames_args(");
6014       boolean first = true;
6015 
6016       sb.append(")");
6017       return sb.toString();
6018     }
6019 
6020     public void validate() throws TException {
6021       // check for required fields
6022     }
6023 
6024   }
6025 
6026   public static class getTableNames_result implements TBase<getTableNames_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableNames_result>   {
6027     private static final TStruct STRUCT_DESC = new TStruct("getTableNames_result");
6028 
6029     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
6030     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
6031 
6032     public List<byte[]> success;
6033     public IOError io;
6034 
6035     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
6036     public enum _Fields implements TFieldIdEnum {
6037       SUCCESS((short)0, "success"),
6038       IO((short)1, "io");
6039 
6040       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6041       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6042 
6043       static {
6044         for (_Fields field : EnumSet.allOf(_Fields.class)) {
6045           byId.put((int)field._thriftId, field);
6046           byName.put(field.getFieldName(), field);
6047         }
6048       }
6049 
6050       /**
6051        * Find the _Fields constant that matches fieldId, or null if its not found.
6052        */
6053       public static _Fields findByThriftId(int fieldId) {
6054         return byId.get(fieldId);
6055       }
6056 
6057       /**
6058        * Find the _Fields constant that matches fieldId, throwing an exception
6059        * if it is not found.
6060        */
6061       public static _Fields findByThriftIdOrThrow(int fieldId) {
6062         _Fields fields = findByThriftId(fieldId);
6063         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6064         return fields;
6065       }
6066 
6067       /**
6068        * Find the _Fields constant that matches name, or null if its not found.
6069        */
6070       public static _Fields findByName(String name) {
6071         return byName.get(name);
6072       }
6073 
6074       private final short _thriftId;
6075       private final String _fieldName;
6076 
6077       _Fields(short thriftId, String fieldName) {
6078         _thriftId = thriftId;
6079         _fieldName = fieldName;
6080       }
6081 
6082       public short getThriftFieldId() {
6083         return _thriftId;
6084       }
6085 
6086       public String getFieldName() {
6087         return _fieldName;
6088       }
6089     }
6090 
6091     // isset id assignments
6092 
6093     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6094       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
6095           new ListMetaData(TType.LIST,
6096               new FieldValueMetaData(TType.STRING))));
6097       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
6098           new FieldValueMetaData(TType.STRUCT)));
6099     }});
6100 
6101     static {
6102       FieldMetaData.addStructMetaDataMap(getTableNames_result.class, metaDataMap);
6103     }
6104 
6105     public getTableNames_result() {
6106     }
6107 
6108     public getTableNames_result(
6109       List<byte[]> success,
6110       IOError io)
6111     {
6112       this();
6113       this.success = success;
6114       this.io = io;
6115     }
6116 
6117     /**
6118      * Performs a deep copy on <i>other</i>.
6119      */
6120     public getTableNames_result(getTableNames_result other) {
6121       if (other.isSetSuccess()) {
6122         List<byte[]> __this__success = new ArrayList<byte[]>();
6123         for (byte[] other_element : other.success) {
6124           __this__success.add(other_element);
6125         }
6126         this.success = __this__success;
6127       }
6128       if (other.isSetIo()) {
6129         this.io = new IOError(other.io);
6130       }
6131     }
6132 
6133     public getTableNames_result deepCopy() {
6134       return new getTableNames_result(this);
6135     }
6136 
6137     @Deprecated
6138     public getTableNames_result clone() {
6139       return new getTableNames_result(this);
6140     }
6141 
6142     public int getSuccessSize() {
6143       return (this.success == null) ? 0 : this.success.size();
6144     }
6145 
6146     public java.util.Iterator<byte[]> getSuccessIterator() {
6147       return (this.success == null) ? null : this.success.iterator();
6148     }
6149 
6150     public void addToSuccess(byte[] elem) {
6151       if (this.success == null) {
6152         this.success = new ArrayList<byte[]>();
6153       }
6154       this.success.add(elem);
6155     }
6156 
6157     public List<byte[]> getSuccess() {
6158       return this.success;
6159     }
6160 
6161     public getTableNames_result setSuccess(List<byte[]> success) {
6162       this.success = success;
6163       return this;
6164     }
6165 
6166     public void unsetSuccess() {
6167       this.success = null;
6168     }
6169 
6170     /** Returns true if field success is set (has been asigned a value) and false otherwise */
6171     public boolean isSetSuccess() {
6172       return this.success != null;
6173     }
6174 
6175     public void setSuccessIsSet(boolean value) {
6176       if (!value) {
6177         this.success = null;
6178       }
6179     }
6180 
6181     public IOError getIo() {
6182       return this.io;
6183     }
6184 
6185     public getTableNames_result setIo(IOError io) {
6186       this.io = io;
6187       return this;
6188     }
6189 
6190     public void unsetIo() {
6191       this.io = null;
6192     }
6193 
6194     /** Returns true if field io is set (has been asigned a value) and false otherwise */
6195     public boolean isSetIo() {
6196       return this.io != null;
6197     }
6198 
6199     public void setIoIsSet(boolean value) {
6200       if (!value) {
6201         this.io = null;
6202       }
6203     }
6204 
6205     public void setFieldValue(_Fields field, Object value) {
6206       switch (field) {
6207       case SUCCESS:
6208         if (value == null) {
6209           unsetSuccess();
6210         } else {
6211           setSuccess((List<byte[]>)value);
6212         }
6213         break;
6214 
6215       case IO:
6216         if (value == null) {
6217           unsetIo();
6218         } else {
6219           setIo((IOError)value);
6220         }
6221         break;
6222 
6223       }
6224     }
6225 
6226     public void setFieldValue(int fieldID, Object value) {
6227       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6228     }
6229 
6230     public Object getFieldValue(_Fields field) {
6231       switch (field) {
6232       case SUCCESS:
6233         return getSuccess();
6234 
6235       case IO:
6236         return getIo();
6237 
6238       }
6239       throw new IllegalStateException();
6240     }
6241 
6242     public Object getFieldValue(int fieldId) {
6243       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6244     }
6245 
6246     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
6247     public boolean isSet(_Fields field) {
6248       switch (field) {
6249       case SUCCESS:
6250         return isSetSuccess();
6251       case IO:
6252         return isSetIo();
6253       }
6254       throw new IllegalStateException();
6255     }
6256 
6257     public boolean isSet(int fieldID) {
6258       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6259     }
6260 
6261     @Override
6262     public boolean equals(Object that) {
6263       if (that == null)
6264         return false;
6265       if (that instanceof getTableNames_result)
6266         return this.equals((getTableNames_result)that);
6267       return false;
6268     }
6269 
6270     public boolean equals(getTableNames_result that) {
6271       if (that == null)
6272         return false;
6273 
6274       boolean this_present_success = true && this.isSetSuccess();
6275       boolean that_present_success = true && that.isSetSuccess();
6276       if (this_present_success || that_present_success) {
6277         if (!(this_present_success && that_present_success))
6278           return false;
6279         if (!this.success.equals(that.success))
6280           return false;
6281       }
6282 
6283       boolean this_present_io = true && this.isSetIo();
6284       boolean that_present_io = true && that.isSetIo();
6285       if (this_present_io || that_present_io) {
6286         if (!(this_present_io && that_present_io))
6287           return false;
6288         if (!this.io.equals(that.io))
6289           return false;
6290       }
6291 
6292       return true;
6293     }
6294 
6295     @Override
6296     public int hashCode() {
6297       HashCodeBuilder builder = new HashCodeBuilder();
6298 
6299       boolean present_success = true && (isSetSuccess());
6300       builder.append(present_success);
6301       if (present_success)
6302         builder.append(success);
6303 
6304       boolean present_io = true && (isSetIo());
6305       builder.append(present_io);
6306       if (present_io)
6307         builder.append(io);
6308 
6309       return builder.toHashCode();
6310     }
6311 
6312     public int compareTo(getTableNames_result other) {
6313       if (!getClass().equals(other.getClass())) {
6314         return getClass().getName().compareTo(other.getClass().getName());
6315       }
6316 
6317       int lastComparison = 0;
6318       getTableNames_result typedOther = (getTableNames_result)other;
6319 
6320       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
6321       if (lastComparison != 0) {
6322         return lastComparison;
6323       }
6324       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
6325       if (lastComparison != 0) {
6326         return lastComparison;
6327       }
6328       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
6329       if (lastComparison != 0) {
6330         return lastComparison;
6331       }
6332       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
6333       if (lastComparison != 0) {
6334         return lastComparison;
6335       }
6336       return 0;
6337     }
6338 
6339     public void read(TProtocol iprot) throws TException {
6340       TField field;
6341       iprot.readStructBegin();
6342       while (true)
6343       {
6344         field = iprot.readFieldBegin();
6345         if (field.type == TType.STOP) {
6346           break;
6347         }
6348         _Fields fieldId = _Fields.findByThriftId(field.id);
6349         if (fieldId == null) {
6350           TProtocolUtil.skip(iprot, field.type);
6351         } else {
6352           switch (fieldId) {
6353             case SUCCESS:
6354               if (field.type == TType.LIST) {
6355                 {
6356                   TList _list9 = iprot.readListBegin();
6357                   this.success = new ArrayList<byte[]>(_list9.size);
6358                   for (int _i10 = 0; _i10 < _list9.size; ++_i10)
6359                   {
6360                     byte[] _elem11;
6361                     _elem11 = iprot.readBinary();
6362                     this.success.add(_elem11);
6363                   }
6364                   iprot.readListEnd();
6365                 }
6366               } else {
6367                 TProtocolUtil.skip(iprot, field.type);
6368               }
6369               break;
6370             case IO:
6371               if (field.type == TType.STRUCT) {
6372                 this.io = new IOError();
6373                 this.io.read(iprot);
6374               } else {
6375                 TProtocolUtil.skip(iprot, field.type);
6376               }
6377               break;
6378           }
6379           iprot.readFieldEnd();
6380         }
6381       }
6382       iprot.readStructEnd();
6383 
6384       // check for required fields of primitive type, which can't be checked in the validate method
6385       validate();
6386     }
6387 
6388     public void write(TProtocol oprot) throws TException {
6389       oprot.writeStructBegin(STRUCT_DESC);
6390 
6391       if (this.isSetSuccess()) {
6392         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6393         {
6394           oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
6395           for (byte[] _iter12 : this.success)
6396           {
6397             oprot.writeBinary(_iter12);
6398           }
6399           oprot.writeListEnd();
6400         }
6401         oprot.writeFieldEnd();
6402       } else if (this.isSetIo()) {
6403         oprot.writeFieldBegin(IO_FIELD_DESC);
6404         this.io.write(oprot);
6405         oprot.writeFieldEnd();
6406       }
6407       oprot.writeFieldStop();
6408       oprot.writeStructEnd();
6409     }
6410 
6411     @Override
6412     public String toString() {
6413       StringBuilder sb = new StringBuilder("getTableNames_result(");
6414       boolean first = true;
6415 
6416       sb.append("success:");
6417       if (this.success == null) {
6418         sb.append("null");
6419       } else {
6420         sb.append(this.success);
6421       }
6422       first = false;
6423       if (!first) sb.append(", ");
6424       sb.append("io:");
6425       if (this.io == null) {
6426         sb.append("null");
6427       } else {
6428         sb.append(this.io);
6429       }
6430       first = false;
6431       sb.append(")");
6432       return sb.toString();
6433     }
6434 
6435     public void validate() throws TException {
6436       // check for required fields
6437     }
6438 
6439   }
6440 
6441   public static class getColumnDescriptors_args implements TBase<getColumnDescriptors_args._Fields>, java.io.Serializable, Cloneable, Comparable<getColumnDescriptors_args>   {
6442     private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_args");
6443 
6444     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
6445 
6446     /**
6447      * table name
6448      */
6449     public byte[] tableName;
6450 
6451     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
6452     public enum _Fields implements TFieldIdEnum {
6453       /**
6454        * table name
6455        */
6456       TABLE_NAME((short)1, "tableName");
6457 
6458       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6459       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6460 
6461       static {
6462         for (_Fields field : EnumSet.allOf(_Fields.class)) {
6463           byId.put((int)field._thriftId, field);
6464           byName.put(field.getFieldName(), field);
6465         }
6466       }
6467 
6468       /**
6469        * Find the _Fields constant that matches fieldId, or null if its not found.
6470        */
6471       public static _Fields findByThriftId(int fieldId) {
6472         return byId.get(fieldId);
6473       }
6474 
6475       /**
6476        * Find the _Fields constant that matches fieldId, throwing an exception
6477        * if it is not found.
6478        */
6479       public static _Fields findByThriftIdOrThrow(int fieldId) {
6480         _Fields fields = findByThriftId(fieldId);
6481         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6482         return fields;
6483       }
6484 
6485       /**
6486        * Find the _Fields constant that matches name, or null if its not found.
6487        */
6488       public static _Fields findByName(String name) {
6489         return byName.get(name);
6490       }
6491 
6492       private final short _thriftId;
6493       private final String _fieldName;
6494 
6495       _Fields(short thriftId, String fieldName) {
6496         _thriftId = thriftId;
6497         _fieldName = fieldName;
6498       }
6499 
6500       public short getThriftFieldId() {
6501         return _thriftId;
6502       }
6503 
6504       public String getFieldName() {
6505         return _fieldName;
6506       }
6507     }
6508 
6509     // isset id assignments
6510 
6511     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6512       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
6513           new FieldValueMetaData(TType.STRING)));
6514     }});
6515 
6516     static {
6517       FieldMetaData.addStructMetaDataMap(getColumnDescriptors_args.class, metaDataMap);
6518     }
6519 
6520     public getColumnDescriptors_args() {
6521     }
6522 
6523     public getColumnDescriptors_args(
6524       byte[] tableName)
6525     {
6526       this();
6527       this.tableName = tableName;
6528     }
6529 
6530     /**
6531      * Performs a deep copy on <i>other</i>.
6532      */
6533     public getColumnDescriptors_args(getColumnDescriptors_args other) {
6534       if (other.isSetTableName()) {
6535         this.tableName = other.tableName;
6536       }
6537     }
6538 
6539     public getColumnDescriptors_args deepCopy() {
6540       return new getColumnDescriptors_args(this);
6541     }
6542 
6543     @Deprecated
6544     public getColumnDescriptors_args clone() {
6545       return new getColumnDescriptors_args(this);
6546     }
6547 
6548     /**
6549      * table name
6550      */
6551     public byte[] getTableName() {
6552       return this.tableName;
6553     }
6554 
6555     /**
6556      * table name
6557      */
6558     public getColumnDescriptors_args setTableName(byte[] tableName) {
6559       this.tableName = tableName;
6560       return this;
6561     }
6562 
6563     public void unsetTableName() {
6564       this.tableName = null;
6565     }
6566 
6567     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
6568     public boolean isSetTableName() {
6569       return this.tableName != null;
6570     }
6571 
6572     public void setTableNameIsSet(boolean value) {
6573       if (!value) {
6574         this.tableName = null;
6575       }
6576     }
6577 
6578     public void setFieldValue(_Fields field, Object value) {
6579       switch (field) {
6580       case TABLE_NAME:
6581         if (value == null) {
6582           unsetTableName();
6583         } else {
6584           setTableName((byte[])value);
6585         }
6586         break;
6587 
6588       }
6589     }
6590 
6591     public void setFieldValue(int fieldID, Object value) {
6592       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6593     }
6594 
6595     public Object getFieldValue(_Fields field) {
6596       switch (field) {
6597       case TABLE_NAME:
6598         return getTableName();
6599 
6600       }
6601       throw new IllegalStateException();
6602     }
6603 
6604     public Object getFieldValue(int fieldId) {
6605       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6606     }
6607 
6608     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
6609     public boolean isSet(_Fields field) {
6610       switch (field) {
6611       case TABLE_NAME:
6612         return isSetTableName();
6613       }
6614       throw new IllegalStateException();
6615     }
6616 
6617     public boolean isSet(int fieldID) {
6618       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6619     }
6620 
6621     @Override
6622     public boolean equals(Object that) {
6623       if (that == null)
6624         return false;
6625       if (that instanceof getColumnDescriptors_args)
6626         return this.equals((getColumnDescriptors_args)that);
6627       return false;
6628     }
6629 
6630     public boolean equals(getColumnDescriptors_args that) {
6631       if (that == null)
6632         return false;
6633 
6634       boolean this_present_tableName = true && this.isSetTableName();
6635       boolean that_present_tableName = true && that.isSetTableName();
6636       if (this_present_tableName || that_present_tableName) {
6637         if (!(this_present_tableName && that_present_tableName))
6638           return false;
6639         if (!java.util.Arrays.equals(this.tableName, that.tableName))
6640           return false;
6641       }
6642 
6643       return true;
6644     }
6645 
6646     @Override
6647     public int hashCode() {
6648       HashCodeBuilder builder = new HashCodeBuilder();
6649 
6650       boolean present_tableName = true && (isSetTableName());
6651       builder.append(present_tableName);
6652       if (present_tableName)
6653         builder.append(tableName);
6654 
6655       return builder.toHashCode();
6656     }
6657 
6658     public int compareTo(getColumnDescriptors_args other) {
6659       if (!getClass().equals(other.getClass())) {
6660         return getClass().getName().compareTo(other.getClass().getName());
6661       }
6662 
6663       int lastComparison = 0;
6664       getColumnDescriptors_args typedOther = (getColumnDescriptors_args)other;
6665 
6666       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
6667       if (lastComparison != 0) {
6668         return lastComparison;
6669       }
6670       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
6671       if (lastComparison != 0) {
6672         return lastComparison;
6673       }
6674       return 0;
6675     }
6676 
6677     public void read(TProtocol iprot) throws TException {
6678       TField field;
6679       iprot.readStructBegin();
6680       while (true)
6681       {
6682         field = iprot.readFieldBegin();
6683         if (field.type == TType.STOP) {
6684           break;
6685         }
6686         _Fields fieldId = _Fields.findByThriftId(field.id);
6687         if (fieldId == null) {
6688           TProtocolUtil.skip(iprot, field.type);
6689         } else {
6690           switch (fieldId) {
6691             case TABLE_NAME:
6692               if (field.type == TType.STRING) {
6693                 this.tableName = iprot.readBinary();
6694               } else {
6695                 TProtocolUtil.skip(iprot, field.type);
6696               }
6697               break;
6698           }
6699           iprot.readFieldEnd();
6700         }
6701       }
6702       iprot.readStructEnd();
6703 
6704       // check for required fields of primitive type, which can't be checked in the validate method
6705       validate();
6706     }
6707 
6708     public void write(TProtocol oprot) throws TException {
6709       validate();
6710 
6711       oprot.writeStructBegin(STRUCT_DESC);
6712       if (this.tableName != null) {
6713         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
6714         oprot.writeBinary(this.tableName);
6715         oprot.writeFieldEnd();
6716       }
6717       oprot.writeFieldStop();
6718       oprot.writeStructEnd();
6719     }
6720 
6721     @Override
6722     public String toString() {
6723       StringBuilder sb = new StringBuilder("getColumnDescriptors_args(");
6724       boolean first = true;
6725 
6726       sb.append("tableName:");
6727       if (this.tableName == null) {
6728         sb.append("null");
6729       } else {
6730         sb.append(this.tableName);
6731       }
6732       first = false;
6733       sb.append(")");
6734       return sb.toString();
6735     }
6736 
6737     public void validate() throws TException {
6738       // check for required fields
6739     }
6740 
6741   }
6742 
6743   public static class getColumnDescriptors_result implements TBase<getColumnDescriptors_result._Fields>, java.io.Serializable, Cloneable   {
6744     private static final TStruct STRUCT_DESC = new TStruct("getColumnDescriptors_result");
6745 
6746     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.MAP, (short)0);
6747     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
6748 
6749     public Map<byte[],ColumnDescriptor> success;
6750     public IOError io;
6751 
6752     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
6753     public enum _Fields implements TFieldIdEnum {
6754       SUCCESS((short)0, "success"),
6755       IO((short)1, "io");
6756 
6757       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
6758       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
6759 
6760       static {
6761         for (_Fields field : EnumSet.allOf(_Fields.class)) {
6762           byId.put((int)field._thriftId, field);
6763           byName.put(field.getFieldName(), field);
6764         }
6765       }
6766 
6767       /**
6768        * Find the _Fields constant that matches fieldId, or null if its not found.
6769        */
6770       public static _Fields findByThriftId(int fieldId) {
6771         return byId.get(fieldId);
6772       }
6773 
6774       /**
6775        * Find the _Fields constant that matches fieldId, throwing an exception
6776        * if it is not found.
6777        */
6778       public static _Fields findByThriftIdOrThrow(int fieldId) {
6779         _Fields fields = findByThriftId(fieldId);
6780         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
6781         return fields;
6782       }
6783 
6784       /**
6785        * Find the _Fields constant that matches name, or null if its not found.
6786        */
6787       public static _Fields findByName(String name) {
6788         return byName.get(name);
6789       }
6790 
6791       private final short _thriftId;
6792       private final String _fieldName;
6793 
6794       _Fields(short thriftId, String fieldName) {
6795         _thriftId = thriftId;
6796         _fieldName = fieldName;
6797       }
6798 
6799       public short getThriftFieldId() {
6800         return _thriftId;
6801       }
6802 
6803       public String getFieldName() {
6804         return _fieldName;
6805       }
6806     }
6807 
6808     // isset id assignments
6809 
6810     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
6811       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
6812           new MapMetaData(TType.MAP,
6813               new FieldValueMetaData(TType.STRING),
6814               new StructMetaData(TType.STRUCT, ColumnDescriptor.class))));
6815       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
6816           new FieldValueMetaData(TType.STRUCT)));
6817     }});
6818 
6819     static {
6820       FieldMetaData.addStructMetaDataMap(getColumnDescriptors_result.class, metaDataMap);
6821     }
6822 
6823     public getColumnDescriptors_result() {
6824     }
6825 
6826     public getColumnDescriptors_result(
6827       Map<byte[],ColumnDescriptor> success,
6828       IOError io)
6829     {
6830       this();
6831       this.success = success;
6832       this.io = io;
6833     }
6834 
6835     /**
6836      * Performs a deep copy on <i>other</i>.
6837      */
6838     public getColumnDescriptors_result(getColumnDescriptors_result other) {
6839       if (other.isSetSuccess()) {
6840         Map<byte[],ColumnDescriptor> __this__success = new HashMap<byte[],ColumnDescriptor>();
6841         for (Map.Entry<byte[], ColumnDescriptor> other_element : other.success.entrySet()) {
6842 
6843           byte[] other_element_key = other_element.getKey();
6844           ColumnDescriptor other_element_value = other_element.getValue();
6845 
6846           byte[] __this__success_copy_key = other_element_key;
6847 
6848           ColumnDescriptor __this__success_copy_value = new ColumnDescriptor(other_element_value);
6849 
6850           __this__success.put(__this__success_copy_key, __this__success_copy_value);
6851         }
6852         this.success = __this__success;
6853       }
6854       if (other.isSetIo()) {
6855         this.io = new IOError(other.io);
6856       }
6857     }
6858 
6859     public getColumnDescriptors_result deepCopy() {
6860       return new getColumnDescriptors_result(this);
6861     }
6862 
6863     @Deprecated
6864     public getColumnDescriptors_result clone() {
6865       return new getColumnDescriptors_result(this);
6866     }
6867 
6868     public int getSuccessSize() {
6869       return (this.success == null) ? 0 : this.success.size();
6870     }
6871 
6872     public void putToSuccess(byte[] key, ColumnDescriptor val) {
6873       if (this.success == null) {
6874         this.success = new HashMap<byte[],ColumnDescriptor>();
6875       }
6876       this.success.put(key, val);
6877     }
6878 
6879     public Map<byte[],ColumnDescriptor> getSuccess() {
6880       return this.success;
6881     }
6882 
6883     public getColumnDescriptors_result setSuccess(Map<byte[],ColumnDescriptor> success) {
6884       this.success = success;
6885       return this;
6886     }
6887 
6888     public void unsetSuccess() {
6889       this.success = null;
6890     }
6891 
6892     /** Returns true if field success is set (has been asigned a value) and false otherwise */
6893     public boolean isSetSuccess() {
6894       return this.success != null;
6895     }
6896 
6897     public void setSuccessIsSet(boolean value) {
6898       if (!value) {
6899         this.success = null;
6900       }
6901     }
6902 
6903     public IOError getIo() {
6904       return this.io;
6905     }
6906 
6907     public getColumnDescriptors_result setIo(IOError io) {
6908       this.io = io;
6909       return this;
6910     }
6911 
6912     public void unsetIo() {
6913       this.io = null;
6914     }
6915 
6916     /** Returns true if field io is set (has been asigned a value) and false otherwise */
6917     public boolean isSetIo() {
6918       return this.io != null;
6919     }
6920 
6921     public void setIoIsSet(boolean value) {
6922       if (!value) {
6923         this.io = null;
6924       }
6925     }
6926 
6927     public void setFieldValue(_Fields field, Object value) {
6928       switch (field) {
6929       case SUCCESS:
6930         if (value == null) {
6931           unsetSuccess();
6932         } else {
6933           setSuccess((Map<byte[],ColumnDescriptor>)value);
6934         }
6935         break;
6936 
6937       case IO:
6938         if (value == null) {
6939           unsetIo();
6940         } else {
6941           setIo((IOError)value);
6942         }
6943         break;
6944 
6945       }
6946     }
6947 
6948     public void setFieldValue(int fieldID, Object value) {
6949       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
6950     }
6951 
6952     public Object getFieldValue(_Fields field) {
6953       switch (field) {
6954       case SUCCESS:
6955         return getSuccess();
6956 
6957       case IO:
6958         return getIo();
6959 
6960       }
6961       throw new IllegalStateException();
6962     }
6963 
6964     public Object getFieldValue(int fieldId) {
6965       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
6966     }
6967 
6968     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
6969     public boolean isSet(_Fields field) {
6970       switch (field) {
6971       case SUCCESS:
6972         return isSetSuccess();
6973       case IO:
6974         return isSetIo();
6975       }
6976       throw new IllegalStateException();
6977     }
6978 
6979     public boolean isSet(int fieldID) {
6980       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
6981     }
6982 
6983     @Override
6984     public boolean equals(Object that) {
6985       if (that == null)
6986         return false;
6987       if (that instanceof getColumnDescriptors_result)
6988         return this.equals((getColumnDescriptors_result)that);
6989       return false;
6990     }
6991 
6992     public boolean equals(getColumnDescriptors_result that) {
6993       if (that == null)
6994         return false;
6995 
6996       boolean this_present_success = true && this.isSetSuccess();
6997       boolean that_present_success = true && that.isSetSuccess();
6998       if (this_present_success || that_present_success) {
6999         if (!(this_present_success && that_present_success))
7000           return false;
7001         if (!this.success.equals(that.success))
7002           return false;
7003       }
7004 
7005       boolean this_present_io = true && this.isSetIo();
7006       boolean that_present_io = true && that.isSetIo();
7007       if (this_present_io || that_present_io) {
7008         if (!(this_present_io && that_present_io))
7009           return false;
7010         if (!this.io.equals(that.io))
7011           return false;
7012       }
7013 
7014       return true;
7015     }
7016 
7017     @Override
7018     public int hashCode() {
7019       HashCodeBuilder builder = new HashCodeBuilder();
7020 
7021       boolean present_success = true && (isSetSuccess());
7022       builder.append(present_success);
7023       if (present_success)
7024         builder.append(success);
7025 
7026       boolean present_io = true && (isSetIo());
7027       builder.append(present_io);
7028       if (present_io)
7029         builder.append(io);
7030 
7031       return builder.toHashCode();
7032     }
7033 
7034     public void read(TProtocol iprot) throws TException {
7035       TField field;
7036       iprot.readStructBegin();
7037       while (true)
7038       {
7039         field = iprot.readFieldBegin();
7040         if (field.type == TType.STOP) {
7041           break;
7042         }
7043         _Fields fieldId = _Fields.findByThriftId(field.id);
7044         if (fieldId == null) {
7045           TProtocolUtil.skip(iprot, field.type);
7046         } else {
7047           switch (fieldId) {
7048             case SUCCESS:
7049               if (field.type == TType.MAP) {
7050                 {
7051                   TMap _map13 = iprot.readMapBegin();
7052                   this.success = new HashMap<byte[],ColumnDescriptor>(2*_map13.size);
7053                   for (int _i14 = 0; _i14 < _map13.size; ++_i14)
7054                   {
7055                     byte[] _key15;
7056                     ColumnDescriptor _val16;
7057                     _key15 = iprot.readBinary();
7058                     _val16 = new ColumnDescriptor();
7059                     _val16.read(iprot);
7060                     this.success.put(_key15, _val16);
7061                   }
7062                   iprot.readMapEnd();
7063                 }
7064               } else {
7065                 TProtocolUtil.skip(iprot, field.type);
7066               }
7067               break;
7068             case IO:
7069               if (field.type == TType.STRUCT) {
7070                 this.io = new IOError();
7071                 this.io.read(iprot);
7072               } else {
7073                 TProtocolUtil.skip(iprot, field.type);
7074               }
7075               break;
7076           }
7077           iprot.readFieldEnd();
7078         }
7079       }
7080       iprot.readStructEnd();
7081 
7082       // check for required fields of primitive type, which can't be checked in the validate method
7083       validate();
7084     }
7085 
7086     public void write(TProtocol oprot) throws TException {
7087       oprot.writeStructBegin(STRUCT_DESC);
7088 
7089       if (this.isSetSuccess()) {
7090         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
7091         {
7092           oprot.writeMapBegin(new TMap(TType.STRING, TType.STRUCT, this.success.size()));
7093           for (Map.Entry<byte[], ColumnDescriptor> _iter17 : this.success.entrySet())
7094           {
7095             oprot.writeBinary(_iter17.getKey());
7096             _iter17.getValue().write(oprot);
7097           }
7098           oprot.writeMapEnd();
7099         }
7100         oprot.writeFieldEnd();
7101       } else if (this.isSetIo()) {
7102         oprot.writeFieldBegin(IO_FIELD_DESC);
7103         this.io.write(oprot);
7104         oprot.writeFieldEnd();
7105       }
7106       oprot.writeFieldStop();
7107       oprot.writeStructEnd();
7108     }
7109 
7110     @Override
7111     public String toString() {
7112       StringBuilder sb = new StringBuilder("getColumnDescriptors_result(");
7113       boolean first = true;
7114 
7115       sb.append("success:");
7116       if (this.success == null) {
7117         sb.append("null");
7118       } else {
7119         sb.append(this.success);
7120       }
7121       first = false;
7122       if (!first) sb.append(", ");
7123       sb.append("io:");
7124       if (this.io == null) {
7125         sb.append("null");
7126       } else {
7127         sb.append(this.io);
7128       }
7129       first = false;
7130       sb.append(")");
7131       return sb.toString();
7132     }
7133 
7134     public void validate() throws TException {
7135       // check for required fields
7136     }
7137 
7138   }
7139 
7140   public static class getTableRegions_args implements TBase<getTableRegions_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_args>   {
7141     private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_args");
7142 
7143     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
7144 
7145     /**
7146      * table name
7147      */
7148     public byte[] tableName;
7149 
7150     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
7151     public enum _Fields implements TFieldIdEnum {
7152       /**
7153        * table name
7154        */
7155       TABLE_NAME((short)1, "tableName");
7156 
7157       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7158       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7159 
7160       static {
7161         for (_Fields field : EnumSet.allOf(_Fields.class)) {
7162           byId.put((int)field._thriftId, field);
7163           byName.put(field.getFieldName(), field);
7164         }
7165       }
7166 
7167       /**
7168        * Find the _Fields constant that matches fieldId, or null if its not found.
7169        */
7170       public static _Fields findByThriftId(int fieldId) {
7171         return byId.get(fieldId);
7172       }
7173 
7174       /**
7175        * Find the _Fields constant that matches fieldId, throwing an exception
7176        * if it is not found.
7177        */
7178       public static _Fields findByThriftIdOrThrow(int fieldId) {
7179         _Fields fields = findByThriftId(fieldId);
7180         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7181         return fields;
7182       }
7183 
7184       /**
7185        * Find the _Fields constant that matches name, or null if its not found.
7186        */
7187       public static _Fields findByName(String name) {
7188         return byName.get(name);
7189       }
7190 
7191       private final short _thriftId;
7192       private final String _fieldName;
7193 
7194       _Fields(short thriftId, String fieldName) {
7195         _thriftId = thriftId;
7196         _fieldName = fieldName;
7197       }
7198 
7199       public short getThriftFieldId() {
7200         return _thriftId;
7201       }
7202 
7203       public String getFieldName() {
7204         return _fieldName;
7205       }
7206     }
7207 
7208     // isset id assignments
7209 
7210     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7211       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
7212           new FieldValueMetaData(TType.STRING)));
7213     }});
7214 
7215     static {
7216       FieldMetaData.addStructMetaDataMap(getTableRegions_args.class, metaDataMap);
7217     }
7218 
7219     public getTableRegions_args() {
7220     }
7221 
7222     public getTableRegions_args(
7223       byte[] tableName)
7224     {
7225       this();
7226       this.tableName = tableName;
7227     }
7228 
7229     /**
7230      * Performs a deep copy on <i>other</i>.
7231      */
7232     public getTableRegions_args(getTableRegions_args other) {
7233       if (other.isSetTableName()) {
7234         this.tableName = other.tableName;
7235       }
7236     }
7237 
7238     public getTableRegions_args deepCopy() {
7239       return new getTableRegions_args(this);
7240     }
7241 
7242     @Deprecated
7243     public getTableRegions_args clone() {
7244       return new getTableRegions_args(this);
7245     }
7246 
7247     /**
7248      * table name
7249      */
7250     public byte[] getTableName() {
7251       return this.tableName;
7252     }
7253 
7254     /**
7255      * table name
7256      */
7257     public getTableRegions_args setTableName(byte[] tableName) {
7258       this.tableName = tableName;
7259       return this;
7260     }
7261 
7262     public void unsetTableName() {
7263       this.tableName = null;
7264     }
7265 
7266     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
7267     public boolean isSetTableName() {
7268       return this.tableName != null;
7269     }
7270 
7271     public void setTableNameIsSet(boolean value) {
7272       if (!value) {
7273         this.tableName = null;
7274       }
7275     }
7276 
7277     public void setFieldValue(_Fields field, Object value) {
7278       switch (field) {
7279       case TABLE_NAME:
7280         if (value == null) {
7281           unsetTableName();
7282         } else {
7283           setTableName((byte[])value);
7284         }
7285         break;
7286 
7287       }
7288     }
7289 
7290     public void setFieldValue(int fieldID, Object value) {
7291       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7292     }
7293 
7294     public Object getFieldValue(_Fields field) {
7295       switch (field) {
7296       case TABLE_NAME:
7297         return getTableName();
7298 
7299       }
7300       throw new IllegalStateException();
7301     }
7302 
7303     public Object getFieldValue(int fieldId) {
7304       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7305     }
7306 
7307     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
7308     public boolean isSet(_Fields field) {
7309       switch (field) {
7310       case TABLE_NAME:
7311         return isSetTableName();
7312       }
7313       throw new IllegalStateException();
7314     }
7315 
7316     public boolean isSet(int fieldID) {
7317       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
7318     }
7319 
7320     @Override
7321     public boolean equals(Object that) {
7322       if (that == null)
7323         return false;
7324       if (that instanceof getTableRegions_args)
7325         return this.equals((getTableRegions_args)that);
7326       return false;
7327     }
7328 
7329     public boolean equals(getTableRegions_args that) {
7330       if (that == null)
7331         return false;
7332 
7333       boolean this_present_tableName = true && this.isSetTableName();
7334       boolean that_present_tableName = true && that.isSetTableName();
7335       if (this_present_tableName || that_present_tableName) {
7336         if (!(this_present_tableName && that_present_tableName))
7337           return false;
7338         if (!java.util.Arrays.equals(this.tableName, that.tableName))
7339           return false;
7340       }
7341 
7342       return true;
7343     }
7344 
7345     @Override
7346     public int hashCode() {
7347       HashCodeBuilder builder = new HashCodeBuilder();
7348 
7349       boolean present_tableName = true && (isSetTableName());
7350       builder.append(present_tableName);
7351       if (present_tableName)
7352         builder.append(tableName);
7353 
7354       return builder.toHashCode();
7355     }
7356 
7357     public int compareTo(getTableRegions_args other) {
7358       if (!getClass().equals(other.getClass())) {
7359         return getClass().getName().compareTo(other.getClass().getName());
7360       }
7361 
7362       int lastComparison = 0;
7363       getTableRegions_args typedOther = (getTableRegions_args)other;
7364 
7365       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
7366       if (lastComparison != 0) {
7367         return lastComparison;
7368       }
7369       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
7370       if (lastComparison != 0) {
7371         return lastComparison;
7372       }
7373       return 0;
7374     }
7375 
7376     public void read(TProtocol iprot) throws TException {
7377       TField field;
7378       iprot.readStructBegin();
7379       while (true)
7380       {
7381         field = iprot.readFieldBegin();
7382         if (field.type == TType.STOP) {
7383           break;
7384         }
7385         _Fields fieldId = _Fields.findByThriftId(field.id);
7386         if (fieldId == null) {
7387           TProtocolUtil.skip(iprot, field.type);
7388         } else {
7389           switch (fieldId) {
7390             case TABLE_NAME:
7391               if (field.type == TType.STRING) {
7392                 this.tableName = iprot.readBinary();
7393               } else {
7394                 TProtocolUtil.skip(iprot, field.type);
7395               }
7396               break;
7397           }
7398           iprot.readFieldEnd();
7399         }
7400       }
7401       iprot.readStructEnd();
7402 
7403       // check for required fields of primitive type, which can't be checked in the validate method
7404       validate();
7405     }
7406 
7407     public void write(TProtocol oprot) throws TException {
7408       validate();
7409 
7410       oprot.writeStructBegin(STRUCT_DESC);
7411       if (this.tableName != null) {
7412         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
7413         oprot.writeBinary(this.tableName);
7414         oprot.writeFieldEnd();
7415       }
7416       oprot.writeFieldStop();
7417       oprot.writeStructEnd();
7418     }
7419 
7420     @Override
7421     public String toString() {
7422       StringBuilder sb = new StringBuilder("getTableRegions_args(");
7423       boolean first = true;
7424 
7425       sb.append("tableName:");
7426       if (this.tableName == null) {
7427         sb.append("null");
7428       } else {
7429         sb.append(this.tableName);
7430       }
7431       first = false;
7432       sb.append(")");
7433       return sb.toString();
7434     }
7435 
7436     public void validate() throws TException {
7437       // check for required fields
7438     }
7439 
7440   }
7441 
7442   public static class getTableRegions_result implements TBase<getTableRegions_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTableRegions_result>   {
7443     private static final TStruct STRUCT_DESC = new TStruct("getTableRegions_result");
7444 
7445     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
7446     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
7447 
7448     public List<TRegionInfo> success;
7449     public IOError io;
7450 
7451     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
7452     public enum _Fields implements TFieldIdEnum {
7453       SUCCESS((short)0, "success"),
7454       IO((short)1, "io");
7455 
7456       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7457       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7458 
7459       static {
7460         for (_Fields field : EnumSet.allOf(_Fields.class)) {
7461           byId.put((int)field._thriftId, field);
7462           byName.put(field.getFieldName(), field);
7463         }
7464       }
7465 
7466       /**
7467        * Find the _Fields constant that matches fieldId, or null if its not found.
7468        */
7469       public static _Fields findByThriftId(int fieldId) {
7470         return byId.get(fieldId);
7471       }
7472 
7473       /**
7474        * Find the _Fields constant that matches fieldId, throwing an exception
7475        * if it is not found.
7476        */
7477       public static _Fields findByThriftIdOrThrow(int fieldId) {
7478         _Fields fields = findByThriftId(fieldId);
7479         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7480         return fields;
7481       }
7482 
7483       /**
7484        * Find the _Fields constant that matches name, or null if its not found.
7485        */
7486       public static _Fields findByName(String name) {
7487         return byName.get(name);
7488       }
7489 
7490       private final short _thriftId;
7491       private final String _fieldName;
7492 
7493       _Fields(short thriftId, String fieldName) {
7494         _thriftId = thriftId;
7495         _fieldName = fieldName;
7496       }
7497 
7498       public short getThriftFieldId() {
7499         return _thriftId;
7500       }
7501 
7502       public String getFieldName() {
7503         return _fieldName;
7504       }
7505     }
7506 
7507     // isset id assignments
7508 
7509     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7510       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
7511           new ListMetaData(TType.LIST,
7512               new StructMetaData(TType.STRUCT, TRegionInfo.class))));
7513       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
7514           new FieldValueMetaData(TType.STRUCT)));
7515     }});
7516 
7517     static {
7518       FieldMetaData.addStructMetaDataMap(getTableRegions_result.class, metaDataMap);
7519     }
7520 
7521     public getTableRegions_result() {
7522     }
7523 
7524     public getTableRegions_result(
7525       List<TRegionInfo> success,
7526       IOError io)
7527     {
7528       this();
7529       this.success = success;
7530       this.io = io;
7531     }
7532 
7533     /**
7534      * Performs a deep copy on <i>other</i>.
7535      */
7536     public getTableRegions_result(getTableRegions_result other) {
7537       if (other.isSetSuccess()) {
7538         List<TRegionInfo> __this__success = new ArrayList<TRegionInfo>();
7539         for (TRegionInfo other_element : other.success) {
7540           __this__success.add(new TRegionInfo(other_element));
7541         }
7542         this.success = __this__success;
7543       }
7544       if (other.isSetIo()) {
7545         this.io = new IOError(other.io);
7546       }
7547     }
7548 
7549     public getTableRegions_result deepCopy() {
7550       return new getTableRegions_result(this);
7551     }
7552 
7553     @Deprecated
7554     public getTableRegions_result clone() {
7555       return new getTableRegions_result(this);
7556     }
7557 
7558     public int getSuccessSize() {
7559       return (this.success == null) ? 0 : this.success.size();
7560     }
7561 
7562     public java.util.Iterator<TRegionInfo> getSuccessIterator() {
7563       return (this.success == null) ? null : this.success.iterator();
7564     }
7565 
7566     public void addToSuccess(TRegionInfo elem) {
7567       if (this.success == null) {
7568         this.success = new ArrayList<TRegionInfo>();
7569       }
7570       this.success.add(elem);
7571     }
7572 
7573     public List<TRegionInfo> getSuccess() {
7574       return this.success;
7575     }
7576 
7577     public getTableRegions_result setSuccess(List<TRegionInfo> success) {
7578       this.success = success;
7579       return this;
7580     }
7581 
7582     public void unsetSuccess() {
7583       this.success = null;
7584     }
7585 
7586     /** Returns true if field success is set (has been asigned a value) and false otherwise */
7587     public boolean isSetSuccess() {
7588       return this.success != null;
7589     }
7590 
7591     public void setSuccessIsSet(boolean value) {
7592       if (!value) {
7593         this.success = null;
7594       }
7595     }
7596 
7597     public IOError getIo() {
7598       return this.io;
7599     }
7600 
7601     public getTableRegions_result setIo(IOError io) {
7602       this.io = io;
7603       return this;
7604     }
7605 
7606     public void unsetIo() {
7607       this.io = null;
7608     }
7609 
7610     /** Returns true if field io is set (has been asigned a value) and false otherwise */
7611     public boolean isSetIo() {
7612       return this.io != null;
7613     }
7614 
7615     public void setIoIsSet(boolean value) {
7616       if (!value) {
7617         this.io = null;
7618       }
7619     }
7620 
7621     public void setFieldValue(_Fields field, Object value) {
7622       switch (field) {
7623       case SUCCESS:
7624         if (value == null) {
7625           unsetSuccess();
7626         } else {
7627           setSuccess((List<TRegionInfo>)value);
7628         }
7629         break;
7630 
7631       case IO:
7632         if (value == null) {
7633           unsetIo();
7634         } else {
7635           setIo((IOError)value);
7636         }
7637         break;
7638 
7639       }
7640     }
7641 
7642     public void setFieldValue(int fieldID, Object value) {
7643       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
7644     }
7645 
7646     public Object getFieldValue(_Fields field) {
7647       switch (field) {
7648       case SUCCESS:
7649         return getSuccess();
7650 
7651       case IO:
7652         return getIo();
7653 
7654       }
7655       throw new IllegalStateException();
7656     }
7657 
7658     public Object getFieldValue(int fieldId) {
7659       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
7660     }
7661 
7662     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
7663     public boolean isSet(_Fields field) {
7664       switch (field) {
7665       case SUCCESS:
7666         return isSetSuccess();
7667       case IO:
7668         return isSetIo();
7669       }
7670       throw new IllegalStateException();
7671     }
7672 
7673     public boolean isSet(int fieldID) {
7674       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
7675     }
7676 
7677     @Override
7678     public boolean equals(Object that) {
7679       if (that == null)
7680         return false;
7681       if (that instanceof getTableRegions_result)
7682         return this.equals((getTableRegions_result)that);
7683       return false;
7684     }
7685 
7686     public boolean equals(getTableRegions_result that) {
7687       if (that == null)
7688         return false;
7689 
7690       boolean this_present_success = true && this.isSetSuccess();
7691       boolean that_present_success = true && that.isSetSuccess();
7692       if (this_present_success || that_present_success) {
7693         if (!(this_present_success && that_present_success))
7694           return false;
7695         if (!this.success.equals(that.success))
7696           return false;
7697       }
7698 
7699       boolean this_present_io = true && this.isSetIo();
7700       boolean that_present_io = true && that.isSetIo();
7701       if (this_present_io || that_present_io) {
7702         if (!(this_present_io && that_present_io))
7703           return false;
7704         if (!this.io.equals(that.io))
7705           return false;
7706       }
7707 
7708       return true;
7709     }
7710 
7711     @Override
7712     public int hashCode() {
7713       HashCodeBuilder builder = new HashCodeBuilder();
7714 
7715       boolean present_success = true && (isSetSuccess());
7716       builder.append(present_success);
7717       if (present_success)
7718         builder.append(success);
7719 
7720       boolean present_io = true && (isSetIo());
7721       builder.append(present_io);
7722       if (present_io)
7723         builder.append(io);
7724 
7725       return builder.toHashCode();
7726     }
7727 
7728     public int compareTo(getTableRegions_result other) {
7729       if (!getClass().equals(other.getClass())) {
7730         return getClass().getName().compareTo(other.getClass().getName());
7731       }
7732 
7733       int lastComparison = 0;
7734       getTableRegions_result typedOther = (getTableRegions_result)other;
7735 
7736       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
7737       if (lastComparison != 0) {
7738         return lastComparison;
7739       }
7740       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
7741       if (lastComparison != 0) {
7742         return lastComparison;
7743       }
7744       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
7745       if (lastComparison != 0) {
7746         return lastComparison;
7747       }
7748       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
7749       if (lastComparison != 0) {
7750         return lastComparison;
7751       }
7752       return 0;
7753     }
7754 
7755     public void read(TProtocol iprot) throws TException {
7756       TField field;
7757       iprot.readStructBegin();
7758       while (true)
7759       {
7760         field = iprot.readFieldBegin();
7761         if (field.type == TType.STOP) {
7762           break;
7763         }
7764         _Fields fieldId = _Fields.findByThriftId(field.id);
7765         if (fieldId == null) {
7766           TProtocolUtil.skip(iprot, field.type);
7767         } else {
7768           switch (fieldId) {
7769             case SUCCESS:
7770               if (field.type == TType.LIST) {
7771                 {
7772                   TList _list18 = iprot.readListBegin();
7773                   this.success = new ArrayList<TRegionInfo>(_list18.size);
7774                   for (int _i19 = 0; _i19 < _list18.size; ++_i19)
7775                   {
7776                     TRegionInfo _elem20;
7777                     _elem20 = new TRegionInfo();
7778                     _elem20.read(iprot);
7779                     this.success.add(_elem20);
7780                   }
7781                   iprot.readListEnd();
7782                 }
7783               } else {
7784                 TProtocolUtil.skip(iprot, field.type);
7785               }
7786               break;
7787             case IO:
7788               if (field.type == TType.STRUCT) {
7789                 this.io = new IOError();
7790                 this.io.read(iprot);
7791               } else {
7792                 TProtocolUtil.skip(iprot, field.type);
7793               }
7794               break;
7795           }
7796           iprot.readFieldEnd();
7797         }
7798       }
7799       iprot.readStructEnd();
7800 
7801       // check for required fields of primitive type, which can't be checked in the validate method
7802       validate();
7803     }
7804 
7805     public void write(TProtocol oprot) throws TException {
7806       oprot.writeStructBegin(STRUCT_DESC);
7807 
7808       if (this.isSetSuccess()) {
7809         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
7810         {
7811           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
7812           for (TRegionInfo _iter21 : this.success)
7813           {
7814             _iter21.write(oprot);
7815           }
7816           oprot.writeListEnd();
7817         }
7818         oprot.writeFieldEnd();
7819       } else if (this.isSetIo()) {
7820         oprot.writeFieldBegin(IO_FIELD_DESC);
7821         this.io.write(oprot);
7822         oprot.writeFieldEnd();
7823       }
7824       oprot.writeFieldStop();
7825       oprot.writeStructEnd();
7826     }
7827 
7828     @Override
7829     public String toString() {
7830       StringBuilder sb = new StringBuilder("getTableRegions_result(");
7831       boolean first = true;
7832 
7833       sb.append("success:");
7834       if (this.success == null) {
7835         sb.append("null");
7836       } else {
7837         sb.append(this.success);
7838       }
7839       first = false;
7840       if (!first) sb.append(", ");
7841       sb.append("io:");
7842       if (this.io == null) {
7843         sb.append("null");
7844       } else {
7845         sb.append(this.io);
7846       }
7847       first = false;
7848       sb.append(")");
7849       return sb.toString();
7850     }
7851 
7852     public void validate() throws TException {
7853       // check for required fields
7854     }
7855 
7856   }
7857 
7858   public static class createTable_args implements TBase<createTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_args>   {
7859     private static final TStruct STRUCT_DESC = new TStruct("createTable_args");
7860 
7861     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
7862     private static final TField COLUMN_FAMILIES_FIELD_DESC = new TField("columnFamilies", TType.LIST, (short)2);
7863 
7864     /**
7865      * name of table to create
7866      */
7867     public byte[] tableName;
7868     /**
7869      * list of column family descriptors
7870      */
7871     public List<ColumnDescriptor> columnFamilies;
7872 
7873     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
7874     public enum _Fields implements TFieldIdEnum {
7875       /**
7876        * name of table to create
7877        */
7878       TABLE_NAME((short)1, "tableName"),
7879       /**
7880        * list of column family descriptors
7881        */
7882       COLUMN_FAMILIES((short)2, "columnFamilies");
7883 
7884       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
7885       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
7886 
7887       static {
7888         for (_Fields field : EnumSet.allOf(_Fields.class)) {
7889           byId.put((int)field._thriftId, field);
7890           byName.put(field.getFieldName(), field);
7891         }
7892       }
7893 
7894       /**
7895        * Find the _Fields constant that matches fieldId, or null if its not found.
7896        */
7897       public static _Fields findByThriftId(int fieldId) {
7898         return byId.get(fieldId);
7899       }
7900 
7901       /**
7902        * Find the _Fields constant that matches fieldId, throwing an exception
7903        * if it is not found.
7904        */
7905       public static _Fields findByThriftIdOrThrow(int fieldId) {
7906         _Fields fields = findByThriftId(fieldId);
7907         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
7908         return fields;
7909       }
7910 
7911       /**
7912        * Find the _Fields constant that matches name, or null if its not found.
7913        */
7914       public static _Fields findByName(String name) {
7915         return byName.get(name);
7916       }
7917 
7918       private final short _thriftId;
7919       private final String _fieldName;
7920 
7921       _Fields(short thriftId, String fieldName) {
7922         _thriftId = thriftId;
7923         _fieldName = fieldName;
7924       }
7925 
7926       public short getThriftFieldId() {
7927         return _thriftId;
7928       }
7929 
7930       public String getFieldName() {
7931         return _fieldName;
7932       }
7933     }
7934 
7935     // isset id assignments
7936 
7937     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
7938       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
7939           new FieldValueMetaData(TType.STRING)));
7940       put(_Fields.COLUMN_FAMILIES, new FieldMetaData("columnFamilies", TFieldRequirementType.DEFAULT,
7941           new ListMetaData(TType.LIST,
7942               new StructMetaData(TType.STRUCT, ColumnDescriptor.class))));
7943     }});
7944 
7945     static {
7946       FieldMetaData.addStructMetaDataMap(createTable_args.class, metaDataMap);
7947     }
7948 
7949     public createTable_args() {
7950     }
7951 
7952     public createTable_args(
7953       byte[] tableName,
7954       List<ColumnDescriptor> columnFamilies)
7955     {
7956       this();
7957       this.tableName = tableName;
7958       this.columnFamilies = columnFamilies;
7959     }
7960 
7961     /**
7962      * Performs a deep copy on <i>other</i>.
7963      */
7964     public createTable_args(createTable_args other) {
7965       if (other.isSetTableName()) {
7966         this.tableName = other.tableName;
7967       }
7968       if (other.isSetColumnFamilies()) {
7969         List<ColumnDescriptor> __this__columnFamilies = new ArrayList<ColumnDescriptor>();
7970         for (ColumnDescriptor other_element : other.columnFamilies) {
7971           __this__columnFamilies.add(new ColumnDescriptor(other_element));
7972         }
7973         this.columnFamilies = __this__columnFamilies;
7974       }
7975     }
7976 
7977     public createTable_args deepCopy() {
7978       return new createTable_args(this);
7979     }
7980 
7981     @Deprecated
7982     public createTable_args clone() {
7983       return new createTable_args(this);
7984     }
7985 
7986     /**
7987      * name of table to create
7988      */
7989     public byte[] getTableName() {
7990       return this.tableName;
7991     }
7992 
7993     /**
7994      * name of table to create
7995      */
7996     public createTable_args setTableName(byte[] tableName) {
7997       this.tableName = tableName;
7998       return this;
7999     }
8000 
8001     public void unsetTableName() {
8002       this.tableName = null;
8003     }
8004 
8005     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
8006     public boolean isSetTableName() {
8007       return this.tableName != null;
8008     }
8009 
8010     public void setTableNameIsSet(boolean value) {
8011       if (!value) {
8012         this.tableName = null;
8013       }
8014     }
8015 
8016     public int getColumnFamiliesSize() {
8017       return (this.columnFamilies == null) ? 0 : this.columnFamilies.size();
8018     }
8019 
8020     public java.util.Iterator<ColumnDescriptor> getColumnFamiliesIterator() {
8021       return (this.columnFamilies == null) ? null : this.columnFamilies.iterator();
8022     }
8023 
8024     public void addToColumnFamilies(ColumnDescriptor elem) {
8025       if (this.columnFamilies == null) {
8026         this.columnFamilies = new ArrayList<ColumnDescriptor>();
8027       }
8028       this.columnFamilies.add(elem);
8029     }
8030 
8031     /**
8032      * list of column family descriptors
8033      */
8034     public List<ColumnDescriptor> getColumnFamilies() {
8035       return this.columnFamilies;
8036     }
8037 
8038     /**
8039      * list of column family descriptors
8040      */
8041     public createTable_args setColumnFamilies(List<ColumnDescriptor> columnFamilies) {
8042       this.columnFamilies = columnFamilies;
8043       return this;
8044     }
8045 
8046     public void unsetColumnFamilies() {
8047       this.columnFamilies = null;
8048     }
8049 
8050     /** Returns true if field columnFamilies is set (has been asigned a value) and false otherwise */
8051     public boolean isSetColumnFamilies() {
8052       return this.columnFamilies != null;
8053     }
8054 
8055     public void setColumnFamiliesIsSet(boolean value) {
8056       if (!value) {
8057         this.columnFamilies = null;
8058       }
8059     }
8060 
8061     public void setFieldValue(_Fields field, Object value) {
8062       switch (field) {
8063       case TABLE_NAME:
8064         if (value == null) {
8065           unsetTableName();
8066         } else {
8067           setTableName((byte[])value);
8068         }
8069         break;
8070 
8071       case COLUMN_FAMILIES:
8072         if (value == null) {
8073           unsetColumnFamilies();
8074         } else {
8075           setColumnFamilies((List<ColumnDescriptor>)value);
8076         }
8077         break;
8078 
8079       }
8080     }
8081 
8082     public void setFieldValue(int fieldID, Object value) {
8083       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8084     }
8085 
8086     public Object getFieldValue(_Fields field) {
8087       switch (field) {
8088       case TABLE_NAME:
8089         return getTableName();
8090 
8091       case COLUMN_FAMILIES:
8092         return getColumnFamilies();
8093 
8094       }
8095       throw new IllegalStateException();
8096     }
8097 
8098     public Object getFieldValue(int fieldId) {
8099       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8100     }
8101 
8102     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
8103     public boolean isSet(_Fields field) {
8104       switch (field) {
8105       case TABLE_NAME:
8106         return isSetTableName();
8107       case COLUMN_FAMILIES:
8108         return isSetColumnFamilies();
8109       }
8110       throw new IllegalStateException();
8111     }
8112 
8113     public boolean isSet(int fieldID) {
8114       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8115     }
8116 
8117     @Override
8118     public boolean equals(Object that) {
8119       if (that == null)
8120         return false;
8121       if (that instanceof createTable_args)
8122         return this.equals((createTable_args)that);
8123       return false;
8124     }
8125 
8126     public boolean equals(createTable_args that) {
8127       if (that == null)
8128         return false;
8129 
8130       boolean this_present_tableName = true && this.isSetTableName();
8131       boolean that_present_tableName = true && that.isSetTableName();
8132       if (this_present_tableName || that_present_tableName) {
8133         if (!(this_present_tableName && that_present_tableName))
8134           return false;
8135         if (!java.util.Arrays.equals(this.tableName, that.tableName))
8136           return false;
8137       }
8138 
8139       boolean this_present_columnFamilies = true && this.isSetColumnFamilies();
8140       boolean that_present_columnFamilies = true && that.isSetColumnFamilies();
8141       if (this_present_columnFamilies || that_present_columnFamilies) {
8142         if (!(this_present_columnFamilies && that_present_columnFamilies))
8143           return false;
8144         if (!this.columnFamilies.equals(that.columnFamilies))
8145           return false;
8146       }
8147 
8148       return true;
8149     }
8150 
8151     @Override
8152     public int hashCode() {
8153       HashCodeBuilder builder = new HashCodeBuilder();
8154 
8155       boolean present_tableName = true && (isSetTableName());
8156       builder.append(present_tableName);
8157       if (present_tableName)
8158         builder.append(tableName);
8159 
8160       boolean present_columnFamilies = true && (isSetColumnFamilies());
8161       builder.append(present_columnFamilies);
8162       if (present_columnFamilies)
8163         builder.append(columnFamilies);
8164 
8165       return builder.toHashCode();
8166     }
8167 
8168     public int compareTo(createTable_args other) {
8169       if (!getClass().equals(other.getClass())) {
8170         return getClass().getName().compareTo(other.getClass().getName());
8171       }
8172 
8173       int lastComparison = 0;
8174       createTable_args typedOther = (createTable_args)other;
8175 
8176       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
8177       if (lastComparison != 0) {
8178         return lastComparison;
8179       }
8180       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
8181       if (lastComparison != 0) {
8182         return lastComparison;
8183       }
8184       lastComparison = Boolean.valueOf(isSetColumnFamilies()).compareTo(isSetColumnFamilies());
8185       if (lastComparison != 0) {
8186         return lastComparison;
8187       }
8188       lastComparison = TBaseHelper.compareTo(columnFamilies, typedOther.columnFamilies);
8189       if (lastComparison != 0) {
8190         return lastComparison;
8191       }
8192       return 0;
8193     }
8194 
8195     public void read(TProtocol iprot) throws TException {
8196       TField field;
8197       iprot.readStructBegin();
8198       while (true)
8199       {
8200         field = iprot.readFieldBegin();
8201         if (field.type == TType.STOP) {
8202           break;
8203         }
8204         _Fields fieldId = _Fields.findByThriftId(field.id);
8205         if (fieldId == null) {
8206           TProtocolUtil.skip(iprot, field.type);
8207         } else {
8208           switch (fieldId) {
8209             case TABLE_NAME:
8210               if (field.type == TType.STRING) {
8211                 this.tableName = iprot.readBinary();
8212               } else {
8213                 TProtocolUtil.skip(iprot, field.type);
8214               }
8215               break;
8216             case COLUMN_FAMILIES:
8217               if (field.type == TType.LIST) {
8218                 {
8219                   TList _list22 = iprot.readListBegin();
8220                   this.columnFamilies = new ArrayList<ColumnDescriptor>(_list22.size);
8221                   for (int _i23 = 0; _i23 < _list22.size; ++_i23)
8222                   {
8223                     ColumnDescriptor _elem24;
8224                     _elem24 = new ColumnDescriptor();
8225                     _elem24.read(iprot);
8226                     this.columnFamilies.add(_elem24);
8227                   }
8228                   iprot.readListEnd();
8229                 }
8230               } else {
8231                 TProtocolUtil.skip(iprot, field.type);
8232               }
8233               break;
8234           }
8235           iprot.readFieldEnd();
8236         }
8237       }
8238       iprot.readStructEnd();
8239 
8240       // check for required fields of primitive type, which can't be checked in the validate method
8241       validate();
8242     }
8243 
8244     public void write(TProtocol oprot) throws TException {
8245       validate();
8246 
8247       oprot.writeStructBegin(STRUCT_DESC);
8248       if (this.tableName != null) {
8249         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
8250         oprot.writeBinary(this.tableName);
8251         oprot.writeFieldEnd();
8252       }
8253       if (this.columnFamilies != null) {
8254         oprot.writeFieldBegin(COLUMN_FAMILIES_FIELD_DESC);
8255         {
8256           oprot.writeListBegin(new TList(TType.STRUCT, this.columnFamilies.size()));
8257           for (ColumnDescriptor _iter25 : this.columnFamilies)
8258           {
8259             _iter25.write(oprot);
8260           }
8261           oprot.writeListEnd();
8262         }
8263         oprot.writeFieldEnd();
8264       }
8265       oprot.writeFieldStop();
8266       oprot.writeStructEnd();
8267     }
8268 
8269     @Override
8270     public String toString() {
8271       StringBuilder sb = new StringBuilder("createTable_args(");
8272       boolean first = true;
8273 
8274       sb.append("tableName:");
8275       if (this.tableName == null) {
8276         sb.append("null");
8277       } else {
8278         sb.append(this.tableName);
8279       }
8280       first = false;
8281       if (!first) sb.append(", ");
8282       sb.append("columnFamilies:");
8283       if (this.columnFamilies == null) {
8284         sb.append("null");
8285       } else {
8286         sb.append(this.columnFamilies);
8287       }
8288       first = false;
8289       sb.append(")");
8290       return sb.toString();
8291     }
8292 
8293     public void validate() throws TException {
8294       // check for required fields
8295     }
8296 
8297   }
8298 
8299   public static class createTable_result implements TBase<createTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<createTable_result>   {
8300     private static final TStruct STRUCT_DESC = new TStruct("createTable_result");
8301 
8302     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
8303     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
8304     private static final TField EXIST_FIELD_DESC = new TField("exist", TType.STRUCT, (short)3);
8305 
8306     public IOError io;
8307     public IllegalArgument ia;
8308     public AlreadyExists exist;
8309 
8310     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
8311     public enum _Fields implements TFieldIdEnum {
8312       IO((short)1, "io"),
8313       IA((short)2, "ia"),
8314       EXIST((short)3, "exist");
8315 
8316       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
8317       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8318 
8319       static {
8320         for (_Fields field : EnumSet.allOf(_Fields.class)) {
8321           byId.put((int)field._thriftId, field);
8322           byName.put(field.getFieldName(), field);
8323         }
8324       }
8325 
8326       /**
8327        * Find the _Fields constant that matches fieldId, or null if its not found.
8328        */
8329       public static _Fields findByThriftId(int fieldId) {
8330         return byId.get(fieldId);
8331       }
8332 
8333       /**
8334        * Find the _Fields constant that matches fieldId, throwing an exception
8335        * if it is not found.
8336        */
8337       public static _Fields findByThriftIdOrThrow(int fieldId) {
8338         _Fields fields = findByThriftId(fieldId);
8339         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8340         return fields;
8341       }
8342 
8343       /**
8344        * Find the _Fields constant that matches name, or null if its not found.
8345        */
8346       public static _Fields findByName(String name) {
8347         return byName.get(name);
8348       }
8349 
8350       private final short _thriftId;
8351       private final String _fieldName;
8352 
8353       _Fields(short thriftId, String fieldName) {
8354         _thriftId = thriftId;
8355         _fieldName = fieldName;
8356       }
8357 
8358       public short getThriftFieldId() {
8359         return _thriftId;
8360       }
8361 
8362       public String getFieldName() {
8363         return _fieldName;
8364       }
8365     }
8366 
8367     // isset id assignments
8368 
8369     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
8370       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
8371           new FieldValueMetaData(TType.STRUCT)));
8372       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
8373           new FieldValueMetaData(TType.STRUCT)));
8374       put(_Fields.EXIST, new FieldMetaData("exist", TFieldRequirementType.DEFAULT,
8375           new FieldValueMetaData(TType.STRUCT)));
8376     }});
8377 
8378     static {
8379       FieldMetaData.addStructMetaDataMap(createTable_result.class, metaDataMap);
8380     }
8381 
8382     public createTable_result() {
8383     }
8384 
8385     public createTable_result(
8386       IOError io,
8387       IllegalArgument ia,
8388       AlreadyExists exist)
8389     {
8390       this();
8391       this.io = io;
8392       this.ia = ia;
8393       this.exist = exist;
8394     }
8395 
8396     /**
8397      * Performs a deep copy on <i>other</i>.
8398      */
8399     public createTable_result(createTable_result other) {
8400       if (other.isSetIo()) {
8401         this.io = new IOError(other.io);
8402       }
8403       if (other.isSetIa()) {
8404         this.ia = new IllegalArgument(other.ia);
8405       }
8406       if (other.isSetExist()) {
8407         this.exist = new AlreadyExists(other.exist);
8408       }
8409     }
8410 
8411     public createTable_result deepCopy() {
8412       return new createTable_result(this);
8413     }
8414 
8415     @Deprecated
8416     public createTable_result clone() {
8417       return new createTable_result(this);
8418     }
8419 
8420     public IOError getIo() {
8421       return this.io;
8422     }
8423 
8424     public createTable_result setIo(IOError io) {
8425       this.io = io;
8426       return this;
8427     }
8428 
8429     public void unsetIo() {
8430       this.io = null;
8431     }
8432 
8433     /** Returns true if field io is set (has been asigned a value) and false otherwise */
8434     public boolean isSetIo() {
8435       return this.io != null;
8436     }
8437 
8438     public void setIoIsSet(boolean value) {
8439       if (!value) {
8440         this.io = null;
8441       }
8442     }
8443 
8444     public IllegalArgument getIa() {
8445       return this.ia;
8446     }
8447 
8448     public createTable_result setIa(IllegalArgument ia) {
8449       this.ia = ia;
8450       return this;
8451     }
8452 
8453     public void unsetIa() {
8454       this.ia = null;
8455     }
8456 
8457     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
8458     public boolean isSetIa() {
8459       return this.ia != null;
8460     }
8461 
8462     public void setIaIsSet(boolean value) {
8463       if (!value) {
8464         this.ia = null;
8465       }
8466     }
8467 
8468     public AlreadyExists getExist() {
8469       return this.exist;
8470     }
8471 
8472     public createTable_result setExist(AlreadyExists exist) {
8473       this.exist = exist;
8474       return this;
8475     }
8476 
8477     public void unsetExist() {
8478       this.exist = null;
8479     }
8480 
8481     /** Returns true if field exist is set (has been asigned a value) and false otherwise */
8482     public boolean isSetExist() {
8483       return this.exist != null;
8484     }
8485 
8486     public void setExistIsSet(boolean value) {
8487       if (!value) {
8488         this.exist = null;
8489       }
8490     }
8491 
8492     public void setFieldValue(_Fields field, Object value) {
8493       switch (field) {
8494       case IO:
8495         if (value == null) {
8496           unsetIo();
8497         } else {
8498           setIo((IOError)value);
8499         }
8500         break;
8501 
8502       case IA:
8503         if (value == null) {
8504           unsetIa();
8505         } else {
8506           setIa((IllegalArgument)value);
8507         }
8508         break;
8509 
8510       case EXIST:
8511         if (value == null) {
8512           unsetExist();
8513         } else {
8514           setExist((AlreadyExists)value);
8515         }
8516         break;
8517 
8518       }
8519     }
8520 
8521     public void setFieldValue(int fieldID, Object value) {
8522       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8523     }
8524 
8525     public Object getFieldValue(_Fields field) {
8526       switch (field) {
8527       case IO:
8528         return getIo();
8529 
8530       case IA:
8531         return getIa();
8532 
8533       case EXIST:
8534         return getExist();
8535 
8536       }
8537       throw new IllegalStateException();
8538     }
8539 
8540     public Object getFieldValue(int fieldId) {
8541       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8542     }
8543 
8544     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
8545     public boolean isSet(_Fields field) {
8546       switch (field) {
8547       case IO:
8548         return isSetIo();
8549       case IA:
8550         return isSetIa();
8551       case EXIST:
8552         return isSetExist();
8553       }
8554       throw new IllegalStateException();
8555     }
8556 
8557     public boolean isSet(int fieldID) {
8558       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8559     }
8560 
8561     @Override
8562     public boolean equals(Object that) {
8563       if (that == null)
8564         return false;
8565       if (that instanceof createTable_result)
8566         return this.equals((createTable_result)that);
8567       return false;
8568     }
8569 
8570     public boolean equals(createTable_result that) {
8571       if (that == null)
8572         return false;
8573 
8574       boolean this_present_io = true && this.isSetIo();
8575       boolean that_present_io = true && that.isSetIo();
8576       if (this_present_io || that_present_io) {
8577         if (!(this_present_io && that_present_io))
8578           return false;
8579         if (!this.io.equals(that.io))
8580           return false;
8581       }
8582 
8583       boolean this_present_ia = true && this.isSetIa();
8584       boolean that_present_ia = true && that.isSetIa();
8585       if (this_present_ia || that_present_ia) {
8586         if (!(this_present_ia && that_present_ia))
8587           return false;
8588         if (!this.ia.equals(that.ia))
8589           return false;
8590       }
8591 
8592       boolean this_present_exist = true && this.isSetExist();
8593       boolean that_present_exist = true && that.isSetExist();
8594       if (this_present_exist || that_present_exist) {
8595         if (!(this_present_exist && that_present_exist))
8596           return false;
8597         if (!this.exist.equals(that.exist))
8598           return false;
8599       }
8600 
8601       return true;
8602     }
8603 
8604     @Override
8605     public int hashCode() {
8606       HashCodeBuilder builder = new HashCodeBuilder();
8607 
8608       boolean present_io = true && (isSetIo());
8609       builder.append(present_io);
8610       if (present_io)
8611         builder.append(io);
8612 
8613       boolean present_ia = true && (isSetIa());
8614       builder.append(present_ia);
8615       if (present_ia)
8616         builder.append(ia);
8617 
8618       boolean present_exist = true && (isSetExist());
8619       builder.append(present_exist);
8620       if (present_exist)
8621         builder.append(exist);
8622 
8623       return builder.toHashCode();
8624     }
8625 
8626     public int compareTo(createTable_result other) {
8627       if (!getClass().equals(other.getClass())) {
8628         return getClass().getName().compareTo(other.getClass().getName());
8629       }
8630 
8631       int lastComparison = 0;
8632       createTable_result typedOther = (createTable_result)other;
8633 
8634       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
8635       if (lastComparison != 0) {
8636         return lastComparison;
8637       }
8638       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
8639       if (lastComparison != 0) {
8640         return lastComparison;
8641       }
8642       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
8643       if (lastComparison != 0) {
8644         return lastComparison;
8645       }
8646       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
8647       if (lastComparison != 0) {
8648         return lastComparison;
8649       }
8650       lastComparison = Boolean.valueOf(isSetExist()).compareTo(isSetExist());
8651       if (lastComparison != 0) {
8652         return lastComparison;
8653       }
8654       lastComparison = TBaseHelper.compareTo(exist, typedOther.exist);
8655       if (lastComparison != 0) {
8656         return lastComparison;
8657       }
8658       return 0;
8659     }
8660 
8661     public void read(TProtocol iprot) throws TException {
8662       TField field;
8663       iprot.readStructBegin();
8664       while (true)
8665       {
8666         field = iprot.readFieldBegin();
8667         if (field.type == TType.STOP) {
8668           break;
8669         }
8670         _Fields fieldId = _Fields.findByThriftId(field.id);
8671         if (fieldId == null) {
8672           TProtocolUtil.skip(iprot, field.type);
8673         } else {
8674           switch (fieldId) {
8675             case IO:
8676               if (field.type == TType.STRUCT) {
8677                 this.io = new IOError();
8678                 this.io.read(iprot);
8679               } else {
8680                 TProtocolUtil.skip(iprot, field.type);
8681               }
8682               break;
8683             case IA:
8684               if (field.type == TType.STRUCT) {
8685                 this.ia = new IllegalArgument();
8686                 this.ia.read(iprot);
8687               } else {
8688                 TProtocolUtil.skip(iprot, field.type);
8689               }
8690               break;
8691             case EXIST:
8692               if (field.type == TType.STRUCT) {
8693                 this.exist = new AlreadyExists();
8694                 this.exist.read(iprot);
8695               } else {
8696                 TProtocolUtil.skip(iprot, field.type);
8697               }
8698               break;
8699           }
8700           iprot.readFieldEnd();
8701         }
8702       }
8703       iprot.readStructEnd();
8704 
8705       // check for required fields of primitive type, which can't be checked in the validate method
8706       validate();
8707     }
8708 
8709     public void write(TProtocol oprot) throws TException {
8710       oprot.writeStructBegin(STRUCT_DESC);
8711 
8712       if (this.isSetIo()) {
8713         oprot.writeFieldBegin(IO_FIELD_DESC);
8714         this.io.write(oprot);
8715         oprot.writeFieldEnd();
8716       } else if (this.isSetIa()) {
8717         oprot.writeFieldBegin(IA_FIELD_DESC);
8718         this.ia.write(oprot);
8719         oprot.writeFieldEnd();
8720       } else if (this.isSetExist()) {
8721         oprot.writeFieldBegin(EXIST_FIELD_DESC);
8722         this.exist.write(oprot);
8723         oprot.writeFieldEnd();
8724       }
8725       oprot.writeFieldStop();
8726       oprot.writeStructEnd();
8727     }
8728 
8729     @Override
8730     public String toString() {
8731       StringBuilder sb = new StringBuilder("createTable_result(");
8732       boolean first = true;
8733 
8734       sb.append("io:");
8735       if (this.io == null) {
8736         sb.append("null");
8737       } else {
8738         sb.append(this.io);
8739       }
8740       first = false;
8741       if (!first) sb.append(", ");
8742       sb.append("ia:");
8743       if (this.ia == null) {
8744         sb.append("null");
8745       } else {
8746         sb.append(this.ia);
8747       }
8748       first = false;
8749       if (!first) sb.append(", ");
8750       sb.append("exist:");
8751       if (this.exist == null) {
8752         sb.append("null");
8753       } else {
8754         sb.append(this.exist);
8755       }
8756       first = false;
8757       sb.append(")");
8758       return sb.toString();
8759     }
8760 
8761     public void validate() throws TException {
8762       // check for required fields
8763     }
8764 
8765   }
8766 
8767   public static class deleteTable_args implements TBase<deleteTable_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_args>   {
8768     private static final TStruct STRUCT_DESC = new TStruct("deleteTable_args");
8769 
8770     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
8771 
8772     /**
8773      * name of table to delete
8774      */
8775     public byte[] tableName;
8776 
8777     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
8778     public enum _Fields implements TFieldIdEnum {
8779       /**
8780        * name of table to delete
8781        */
8782       TABLE_NAME((short)1, "tableName");
8783 
8784       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
8785       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
8786 
8787       static {
8788         for (_Fields field : EnumSet.allOf(_Fields.class)) {
8789           byId.put((int)field._thriftId, field);
8790           byName.put(field.getFieldName(), field);
8791         }
8792       }
8793 
8794       /**
8795        * Find the _Fields constant that matches fieldId, or null if its not found.
8796        */
8797       public static _Fields findByThriftId(int fieldId) {
8798         return byId.get(fieldId);
8799       }
8800 
8801       /**
8802        * Find the _Fields constant that matches fieldId, throwing an exception
8803        * if it is not found.
8804        */
8805       public static _Fields findByThriftIdOrThrow(int fieldId) {
8806         _Fields fields = findByThriftId(fieldId);
8807         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
8808         return fields;
8809       }
8810 
8811       /**
8812        * Find the _Fields constant that matches name, or null if its not found.
8813        */
8814       public static _Fields findByName(String name) {
8815         return byName.get(name);
8816       }
8817 
8818       private final short _thriftId;
8819       private final String _fieldName;
8820 
8821       _Fields(short thriftId, String fieldName) {
8822         _thriftId = thriftId;
8823         _fieldName = fieldName;
8824       }
8825 
8826       public short getThriftFieldId() {
8827         return _thriftId;
8828       }
8829 
8830       public String getFieldName() {
8831         return _fieldName;
8832       }
8833     }
8834 
8835     // isset id assignments
8836 
8837     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
8838       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
8839           new FieldValueMetaData(TType.STRING)));
8840     }});
8841 
8842     static {
8843       FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap);
8844     }
8845 
8846     public deleteTable_args() {
8847     }
8848 
8849     public deleteTable_args(
8850       byte[] tableName)
8851     {
8852       this();
8853       this.tableName = tableName;
8854     }
8855 
8856     /**
8857      * Performs a deep copy on <i>other</i>.
8858      */
8859     public deleteTable_args(deleteTable_args other) {
8860       if (other.isSetTableName()) {
8861         this.tableName = other.tableName;
8862       }
8863     }
8864 
8865     public deleteTable_args deepCopy() {
8866       return new deleteTable_args(this);
8867     }
8868 
8869     @Deprecated
8870     public deleteTable_args clone() {
8871       return new deleteTable_args(this);
8872     }
8873 
8874     /**
8875      * name of table to delete
8876      */
8877     public byte[] getTableName() {
8878       return this.tableName;
8879     }
8880 
8881     /**
8882      * name of table to delete
8883      */
8884     public deleteTable_args setTableName(byte[] tableName) {
8885       this.tableName = tableName;
8886       return this;
8887     }
8888 
8889     public void unsetTableName() {
8890       this.tableName = null;
8891     }
8892 
8893     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
8894     public boolean isSetTableName() {
8895       return this.tableName != null;
8896     }
8897 
8898     public void setTableNameIsSet(boolean value) {
8899       if (!value) {
8900         this.tableName = null;
8901       }
8902     }
8903 
8904     public void setFieldValue(_Fields field, Object value) {
8905       switch (field) {
8906       case TABLE_NAME:
8907         if (value == null) {
8908           unsetTableName();
8909         } else {
8910           setTableName((byte[])value);
8911         }
8912         break;
8913 
8914       }
8915     }
8916 
8917     public void setFieldValue(int fieldID, Object value) {
8918       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
8919     }
8920 
8921     public Object getFieldValue(_Fields field) {
8922       switch (field) {
8923       case TABLE_NAME:
8924         return getTableName();
8925 
8926       }
8927       throw new IllegalStateException();
8928     }
8929 
8930     public Object getFieldValue(int fieldId) {
8931       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
8932     }
8933 
8934     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
8935     public boolean isSet(_Fields field) {
8936       switch (field) {
8937       case TABLE_NAME:
8938         return isSetTableName();
8939       }
8940       throw new IllegalStateException();
8941     }
8942 
8943     public boolean isSet(int fieldID) {
8944       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
8945     }
8946 
8947     @Override
8948     public boolean equals(Object that) {
8949       if (that == null)
8950         return false;
8951       if (that instanceof deleteTable_args)
8952         return this.equals((deleteTable_args)that);
8953       return false;
8954     }
8955 
8956     public boolean equals(deleteTable_args that) {
8957       if (that == null)
8958         return false;
8959 
8960       boolean this_present_tableName = true && this.isSetTableName();
8961       boolean that_present_tableName = true && that.isSetTableName();
8962       if (this_present_tableName || that_present_tableName) {
8963         if (!(this_present_tableName && that_present_tableName))
8964           return false;
8965         if (!java.util.Arrays.equals(this.tableName, that.tableName))
8966           return false;
8967       }
8968 
8969       return true;
8970     }
8971 
8972     @Override
8973     public int hashCode() {
8974       HashCodeBuilder builder = new HashCodeBuilder();
8975 
8976       boolean present_tableName = true && (isSetTableName());
8977       builder.append(present_tableName);
8978       if (present_tableName)
8979         builder.append(tableName);
8980 
8981       return builder.toHashCode();
8982     }
8983 
8984     public int compareTo(deleteTable_args other) {
8985       if (!getClass().equals(other.getClass())) {
8986         return getClass().getName().compareTo(other.getClass().getName());
8987       }
8988 
8989       int lastComparison = 0;
8990       deleteTable_args typedOther = (deleteTable_args)other;
8991 
8992       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
8993       if (lastComparison != 0) {
8994         return lastComparison;
8995       }
8996       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
8997       if (lastComparison != 0) {
8998         return lastComparison;
8999       }
9000       return 0;
9001     }
9002 
9003     public void read(TProtocol iprot) throws TException {
9004       TField field;
9005       iprot.readStructBegin();
9006       while (true)
9007       {
9008         field = iprot.readFieldBegin();
9009         if (field.type == TType.STOP) {
9010           break;
9011         }
9012         _Fields fieldId = _Fields.findByThriftId(field.id);
9013         if (fieldId == null) {
9014           TProtocolUtil.skip(iprot, field.type);
9015         } else {
9016           switch (fieldId) {
9017             case TABLE_NAME:
9018               if (field.type == TType.STRING) {
9019                 this.tableName = iprot.readBinary();
9020               } else {
9021                 TProtocolUtil.skip(iprot, field.type);
9022               }
9023               break;
9024           }
9025           iprot.readFieldEnd();
9026         }
9027       }
9028       iprot.readStructEnd();
9029 
9030       // check for required fields of primitive type, which can't be checked in the validate method
9031       validate();
9032     }
9033 
9034     public void write(TProtocol oprot) throws TException {
9035       validate();
9036 
9037       oprot.writeStructBegin(STRUCT_DESC);
9038       if (this.tableName != null) {
9039         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
9040         oprot.writeBinary(this.tableName);
9041         oprot.writeFieldEnd();
9042       }
9043       oprot.writeFieldStop();
9044       oprot.writeStructEnd();
9045     }
9046 
9047     @Override
9048     public String toString() {
9049       StringBuilder sb = new StringBuilder("deleteTable_args(");
9050       boolean first = true;
9051 
9052       sb.append("tableName:");
9053       if (this.tableName == null) {
9054         sb.append("null");
9055       } else {
9056         sb.append(this.tableName);
9057       }
9058       first = false;
9059       sb.append(")");
9060       return sb.toString();
9061     }
9062 
9063     public void validate() throws TException {
9064       // check for required fields
9065     }
9066 
9067   }
9068 
9069   public static class deleteTable_result implements TBase<deleteTable_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteTable_result>   {
9070     private static final TStruct STRUCT_DESC = new TStruct("deleteTable_result");
9071 
9072     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
9073 
9074     public IOError io;
9075 
9076     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
9077     public enum _Fields implements TFieldIdEnum {
9078       IO((short)1, "io");
9079 
9080       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9081       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9082 
9083       static {
9084         for (_Fields field : EnumSet.allOf(_Fields.class)) {
9085           byId.put((int)field._thriftId, field);
9086           byName.put(field.getFieldName(), field);
9087         }
9088       }
9089 
9090       /**
9091        * Find the _Fields constant that matches fieldId, or null if its not found.
9092        */
9093       public static _Fields findByThriftId(int fieldId) {
9094         return byId.get(fieldId);
9095       }
9096 
9097       /**
9098        * Find the _Fields constant that matches fieldId, throwing an exception
9099        * if it is not found.
9100        */
9101       public static _Fields findByThriftIdOrThrow(int fieldId) {
9102         _Fields fields = findByThriftId(fieldId);
9103         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9104         return fields;
9105       }
9106 
9107       /**
9108        * Find the _Fields constant that matches name, or null if its not found.
9109        */
9110       public static _Fields findByName(String name) {
9111         return byName.get(name);
9112       }
9113 
9114       private final short _thriftId;
9115       private final String _fieldName;
9116 
9117       _Fields(short thriftId, String fieldName) {
9118         _thriftId = thriftId;
9119         _fieldName = fieldName;
9120       }
9121 
9122       public short getThriftFieldId() {
9123         return _thriftId;
9124       }
9125 
9126       public String getFieldName() {
9127         return _fieldName;
9128       }
9129     }
9130 
9131     // isset id assignments
9132 
9133     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9134       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
9135           new FieldValueMetaData(TType.STRUCT)));
9136     }});
9137 
9138     static {
9139       FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap);
9140     }
9141 
9142     public deleteTable_result() {
9143     }
9144 
9145     public deleteTable_result(
9146       IOError io)
9147     {
9148       this();
9149       this.io = io;
9150     }
9151 
9152     /**
9153      * Performs a deep copy on <i>other</i>.
9154      */
9155     public deleteTable_result(deleteTable_result other) {
9156       if (other.isSetIo()) {
9157         this.io = new IOError(other.io);
9158       }
9159     }
9160 
9161     public deleteTable_result deepCopy() {
9162       return new deleteTable_result(this);
9163     }
9164 
9165     @Deprecated
9166     public deleteTable_result clone() {
9167       return new deleteTable_result(this);
9168     }
9169 
9170     public IOError getIo() {
9171       return this.io;
9172     }
9173 
9174     public deleteTable_result setIo(IOError io) {
9175       this.io = io;
9176       return this;
9177     }
9178 
9179     public void unsetIo() {
9180       this.io = null;
9181     }
9182 
9183     /** Returns true if field io is set (has been asigned a value) and false otherwise */
9184     public boolean isSetIo() {
9185       return this.io != null;
9186     }
9187 
9188     public void setIoIsSet(boolean value) {
9189       if (!value) {
9190         this.io = null;
9191       }
9192     }
9193 
9194     public void setFieldValue(_Fields field, Object value) {
9195       switch (field) {
9196       case IO:
9197         if (value == null) {
9198           unsetIo();
9199         } else {
9200           setIo((IOError)value);
9201         }
9202         break;
9203 
9204       }
9205     }
9206 
9207     public void setFieldValue(int fieldID, Object value) {
9208       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9209     }
9210 
9211     public Object getFieldValue(_Fields field) {
9212       switch (field) {
9213       case IO:
9214         return getIo();
9215 
9216       }
9217       throw new IllegalStateException();
9218     }
9219 
9220     public Object getFieldValue(int fieldId) {
9221       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9222     }
9223 
9224     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
9225     public boolean isSet(_Fields field) {
9226       switch (field) {
9227       case IO:
9228         return isSetIo();
9229       }
9230       throw new IllegalStateException();
9231     }
9232 
9233     public boolean isSet(int fieldID) {
9234       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9235     }
9236 
9237     @Override
9238     public boolean equals(Object that) {
9239       if (that == null)
9240         return false;
9241       if (that instanceof deleteTable_result)
9242         return this.equals((deleteTable_result)that);
9243       return false;
9244     }
9245 
9246     public boolean equals(deleteTable_result that) {
9247       if (that == null)
9248         return false;
9249 
9250       boolean this_present_io = true && this.isSetIo();
9251       boolean that_present_io = true && that.isSetIo();
9252       if (this_present_io || that_present_io) {
9253         if (!(this_present_io && that_present_io))
9254           return false;
9255         if (!this.io.equals(that.io))
9256           return false;
9257       }
9258 
9259       return true;
9260     }
9261 
9262     @Override
9263     public int hashCode() {
9264       HashCodeBuilder builder = new HashCodeBuilder();
9265 
9266       boolean present_io = true && (isSetIo());
9267       builder.append(present_io);
9268       if (present_io)
9269         builder.append(io);
9270 
9271       return builder.toHashCode();
9272     }
9273 
9274     public int compareTo(deleteTable_result other) {
9275       if (!getClass().equals(other.getClass())) {
9276         return getClass().getName().compareTo(other.getClass().getName());
9277       }
9278 
9279       int lastComparison = 0;
9280       deleteTable_result typedOther = (deleteTable_result)other;
9281 
9282       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
9283       if (lastComparison != 0) {
9284         return lastComparison;
9285       }
9286       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
9287       if (lastComparison != 0) {
9288         return lastComparison;
9289       }
9290       return 0;
9291     }
9292 
9293     public void read(TProtocol iprot) throws TException {
9294       TField field;
9295       iprot.readStructBegin();
9296       while (true)
9297       {
9298         field = iprot.readFieldBegin();
9299         if (field.type == TType.STOP) {
9300           break;
9301         }
9302         _Fields fieldId = _Fields.findByThriftId(field.id);
9303         if (fieldId == null) {
9304           TProtocolUtil.skip(iprot, field.type);
9305         } else {
9306           switch (fieldId) {
9307             case IO:
9308               if (field.type == TType.STRUCT) {
9309                 this.io = new IOError();
9310                 this.io.read(iprot);
9311               } else {
9312                 TProtocolUtil.skip(iprot, field.type);
9313               }
9314               break;
9315           }
9316           iprot.readFieldEnd();
9317         }
9318       }
9319       iprot.readStructEnd();
9320 
9321       // check for required fields of primitive type, which can't be checked in the validate method
9322       validate();
9323     }
9324 
9325     public void write(TProtocol oprot) throws TException {
9326       oprot.writeStructBegin(STRUCT_DESC);
9327 
9328       if (this.isSetIo()) {
9329         oprot.writeFieldBegin(IO_FIELD_DESC);
9330         this.io.write(oprot);
9331         oprot.writeFieldEnd();
9332       }
9333       oprot.writeFieldStop();
9334       oprot.writeStructEnd();
9335     }
9336 
9337     @Override
9338     public String toString() {
9339       StringBuilder sb = new StringBuilder("deleteTable_result(");
9340       boolean first = true;
9341 
9342       sb.append("io:");
9343       if (this.io == null) {
9344         sb.append("null");
9345       } else {
9346         sb.append(this.io);
9347       }
9348       first = false;
9349       sb.append(")");
9350       return sb.toString();
9351     }
9352 
9353     public void validate() throws TException {
9354       // check for required fields
9355     }
9356 
9357   }
9358 
9359   public static class get_args implements TBase<get_args._Fields>, java.io.Serializable, Cloneable, Comparable<get_args>   {
9360     private static final TStruct STRUCT_DESC = new TStruct("get_args");
9361 
9362     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
9363     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
9364     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
9365 
9366     /**
9367      * name of table
9368      */
9369     public byte[] tableName;
9370     /**
9371      * row key
9372      */
9373     public byte[] row;
9374     /**
9375      * column name
9376      */
9377     public byte[] column;
9378 
9379     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
9380     public enum _Fields implements TFieldIdEnum {
9381       /**
9382        * name of table
9383        */
9384       TABLE_NAME((short)1, "tableName"),
9385       /**
9386        * row key
9387        */
9388       ROW((short)2, "row"),
9389       /**
9390        * column name
9391        */
9392       COLUMN((short)3, "column");
9393 
9394       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9395       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9396 
9397       static {
9398         for (_Fields field : EnumSet.allOf(_Fields.class)) {
9399           byId.put((int)field._thriftId, field);
9400           byName.put(field.getFieldName(), field);
9401         }
9402       }
9403 
9404       /**
9405        * Find the _Fields constant that matches fieldId, or null if its not found.
9406        */
9407       public static _Fields findByThriftId(int fieldId) {
9408         return byId.get(fieldId);
9409       }
9410 
9411       /**
9412        * Find the _Fields constant that matches fieldId, throwing an exception
9413        * if it is not found.
9414        */
9415       public static _Fields findByThriftIdOrThrow(int fieldId) {
9416         _Fields fields = findByThriftId(fieldId);
9417         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9418         return fields;
9419       }
9420 
9421       /**
9422        * Find the _Fields constant that matches name, or null if its not found.
9423        */
9424       public static _Fields findByName(String name) {
9425         return byName.get(name);
9426       }
9427 
9428       private final short _thriftId;
9429       private final String _fieldName;
9430 
9431       _Fields(short thriftId, String fieldName) {
9432         _thriftId = thriftId;
9433         _fieldName = fieldName;
9434       }
9435 
9436       public short getThriftFieldId() {
9437         return _thriftId;
9438       }
9439 
9440       public String getFieldName() {
9441         return _fieldName;
9442       }
9443     }
9444 
9445     // isset id assignments
9446 
9447     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9448       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
9449           new FieldValueMetaData(TType.STRING)));
9450       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
9451           new FieldValueMetaData(TType.STRING)));
9452       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
9453           new FieldValueMetaData(TType.STRING)));
9454     }});
9455 
9456     static {
9457       FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap);
9458     }
9459 
9460     public get_args() {
9461     }
9462 
9463     public get_args(
9464       byte[] tableName,
9465       byte[] row,
9466       byte[] column)
9467     {
9468       this();
9469       this.tableName = tableName;
9470       this.row = row;
9471       this.column = column;
9472     }
9473 
9474     /**
9475      * Performs a deep copy on <i>other</i>.
9476      */
9477     public get_args(get_args other) {
9478       if (other.isSetTableName()) {
9479         this.tableName = other.tableName;
9480       }
9481       if (other.isSetRow()) {
9482         this.row = other.row;
9483       }
9484       if (other.isSetColumn()) {
9485         this.column = other.column;
9486       }
9487     }
9488 
9489     public get_args deepCopy() {
9490       return new get_args(this);
9491     }
9492 
9493     @Deprecated
9494     public get_args clone() {
9495       return new get_args(this);
9496     }
9497 
9498     /**
9499      * name of table
9500      */
9501     public byte[] getTableName() {
9502       return this.tableName;
9503     }
9504 
9505     /**
9506      * name of table
9507      */
9508     public get_args setTableName(byte[] tableName) {
9509       this.tableName = tableName;
9510       return this;
9511     }
9512 
9513     public void unsetTableName() {
9514       this.tableName = null;
9515     }
9516 
9517     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
9518     public boolean isSetTableName() {
9519       return this.tableName != null;
9520     }
9521 
9522     public void setTableNameIsSet(boolean value) {
9523       if (!value) {
9524         this.tableName = null;
9525       }
9526     }
9527 
9528     /**
9529      * row key
9530      */
9531     public byte[] getRow() {
9532       return this.row;
9533     }
9534 
9535     /**
9536      * row key
9537      */
9538     public get_args setRow(byte[] row) {
9539       this.row = row;
9540       return this;
9541     }
9542 
9543     public void unsetRow() {
9544       this.row = null;
9545     }
9546 
9547     /** Returns true if field row is set (has been asigned a value) and false otherwise */
9548     public boolean isSetRow() {
9549       return this.row != null;
9550     }
9551 
9552     public void setRowIsSet(boolean value) {
9553       if (!value) {
9554         this.row = null;
9555       }
9556     }
9557 
9558     /**
9559      * column name
9560      */
9561     public byte[] getColumn() {
9562       return this.column;
9563     }
9564 
9565     /**
9566      * column name
9567      */
9568     public get_args setColumn(byte[] column) {
9569       this.column = column;
9570       return this;
9571     }
9572 
9573     public void unsetColumn() {
9574       this.column = null;
9575     }
9576 
9577     /** Returns true if field column is set (has been asigned a value) and false otherwise */
9578     public boolean isSetColumn() {
9579       return this.column != null;
9580     }
9581 
9582     public void setColumnIsSet(boolean value) {
9583       if (!value) {
9584         this.column = null;
9585       }
9586     }
9587 
9588     public void setFieldValue(_Fields field, Object value) {
9589       switch (field) {
9590       case TABLE_NAME:
9591         if (value == null) {
9592           unsetTableName();
9593         } else {
9594           setTableName((byte[])value);
9595         }
9596         break;
9597 
9598       case ROW:
9599         if (value == null) {
9600           unsetRow();
9601         } else {
9602           setRow((byte[])value);
9603         }
9604         break;
9605 
9606       case COLUMN:
9607         if (value == null) {
9608           unsetColumn();
9609         } else {
9610           setColumn((byte[])value);
9611         }
9612         break;
9613 
9614       }
9615     }
9616 
9617     public void setFieldValue(int fieldID, Object value) {
9618       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
9619     }
9620 
9621     public Object getFieldValue(_Fields field) {
9622       switch (field) {
9623       case TABLE_NAME:
9624         return getTableName();
9625 
9626       case ROW:
9627         return getRow();
9628 
9629       case COLUMN:
9630         return getColumn();
9631 
9632       }
9633       throw new IllegalStateException();
9634     }
9635 
9636     public Object getFieldValue(int fieldId) {
9637       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
9638     }
9639 
9640     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
9641     public boolean isSet(_Fields field) {
9642       switch (field) {
9643       case TABLE_NAME:
9644         return isSetTableName();
9645       case ROW:
9646         return isSetRow();
9647       case COLUMN:
9648         return isSetColumn();
9649       }
9650       throw new IllegalStateException();
9651     }
9652 
9653     public boolean isSet(int fieldID) {
9654       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
9655     }
9656 
9657     @Override
9658     public boolean equals(Object that) {
9659       if (that == null)
9660         return false;
9661       if (that instanceof get_args)
9662         return this.equals((get_args)that);
9663       return false;
9664     }
9665 
9666     public boolean equals(get_args that) {
9667       if (that == null)
9668         return false;
9669 
9670       boolean this_present_tableName = true && this.isSetTableName();
9671       boolean that_present_tableName = true && that.isSetTableName();
9672       if (this_present_tableName || that_present_tableName) {
9673         if (!(this_present_tableName && that_present_tableName))
9674           return false;
9675         if (!java.util.Arrays.equals(this.tableName, that.tableName))
9676           return false;
9677       }
9678 
9679       boolean this_present_row = true && this.isSetRow();
9680       boolean that_present_row = true && that.isSetRow();
9681       if (this_present_row || that_present_row) {
9682         if (!(this_present_row && that_present_row))
9683           return false;
9684         if (!java.util.Arrays.equals(this.row, that.row))
9685           return false;
9686       }
9687 
9688       boolean this_present_column = true && this.isSetColumn();
9689       boolean that_present_column = true && that.isSetColumn();
9690       if (this_present_column || that_present_column) {
9691         if (!(this_present_column && that_present_column))
9692           return false;
9693         if (!java.util.Arrays.equals(this.column, that.column))
9694           return false;
9695       }
9696 
9697       return true;
9698     }
9699 
9700     @Override
9701     public int hashCode() {
9702       HashCodeBuilder builder = new HashCodeBuilder();
9703 
9704       boolean present_tableName = true && (isSetTableName());
9705       builder.append(present_tableName);
9706       if (present_tableName)
9707         builder.append(tableName);
9708 
9709       boolean present_row = true && (isSetRow());
9710       builder.append(present_row);
9711       if (present_row)
9712         builder.append(row);
9713 
9714       boolean present_column = true && (isSetColumn());
9715       builder.append(present_column);
9716       if (present_column)
9717         builder.append(column);
9718 
9719       return builder.toHashCode();
9720     }
9721 
9722     public int compareTo(get_args other) {
9723       if (!getClass().equals(other.getClass())) {
9724         return getClass().getName().compareTo(other.getClass().getName());
9725       }
9726 
9727       int lastComparison = 0;
9728       get_args typedOther = (get_args)other;
9729 
9730       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
9731       if (lastComparison != 0) {
9732         return lastComparison;
9733       }
9734       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
9735       if (lastComparison != 0) {
9736         return lastComparison;
9737       }
9738       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
9739       if (lastComparison != 0) {
9740         return lastComparison;
9741       }
9742       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
9743       if (lastComparison != 0) {
9744         return lastComparison;
9745       }
9746       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
9747       if (lastComparison != 0) {
9748         return lastComparison;
9749       }
9750       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
9751       if (lastComparison != 0) {
9752         return lastComparison;
9753       }
9754       return 0;
9755     }
9756 
9757     public void read(TProtocol iprot) throws TException {
9758       TField field;
9759       iprot.readStructBegin();
9760       while (true)
9761       {
9762         field = iprot.readFieldBegin();
9763         if (field.type == TType.STOP) {
9764           break;
9765         }
9766         _Fields fieldId = _Fields.findByThriftId(field.id);
9767         if (fieldId == null) {
9768           TProtocolUtil.skip(iprot, field.type);
9769         } else {
9770           switch (fieldId) {
9771             case TABLE_NAME:
9772               if (field.type == TType.STRING) {
9773                 this.tableName = iprot.readBinary();
9774               } else {
9775                 TProtocolUtil.skip(iprot, field.type);
9776               }
9777               break;
9778             case ROW:
9779               if (field.type == TType.STRING) {
9780                 this.row = iprot.readBinary();
9781               } else {
9782                 TProtocolUtil.skip(iprot, field.type);
9783               }
9784               break;
9785             case COLUMN:
9786               if (field.type == TType.STRING) {
9787                 this.column = iprot.readBinary();
9788               } else {
9789                 TProtocolUtil.skip(iprot, field.type);
9790               }
9791               break;
9792           }
9793           iprot.readFieldEnd();
9794         }
9795       }
9796       iprot.readStructEnd();
9797 
9798       // check for required fields of primitive type, which can't be checked in the validate method
9799       validate();
9800     }
9801 
9802     public void write(TProtocol oprot) throws TException {
9803       validate();
9804 
9805       oprot.writeStructBegin(STRUCT_DESC);
9806       if (this.tableName != null) {
9807         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
9808         oprot.writeBinary(this.tableName);
9809         oprot.writeFieldEnd();
9810       }
9811       if (this.row != null) {
9812         oprot.writeFieldBegin(ROW_FIELD_DESC);
9813         oprot.writeBinary(this.row);
9814         oprot.writeFieldEnd();
9815       }
9816       if (this.column != null) {
9817         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
9818         oprot.writeBinary(this.column);
9819         oprot.writeFieldEnd();
9820       }
9821       oprot.writeFieldStop();
9822       oprot.writeStructEnd();
9823     }
9824 
9825     @Override
9826     public String toString() {
9827       StringBuilder sb = new StringBuilder("get_args(");
9828       boolean first = true;
9829 
9830       sb.append("tableName:");
9831       if (this.tableName == null) {
9832         sb.append("null");
9833       } else {
9834         sb.append(this.tableName);
9835       }
9836       first = false;
9837       if (!first) sb.append(", ");
9838       sb.append("row:");
9839       if (this.row == null) {
9840         sb.append("null");
9841       } else {
9842         sb.append(this.row);
9843       }
9844       first = false;
9845       if (!first) sb.append(", ");
9846       sb.append("column:");
9847       if (this.column == null) {
9848         sb.append("null");
9849       } else {
9850         sb.append(this.column);
9851       }
9852       first = false;
9853       sb.append(")");
9854       return sb.toString();
9855     }
9856 
9857     public void validate() throws TException {
9858       // check for required fields
9859     }
9860 
9861   }
9862 
9863   public static class get_result implements TBase<get_result._Fields>, java.io.Serializable, Cloneable, Comparable<get_result>   {
9864     private static final TStruct STRUCT_DESC = new TStruct("get_result");
9865 
9866     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
9867     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
9868 
9869     public List<TCell> success;
9870     public IOError io;
9871 
9872     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
9873     public enum _Fields implements TFieldIdEnum {
9874       SUCCESS((short)0, "success"),
9875       IO((short)1, "io");
9876 
9877       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
9878       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
9879 
9880       static {
9881         for (_Fields field : EnumSet.allOf(_Fields.class)) {
9882           byId.put((int)field._thriftId, field);
9883           byName.put(field.getFieldName(), field);
9884         }
9885       }
9886 
9887       /**
9888        * Find the _Fields constant that matches fieldId, or null if its not found.
9889        */
9890       public static _Fields findByThriftId(int fieldId) {
9891         return byId.get(fieldId);
9892       }
9893 
9894       /**
9895        * Find the _Fields constant that matches fieldId, throwing an exception
9896        * if it is not found.
9897        */
9898       public static _Fields findByThriftIdOrThrow(int fieldId) {
9899         _Fields fields = findByThriftId(fieldId);
9900         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
9901         return fields;
9902       }
9903 
9904       /**
9905        * Find the _Fields constant that matches name, or null if its not found.
9906        */
9907       public static _Fields findByName(String name) {
9908         return byName.get(name);
9909       }
9910 
9911       private final short _thriftId;
9912       private final String _fieldName;
9913 
9914       _Fields(short thriftId, String fieldName) {
9915         _thriftId = thriftId;
9916         _fieldName = fieldName;
9917       }
9918 
9919       public short getThriftFieldId() {
9920         return _thriftId;
9921       }
9922 
9923       public String getFieldName() {
9924         return _fieldName;
9925       }
9926     }
9927 
9928     // isset id assignments
9929 
9930     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
9931       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
9932           new ListMetaData(TType.LIST,
9933               new StructMetaData(TType.STRUCT, TCell.class))));
9934       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
9935           new FieldValueMetaData(TType.STRUCT)));
9936     }});
9937 
9938     static {
9939       FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap);
9940     }
9941 
9942     public get_result() {
9943     }
9944 
9945     public get_result(
9946       List<TCell> success,
9947       IOError io)
9948     {
9949       this();
9950       this.success = success;
9951       this.io = io;
9952     }
9953 
9954     /**
9955      * Performs a deep copy on <i>other</i>.
9956      */
9957     public get_result(get_result other) {
9958       if (other.isSetSuccess()) {
9959         List<TCell> __this__success = new ArrayList<TCell>();
9960         for (TCell other_element : other.success) {
9961           __this__success.add(new TCell(other_element));
9962         }
9963         this.success = __this__success;
9964       }
9965       if (other.isSetIo()) {
9966         this.io = new IOError(other.io);
9967       }
9968     }
9969 
9970     public get_result deepCopy() {
9971       return new get_result(this);
9972     }
9973 
9974     @Deprecated
9975     public get_result clone() {
9976       return new get_result(this);
9977     }
9978 
9979     public int getSuccessSize() {
9980       return (this.success == null) ? 0 : this.success.size();
9981     }
9982 
9983     public java.util.Iterator<TCell> getSuccessIterator() {
9984       return (this.success == null) ? null : this.success.iterator();
9985     }
9986 
9987     public void addToSuccess(TCell elem) {
9988       if (this.success == null) {
9989         this.success = new ArrayList<TCell>();
9990       }
9991       this.success.add(elem);
9992     }
9993 
9994     public List<TCell> getSuccess() {
9995       return this.success;
9996     }
9997 
9998     public get_result setSuccess(List<TCell> success) {
9999       this.success = success;
10000       return this;
10001     }
10002 
10003     public void unsetSuccess() {
10004       this.success = null;
10005     }
10006 
10007     /** Returns true if field success is set (has been asigned a value) and false otherwise */
10008     public boolean isSetSuccess() {
10009       return this.success != null;
10010     }
10011 
10012     public void setSuccessIsSet(boolean value) {
10013       if (!value) {
10014         this.success = null;
10015       }
10016     }
10017 
10018     public IOError getIo() {
10019       return this.io;
10020     }
10021 
10022     public get_result setIo(IOError io) {
10023       this.io = io;
10024       return this;
10025     }
10026 
10027     public void unsetIo() {
10028       this.io = null;
10029     }
10030 
10031     /** Returns true if field io is set (has been asigned a value) and false otherwise */
10032     public boolean isSetIo() {
10033       return this.io != null;
10034     }
10035 
10036     public void setIoIsSet(boolean value) {
10037       if (!value) {
10038         this.io = null;
10039       }
10040     }
10041 
10042     public void setFieldValue(_Fields field, Object value) {
10043       switch (field) {
10044       case SUCCESS:
10045         if (value == null) {
10046           unsetSuccess();
10047         } else {
10048           setSuccess((List<TCell>)value);
10049         }
10050         break;
10051 
10052       case IO:
10053         if (value == null) {
10054           unsetIo();
10055         } else {
10056           setIo((IOError)value);
10057         }
10058         break;
10059 
10060       }
10061     }
10062 
10063     public void setFieldValue(int fieldID, Object value) {
10064       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
10065     }
10066 
10067     public Object getFieldValue(_Fields field) {
10068       switch (field) {
10069       case SUCCESS:
10070         return getSuccess();
10071 
10072       case IO:
10073         return getIo();
10074 
10075       }
10076       throw new IllegalStateException();
10077     }
10078 
10079     public Object getFieldValue(int fieldId) {
10080       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
10081     }
10082 
10083     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
10084     public boolean isSet(_Fields field) {
10085       switch (field) {
10086       case SUCCESS:
10087         return isSetSuccess();
10088       case IO:
10089         return isSetIo();
10090       }
10091       throw new IllegalStateException();
10092     }
10093 
10094     public boolean isSet(int fieldID) {
10095       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
10096     }
10097 
10098     @Override
10099     public boolean equals(Object that) {
10100       if (that == null)
10101         return false;
10102       if (that instanceof get_result)
10103         return this.equals((get_result)that);
10104       return false;
10105     }
10106 
10107     public boolean equals(get_result that) {
10108       if (that == null)
10109         return false;
10110 
10111       boolean this_present_success = true && this.isSetSuccess();
10112       boolean that_present_success = true && that.isSetSuccess();
10113       if (this_present_success || that_present_success) {
10114         if (!(this_present_success && that_present_success))
10115           return false;
10116         if (!this.success.equals(that.success))
10117           return false;
10118       }
10119 
10120       boolean this_present_io = true && this.isSetIo();
10121       boolean that_present_io = true && that.isSetIo();
10122       if (this_present_io || that_present_io) {
10123         if (!(this_present_io && that_present_io))
10124           return false;
10125         if (!this.io.equals(that.io))
10126           return false;
10127       }
10128 
10129       return true;
10130     }
10131 
10132     @Override
10133     public int hashCode() {
10134       HashCodeBuilder builder = new HashCodeBuilder();
10135 
10136       boolean present_success = true && (isSetSuccess());
10137       builder.append(present_success);
10138       if (present_success)
10139         builder.append(success);
10140 
10141       boolean present_io = true && (isSetIo());
10142       builder.append(present_io);
10143       if (present_io)
10144         builder.append(io);
10145 
10146       return builder.toHashCode();
10147     }
10148 
10149     public int compareTo(get_result other) {
10150       if (!getClass().equals(other.getClass())) {
10151         return getClass().getName().compareTo(other.getClass().getName());
10152       }
10153 
10154       int lastComparison = 0;
10155       get_result typedOther = (get_result)other;
10156 
10157       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
10158       if (lastComparison != 0) {
10159         return lastComparison;
10160       }
10161       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
10162       if (lastComparison != 0) {
10163         return lastComparison;
10164       }
10165       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
10166       if (lastComparison != 0) {
10167         return lastComparison;
10168       }
10169       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
10170       if (lastComparison != 0) {
10171         return lastComparison;
10172       }
10173       return 0;
10174     }
10175 
10176     public void read(TProtocol iprot) throws TException {
10177       TField field;
10178       iprot.readStructBegin();
10179       while (true)
10180       {
10181         field = iprot.readFieldBegin();
10182         if (field.type == TType.STOP) {
10183           break;
10184         }
10185         _Fields fieldId = _Fields.findByThriftId(field.id);
10186         if (fieldId == null) {
10187           TProtocolUtil.skip(iprot, field.type);
10188         } else {
10189           switch (fieldId) {
10190             case SUCCESS:
10191               if (field.type == TType.LIST) {
10192                 {
10193                   TList _list26 = iprot.readListBegin();
10194                   this.success = new ArrayList<TCell>(_list26.size);
10195                   for (int _i27 = 0; _i27 < _list26.size; ++_i27)
10196                   {
10197                     TCell _elem28;
10198                     _elem28 = new TCell();
10199                     _elem28.read(iprot);
10200                     this.success.add(_elem28);
10201                   }
10202                   iprot.readListEnd();
10203                 }
10204               } else {
10205                 TProtocolUtil.skip(iprot, field.type);
10206               }
10207               break;
10208             case IO:
10209               if (field.type == TType.STRUCT) {
10210                 this.io = new IOError();
10211                 this.io.read(iprot);
10212               } else {
10213                 TProtocolUtil.skip(iprot, field.type);
10214               }
10215               break;
10216           }
10217           iprot.readFieldEnd();
10218         }
10219       }
10220       iprot.readStructEnd();
10221 
10222       // check for required fields of primitive type, which can't be checked in the validate method
10223       validate();
10224     }
10225 
10226     public void write(TProtocol oprot) throws TException {
10227       oprot.writeStructBegin(STRUCT_DESC);
10228 
10229       if (this.isSetSuccess()) {
10230         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
10231         {
10232           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
10233           for (TCell _iter29 : this.success)
10234           {
10235             _iter29.write(oprot);
10236           }
10237           oprot.writeListEnd();
10238         }
10239         oprot.writeFieldEnd();
10240       } else if (this.isSetIo()) {
10241         oprot.writeFieldBegin(IO_FIELD_DESC);
10242         this.io.write(oprot);
10243         oprot.writeFieldEnd();
10244       }
10245       oprot.writeFieldStop();
10246       oprot.writeStructEnd();
10247     }
10248 
10249     @Override
10250     public String toString() {
10251       StringBuilder sb = new StringBuilder("get_result(");
10252       boolean first = true;
10253 
10254       sb.append("success:");
10255       if (this.success == null) {
10256         sb.append("null");
10257       } else {
10258         sb.append(this.success);
10259       }
10260       first = false;
10261       if (!first) sb.append(", ");
10262       sb.append("io:");
10263       if (this.io == null) {
10264         sb.append("null");
10265       } else {
10266         sb.append(this.io);
10267       }
10268       first = false;
10269       sb.append(")");
10270       return sb.toString();
10271     }
10272 
10273     public void validate() throws TException {
10274       // check for required fields
10275     }
10276 
10277   }
10278 
10279   public static class getVer_args implements TBase<getVer_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_args>   {
10280     private static final TStruct STRUCT_DESC = new TStruct("getVer_args");
10281 
10282     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
10283     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
10284     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
10285     private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)4);
10286 
10287     /**
10288      * name of table
10289      */
10290     public byte[] tableName;
10291     /**
10292      * row key
10293      */
10294     public byte[] row;
10295     /**
10296      * column name
10297      */
10298     public byte[] column;
10299     /**
10300      * number of versions to retrieve
10301      */
10302     public int numVersions;
10303 
10304     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
10305     public enum _Fields implements TFieldIdEnum {
10306       /**
10307        * name of table
10308        */
10309       TABLE_NAME((short)1, "tableName"),
10310       /**
10311        * row key
10312        */
10313       ROW((short)2, "row"),
10314       /**
10315        * column name
10316        */
10317       COLUMN((short)3, "column"),
10318       /**
10319        * number of versions to retrieve
10320        */
10321       NUM_VERSIONS((short)4, "numVersions");
10322 
10323       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
10324       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10325 
10326       static {
10327         for (_Fields field : EnumSet.allOf(_Fields.class)) {
10328           byId.put((int)field._thriftId, field);
10329           byName.put(field.getFieldName(), field);
10330         }
10331       }
10332 
10333       /**
10334        * Find the _Fields constant that matches fieldId, or null if its not found.
10335        */
10336       public static _Fields findByThriftId(int fieldId) {
10337         return byId.get(fieldId);
10338       }
10339 
10340       /**
10341        * Find the _Fields constant that matches fieldId, throwing an exception
10342        * if it is not found.
10343        */
10344       public static _Fields findByThriftIdOrThrow(int fieldId) {
10345         _Fields fields = findByThriftId(fieldId);
10346         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10347         return fields;
10348       }
10349 
10350       /**
10351        * Find the _Fields constant that matches name, or null if its not found.
10352        */
10353       public static _Fields findByName(String name) {
10354         return byName.get(name);
10355       }
10356 
10357       private final short _thriftId;
10358       private final String _fieldName;
10359 
10360       _Fields(short thriftId, String fieldName) {
10361         _thriftId = thriftId;
10362         _fieldName = fieldName;
10363       }
10364 
10365       public short getThriftFieldId() {
10366         return _thriftId;
10367       }
10368 
10369       public String getFieldName() {
10370         return _fieldName;
10371       }
10372     }
10373 
10374     // isset id assignments
10375     private static final int __NUMVERSIONS_ISSET_ID = 0;
10376     private BitSet __isset_bit_vector = new BitSet(1);
10377 
10378     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
10379       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
10380           new FieldValueMetaData(TType.STRING)));
10381       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
10382           new FieldValueMetaData(TType.STRING)));
10383       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
10384           new FieldValueMetaData(TType.STRING)));
10385       put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT,
10386           new FieldValueMetaData(TType.I32)));
10387     }});
10388 
10389     static {
10390       FieldMetaData.addStructMetaDataMap(getVer_args.class, metaDataMap);
10391     }
10392 
10393     public getVer_args() {
10394     }
10395 
10396     public getVer_args(
10397       byte[] tableName,
10398       byte[] row,
10399       byte[] column,
10400       int numVersions)
10401     {
10402       this();
10403       this.tableName = tableName;
10404       this.row = row;
10405       this.column = column;
10406       this.numVersions = numVersions;
10407       setNumVersionsIsSet(true);
10408     }
10409 
10410     /**
10411      * Performs a deep copy on <i>other</i>.
10412      */
10413     public getVer_args(getVer_args other) {
10414       __isset_bit_vector.clear();
10415       __isset_bit_vector.or(other.__isset_bit_vector);
10416       if (other.isSetTableName()) {
10417         this.tableName = other.tableName;
10418       }
10419       if (other.isSetRow()) {
10420         this.row = other.row;
10421       }
10422       if (other.isSetColumn()) {
10423         this.column = other.column;
10424       }
10425       this.numVersions = other.numVersions;
10426     }
10427 
10428     public getVer_args deepCopy() {
10429       return new getVer_args(this);
10430     }
10431 
10432     @Deprecated
10433     public getVer_args clone() {
10434       return new getVer_args(this);
10435     }
10436 
10437     /**
10438      * name of table
10439      */
10440     public byte[] getTableName() {
10441       return this.tableName;
10442     }
10443 
10444     /**
10445      * name of table
10446      */
10447     public getVer_args setTableName(byte[] tableName) {
10448       this.tableName = tableName;
10449       return this;
10450     }
10451 
10452     public void unsetTableName() {
10453       this.tableName = null;
10454     }
10455 
10456     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
10457     public boolean isSetTableName() {
10458       return this.tableName != null;
10459     }
10460 
10461     public void setTableNameIsSet(boolean value) {
10462       if (!value) {
10463         this.tableName = null;
10464       }
10465     }
10466 
10467     /**
10468      * row key
10469      */
10470     public byte[] getRow() {
10471       return this.row;
10472     }
10473 
10474     /**
10475      * row key
10476      */
10477     public getVer_args setRow(byte[] row) {
10478       this.row = row;
10479       return this;
10480     }
10481 
10482     public void unsetRow() {
10483       this.row = null;
10484     }
10485 
10486     /** Returns true if field row is set (has been asigned a value) and false otherwise */
10487     public boolean isSetRow() {
10488       return this.row != null;
10489     }
10490 
10491     public void setRowIsSet(boolean value) {
10492       if (!value) {
10493         this.row = null;
10494       }
10495     }
10496 
10497     /**
10498      * column name
10499      */
10500     public byte[] getColumn() {
10501       return this.column;
10502     }
10503 
10504     /**
10505      * column name
10506      */
10507     public getVer_args setColumn(byte[] column) {
10508       this.column = column;
10509       return this;
10510     }
10511 
10512     public void unsetColumn() {
10513       this.column = null;
10514     }
10515 
10516     /** Returns true if field column is set (has been asigned a value) and false otherwise */
10517     public boolean isSetColumn() {
10518       return this.column != null;
10519     }
10520 
10521     public void setColumnIsSet(boolean value) {
10522       if (!value) {
10523         this.column = null;
10524       }
10525     }
10526 
10527     /**
10528      * number of versions to retrieve
10529      */
10530     public int getNumVersions() {
10531       return this.numVersions;
10532     }
10533 
10534     /**
10535      * number of versions to retrieve
10536      */
10537     public getVer_args setNumVersions(int numVersions) {
10538       this.numVersions = numVersions;
10539       setNumVersionsIsSet(true);
10540       return this;
10541     }
10542 
10543     public void unsetNumVersions() {
10544       __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID);
10545     }
10546 
10547     /** Returns true if field numVersions is set (has been asigned a value) and false otherwise */
10548     public boolean isSetNumVersions() {
10549       return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID);
10550     }
10551 
10552     public void setNumVersionsIsSet(boolean value) {
10553       __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value);
10554     }
10555 
10556     public void setFieldValue(_Fields field, Object value) {
10557       switch (field) {
10558       case TABLE_NAME:
10559         if (value == null) {
10560           unsetTableName();
10561         } else {
10562           setTableName((byte[])value);
10563         }
10564         break;
10565 
10566       case ROW:
10567         if (value == null) {
10568           unsetRow();
10569         } else {
10570           setRow((byte[])value);
10571         }
10572         break;
10573 
10574       case COLUMN:
10575         if (value == null) {
10576           unsetColumn();
10577         } else {
10578           setColumn((byte[])value);
10579         }
10580         break;
10581 
10582       case NUM_VERSIONS:
10583         if (value == null) {
10584           unsetNumVersions();
10585         } else {
10586           setNumVersions((Integer)value);
10587         }
10588         break;
10589 
10590       }
10591     }
10592 
10593     public void setFieldValue(int fieldID, Object value) {
10594       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
10595     }
10596 
10597     public Object getFieldValue(_Fields field) {
10598       switch (field) {
10599       case TABLE_NAME:
10600         return getTableName();
10601 
10602       case ROW:
10603         return getRow();
10604 
10605       case COLUMN:
10606         return getColumn();
10607 
10608       case NUM_VERSIONS:
10609         return new Integer(getNumVersions());
10610 
10611       }
10612       throw new IllegalStateException();
10613     }
10614 
10615     public Object getFieldValue(int fieldId) {
10616       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
10617     }
10618 
10619     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
10620     public boolean isSet(_Fields field) {
10621       switch (field) {
10622       case TABLE_NAME:
10623         return isSetTableName();
10624       case ROW:
10625         return isSetRow();
10626       case COLUMN:
10627         return isSetColumn();
10628       case NUM_VERSIONS:
10629         return isSetNumVersions();
10630       }
10631       throw new IllegalStateException();
10632     }
10633 
10634     public boolean isSet(int fieldID) {
10635       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
10636     }
10637 
10638     @Override
10639     public boolean equals(Object that) {
10640       if (that == null)
10641         return false;
10642       if (that instanceof getVer_args)
10643         return this.equals((getVer_args)that);
10644       return false;
10645     }
10646 
10647     public boolean equals(getVer_args that) {
10648       if (that == null)
10649         return false;
10650 
10651       boolean this_present_tableName = true && this.isSetTableName();
10652       boolean that_present_tableName = true && that.isSetTableName();
10653       if (this_present_tableName || that_present_tableName) {
10654         if (!(this_present_tableName && that_present_tableName))
10655           return false;
10656         if (!java.util.Arrays.equals(this.tableName, that.tableName))
10657           return false;
10658       }
10659 
10660       boolean this_present_row = true && this.isSetRow();
10661       boolean that_present_row = true && that.isSetRow();
10662       if (this_present_row || that_present_row) {
10663         if (!(this_present_row && that_present_row))
10664           return false;
10665         if (!java.util.Arrays.equals(this.row, that.row))
10666           return false;
10667       }
10668 
10669       boolean this_present_column = true && this.isSetColumn();
10670       boolean that_present_column = true && that.isSetColumn();
10671       if (this_present_column || that_present_column) {
10672         if (!(this_present_column && that_present_column))
10673           return false;
10674         if (!java.util.Arrays.equals(this.column, that.column))
10675           return false;
10676       }
10677 
10678       boolean this_present_numVersions = true;
10679       boolean that_present_numVersions = true;
10680       if (this_present_numVersions || that_present_numVersions) {
10681         if (!(this_present_numVersions && that_present_numVersions))
10682           return false;
10683         if (this.numVersions != that.numVersions)
10684           return false;
10685       }
10686 
10687       return true;
10688     }
10689 
10690     @Override
10691     public int hashCode() {
10692       HashCodeBuilder builder = new HashCodeBuilder();
10693 
10694       boolean present_tableName = true && (isSetTableName());
10695       builder.append(present_tableName);
10696       if (present_tableName)
10697         builder.append(tableName);
10698 
10699       boolean present_row = true && (isSetRow());
10700       builder.append(present_row);
10701       if (present_row)
10702         builder.append(row);
10703 
10704       boolean present_column = true && (isSetColumn());
10705       builder.append(present_column);
10706       if (present_column)
10707         builder.append(column);
10708 
10709       boolean present_numVersions = true;
10710       builder.append(present_numVersions);
10711       if (present_numVersions)
10712         builder.append(numVersions);
10713 
10714       return builder.toHashCode();
10715     }
10716 
10717     public int compareTo(getVer_args other) {
10718       if (!getClass().equals(other.getClass())) {
10719         return getClass().getName().compareTo(other.getClass().getName());
10720       }
10721 
10722       int lastComparison = 0;
10723       getVer_args typedOther = (getVer_args)other;
10724 
10725       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
10726       if (lastComparison != 0) {
10727         return lastComparison;
10728       }
10729       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
10730       if (lastComparison != 0) {
10731         return lastComparison;
10732       }
10733       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
10734       if (lastComparison != 0) {
10735         return lastComparison;
10736       }
10737       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
10738       if (lastComparison != 0) {
10739         return lastComparison;
10740       }
10741       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
10742       if (lastComparison != 0) {
10743         return lastComparison;
10744       }
10745       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
10746       if (lastComparison != 0) {
10747         return lastComparison;
10748       }
10749       lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(isSetNumVersions());
10750       if (lastComparison != 0) {
10751         return lastComparison;
10752       }
10753       lastComparison = TBaseHelper.compareTo(numVersions, typedOther.numVersions);
10754       if (lastComparison != 0) {
10755         return lastComparison;
10756       }
10757       return 0;
10758     }
10759 
10760     public void read(TProtocol iprot) throws TException {
10761       TField field;
10762       iprot.readStructBegin();
10763       while (true)
10764       {
10765         field = iprot.readFieldBegin();
10766         if (field.type == TType.STOP) {
10767           break;
10768         }
10769         _Fields fieldId = _Fields.findByThriftId(field.id);
10770         if (fieldId == null) {
10771           TProtocolUtil.skip(iprot, field.type);
10772         } else {
10773           switch (fieldId) {
10774             case TABLE_NAME:
10775               if (field.type == TType.STRING) {
10776                 this.tableName = iprot.readBinary();
10777               } else {
10778                 TProtocolUtil.skip(iprot, field.type);
10779               }
10780               break;
10781             case ROW:
10782               if (field.type == TType.STRING) {
10783                 this.row = iprot.readBinary();
10784               } else {
10785                 TProtocolUtil.skip(iprot, field.type);
10786               }
10787               break;
10788             case COLUMN:
10789               if (field.type == TType.STRING) {
10790                 this.column = iprot.readBinary();
10791               } else {
10792                 TProtocolUtil.skip(iprot, field.type);
10793               }
10794               break;
10795             case NUM_VERSIONS:
10796               if (field.type == TType.I32) {
10797                 this.numVersions = iprot.readI32();
10798                 setNumVersionsIsSet(true);
10799               } else {
10800                 TProtocolUtil.skip(iprot, field.type);
10801               }
10802               break;
10803           }
10804           iprot.readFieldEnd();
10805         }
10806       }
10807       iprot.readStructEnd();
10808 
10809       // check for required fields of primitive type, which can't be checked in the validate method
10810       validate();
10811     }
10812 
10813     public void write(TProtocol oprot) throws TException {
10814       validate();
10815 
10816       oprot.writeStructBegin(STRUCT_DESC);
10817       if (this.tableName != null) {
10818         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
10819         oprot.writeBinary(this.tableName);
10820         oprot.writeFieldEnd();
10821       }
10822       if (this.row != null) {
10823         oprot.writeFieldBegin(ROW_FIELD_DESC);
10824         oprot.writeBinary(this.row);
10825         oprot.writeFieldEnd();
10826       }
10827       if (this.column != null) {
10828         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
10829         oprot.writeBinary(this.column);
10830         oprot.writeFieldEnd();
10831       }
10832       oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
10833       oprot.writeI32(this.numVersions);
10834       oprot.writeFieldEnd();
10835       oprot.writeFieldStop();
10836       oprot.writeStructEnd();
10837     }
10838 
10839     @Override
10840     public String toString() {
10841       StringBuilder sb = new StringBuilder("getVer_args(");
10842       boolean first = true;
10843 
10844       sb.append("tableName:");
10845       if (this.tableName == null) {
10846         sb.append("null");
10847       } else {
10848         sb.append(this.tableName);
10849       }
10850       first = false;
10851       if (!first) sb.append(", ");
10852       sb.append("row:");
10853       if (this.row == null) {
10854         sb.append("null");
10855       } else {
10856         sb.append(this.row);
10857       }
10858       first = false;
10859       if (!first) sb.append(", ");
10860       sb.append("column:");
10861       if (this.column == null) {
10862         sb.append("null");
10863       } else {
10864         sb.append(this.column);
10865       }
10866       first = false;
10867       if (!first) sb.append(", ");
10868       sb.append("numVersions:");
10869       sb.append(this.numVersions);
10870       first = false;
10871       sb.append(")");
10872       return sb.toString();
10873     }
10874 
10875     public void validate() throws TException {
10876       // check for required fields
10877     }
10878 
10879   }
10880 
10881   public static class getVer_result implements TBase<getVer_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVer_result>   {
10882     private static final TStruct STRUCT_DESC = new TStruct("getVer_result");
10883 
10884     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
10885     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
10886 
10887     public List<TCell> success;
10888     public IOError io;
10889 
10890     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
10891     public enum _Fields implements TFieldIdEnum {
10892       SUCCESS((short)0, "success"),
10893       IO((short)1, "io");
10894 
10895       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
10896       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
10897 
10898       static {
10899         for (_Fields field : EnumSet.allOf(_Fields.class)) {
10900           byId.put((int)field._thriftId, field);
10901           byName.put(field.getFieldName(), field);
10902         }
10903       }
10904 
10905       /**
10906        * Find the _Fields constant that matches fieldId, or null if its not found.
10907        */
10908       public static _Fields findByThriftId(int fieldId) {
10909         return byId.get(fieldId);
10910       }
10911 
10912       /**
10913        * Find the _Fields constant that matches fieldId, throwing an exception
10914        * if it is not found.
10915        */
10916       public static _Fields findByThriftIdOrThrow(int fieldId) {
10917         _Fields fields = findByThriftId(fieldId);
10918         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
10919         return fields;
10920       }
10921 
10922       /**
10923        * Find the _Fields constant that matches name, or null if its not found.
10924        */
10925       public static _Fields findByName(String name) {
10926         return byName.get(name);
10927       }
10928 
10929       private final short _thriftId;
10930       private final String _fieldName;
10931 
10932       _Fields(short thriftId, String fieldName) {
10933         _thriftId = thriftId;
10934         _fieldName = fieldName;
10935       }
10936 
10937       public short getThriftFieldId() {
10938         return _thriftId;
10939       }
10940 
10941       public String getFieldName() {
10942         return _fieldName;
10943       }
10944     }
10945 
10946     // isset id assignments
10947 
10948     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
10949       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
10950           new ListMetaData(TType.LIST,
10951               new StructMetaData(TType.STRUCT, TCell.class))));
10952       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
10953           new FieldValueMetaData(TType.STRUCT)));
10954     }});
10955 
10956     static {
10957       FieldMetaData.addStructMetaDataMap(getVer_result.class, metaDataMap);
10958     }
10959 
10960     public getVer_result() {
10961     }
10962 
10963     public getVer_result(
10964       List<TCell> success,
10965       IOError io)
10966     {
10967       this();
10968       this.success = success;
10969       this.io = io;
10970     }
10971 
10972     /**
10973      * Performs a deep copy on <i>other</i>.
10974      */
10975     public getVer_result(getVer_result other) {
10976       if (other.isSetSuccess()) {
10977         List<TCell> __this__success = new ArrayList<TCell>();
10978         for (TCell other_element : other.success) {
10979           __this__success.add(new TCell(other_element));
10980         }
10981         this.success = __this__success;
10982       }
10983       if (other.isSetIo()) {
10984         this.io = new IOError(other.io);
10985       }
10986     }
10987 
10988     public getVer_result deepCopy() {
10989       return new getVer_result(this);
10990     }
10991 
10992     @Deprecated
10993     public getVer_result clone() {
10994       return new getVer_result(this);
10995     }
10996 
10997     public int getSuccessSize() {
10998       return (this.success == null) ? 0 : this.success.size();
10999     }
11000 
11001     public java.util.Iterator<TCell> getSuccessIterator() {
11002       return (this.success == null) ? null : this.success.iterator();
11003     }
11004 
11005     public void addToSuccess(TCell elem) {
11006       if (this.success == null) {
11007         this.success = new ArrayList<TCell>();
11008       }
11009       this.success.add(elem);
11010     }
11011 
11012     public List<TCell> getSuccess() {
11013       return this.success;
11014     }
11015 
11016     public getVer_result setSuccess(List<TCell> success) {
11017       this.success = success;
11018       return this;
11019     }
11020 
11021     public void unsetSuccess() {
11022       this.success = null;
11023     }
11024 
11025     /** Returns true if field success is set (has been asigned a value) and false otherwise */
11026     public boolean isSetSuccess() {
11027       return this.success != null;
11028     }
11029 
11030     public void setSuccessIsSet(boolean value) {
11031       if (!value) {
11032         this.success = null;
11033       }
11034     }
11035 
11036     public IOError getIo() {
11037       return this.io;
11038     }
11039 
11040     public getVer_result setIo(IOError io) {
11041       this.io = io;
11042       return this;
11043     }
11044 
11045     public void unsetIo() {
11046       this.io = null;
11047     }
11048 
11049     /** Returns true if field io is set (has been asigned a value) and false otherwise */
11050     public boolean isSetIo() {
11051       return this.io != null;
11052     }
11053 
11054     public void setIoIsSet(boolean value) {
11055       if (!value) {
11056         this.io = null;
11057       }
11058     }
11059 
11060     public void setFieldValue(_Fields field, Object value) {
11061       switch (field) {
11062       case SUCCESS:
11063         if (value == null) {
11064           unsetSuccess();
11065         } else {
11066           setSuccess((List<TCell>)value);
11067         }
11068         break;
11069 
11070       case IO:
11071         if (value == null) {
11072           unsetIo();
11073         } else {
11074           setIo((IOError)value);
11075         }
11076         break;
11077 
11078       }
11079     }
11080 
11081     public void setFieldValue(int fieldID, Object value) {
11082       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
11083     }
11084 
11085     public Object getFieldValue(_Fields field) {
11086       switch (field) {
11087       case SUCCESS:
11088         return getSuccess();
11089 
11090       case IO:
11091         return getIo();
11092 
11093       }
11094       throw new IllegalStateException();
11095     }
11096 
11097     public Object getFieldValue(int fieldId) {
11098       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
11099     }
11100 
11101     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
11102     public boolean isSet(_Fields field) {
11103       switch (field) {
11104       case SUCCESS:
11105         return isSetSuccess();
11106       case IO:
11107         return isSetIo();
11108       }
11109       throw new IllegalStateException();
11110     }
11111 
11112     public boolean isSet(int fieldID) {
11113       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
11114     }
11115 
11116     @Override
11117     public boolean equals(Object that) {
11118       if (that == null)
11119         return false;
11120       if (that instanceof getVer_result)
11121         return this.equals((getVer_result)that);
11122       return false;
11123     }
11124 
11125     public boolean equals(getVer_result that) {
11126       if (that == null)
11127         return false;
11128 
11129       boolean this_present_success = true && this.isSetSuccess();
11130       boolean that_present_success = true && that.isSetSuccess();
11131       if (this_present_success || that_present_success) {
11132         if (!(this_present_success && that_present_success))
11133           return false;
11134         if (!this.success.equals(that.success))
11135           return false;
11136       }
11137 
11138       boolean this_present_io = true && this.isSetIo();
11139       boolean that_present_io = true && that.isSetIo();
11140       if (this_present_io || that_present_io) {
11141         if (!(this_present_io && that_present_io))
11142           return false;
11143         if (!this.io.equals(that.io))
11144           return false;
11145       }
11146 
11147       return true;
11148     }
11149 
11150     @Override
11151     public int hashCode() {
11152       HashCodeBuilder builder = new HashCodeBuilder();
11153 
11154       boolean present_success = true && (isSetSuccess());
11155       builder.append(present_success);
11156       if (present_success)
11157         builder.append(success);
11158 
11159       boolean present_io = true && (isSetIo());
11160       builder.append(present_io);
11161       if (present_io)
11162         builder.append(io);
11163 
11164       return builder.toHashCode();
11165     }
11166 
11167     public int compareTo(getVer_result other) {
11168       if (!getClass().equals(other.getClass())) {
11169         return getClass().getName().compareTo(other.getClass().getName());
11170       }
11171 
11172       int lastComparison = 0;
11173       getVer_result typedOther = (getVer_result)other;
11174 
11175       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
11176       if (lastComparison != 0) {
11177         return lastComparison;
11178       }
11179       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
11180       if (lastComparison != 0) {
11181         return lastComparison;
11182       }
11183       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
11184       if (lastComparison != 0) {
11185         return lastComparison;
11186       }
11187       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
11188       if (lastComparison != 0) {
11189         return lastComparison;
11190       }
11191       return 0;
11192     }
11193 
11194     public void read(TProtocol iprot) throws TException {
11195       TField field;
11196       iprot.readStructBegin();
11197       while (true)
11198       {
11199         field = iprot.readFieldBegin();
11200         if (field.type == TType.STOP) {
11201           break;
11202         }
11203         _Fields fieldId = _Fields.findByThriftId(field.id);
11204         if (fieldId == null) {
11205           TProtocolUtil.skip(iprot, field.type);
11206         } else {
11207           switch (fieldId) {
11208             case SUCCESS:
11209               if (field.type == TType.LIST) {
11210                 {
11211                   TList _list30 = iprot.readListBegin();
11212                   this.success = new ArrayList<TCell>(_list30.size);
11213                   for (int _i31 = 0; _i31 < _list30.size; ++_i31)
11214                   {
11215                     TCell _elem32;
11216                     _elem32 = new TCell();
11217                     _elem32.read(iprot);
11218                     this.success.add(_elem32);
11219                   }
11220                   iprot.readListEnd();
11221                 }
11222               } else {
11223                 TProtocolUtil.skip(iprot, field.type);
11224               }
11225               break;
11226             case IO:
11227               if (field.type == TType.STRUCT) {
11228                 this.io = new IOError();
11229                 this.io.read(iprot);
11230               } else {
11231                 TProtocolUtil.skip(iprot, field.type);
11232               }
11233               break;
11234           }
11235           iprot.readFieldEnd();
11236         }
11237       }
11238       iprot.readStructEnd();
11239 
11240       // check for required fields of primitive type, which can't be checked in the validate method
11241       validate();
11242     }
11243 
11244     public void write(TProtocol oprot) throws TException {
11245       oprot.writeStructBegin(STRUCT_DESC);
11246 
11247       if (this.isSetSuccess()) {
11248         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11249         {
11250           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
11251           for (TCell _iter33 : this.success)
11252           {
11253             _iter33.write(oprot);
11254           }
11255           oprot.writeListEnd();
11256         }
11257         oprot.writeFieldEnd();
11258       } else if (this.isSetIo()) {
11259         oprot.writeFieldBegin(IO_FIELD_DESC);
11260         this.io.write(oprot);
11261         oprot.writeFieldEnd();
11262       }
11263       oprot.writeFieldStop();
11264       oprot.writeStructEnd();
11265     }
11266 
11267     @Override
11268     public String toString() {
11269       StringBuilder sb = new StringBuilder("getVer_result(");
11270       boolean first = true;
11271 
11272       sb.append("success:");
11273       if (this.success == null) {
11274         sb.append("null");
11275       } else {
11276         sb.append(this.success);
11277       }
11278       first = false;
11279       if (!first) sb.append(", ");
11280       sb.append("io:");
11281       if (this.io == null) {
11282         sb.append("null");
11283       } else {
11284         sb.append(this.io);
11285       }
11286       first = false;
11287       sb.append(")");
11288       return sb.toString();
11289     }
11290 
11291     public void validate() throws TException {
11292       // check for required fields
11293     }
11294 
11295   }
11296 
11297   public static class getVerTs_args implements TBase<getVerTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_args>   {
11298     private static final TStruct STRUCT_DESC = new TStruct("getVerTs_args");
11299 
11300     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
11301     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
11302     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
11303     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
11304     private static final TField NUM_VERSIONS_FIELD_DESC = new TField("numVersions", TType.I32, (short)5);
11305 
11306     /**
11307      * name of table
11308      */
11309     public byte[] tableName;
11310     /**
11311      * row key
11312      */
11313     public byte[] row;
11314     /**
11315      * column name
11316      */
11317     public byte[] column;
11318     /**
11319      * timestamp
11320      */
11321     public long timestamp;
11322     /**
11323      * number of versions to retrieve
11324      */
11325     public int numVersions;
11326 
11327     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
11328     public enum _Fields implements TFieldIdEnum {
11329       /**
11330        * name of table
11331        */
11332       TABLE_NAME((short)1, "tableName"),
11333       /**
11334        * row key
11335        */
11336       ROW((short)2, "row"),
11337       /**
11338        * column name
11339        */
11340       COLUMN((short)3, "column"),
11341       /**
11342        * timestamp
11343        */
11344       TIMESTAMP((short)4, "timestamp"),
11345       /**
11346        * number of versions to retrieve
11347        */
11348       NUM_VERSIONS((short)5, "numVersions");
11349 
11350       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
11351       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
11352 
11353       static {
11354         for (_Fields field : EnumSet.allOf(_Fields.class)) {
11355           byId.put((int)field._thriftId, field);
11356           byName.put(field.getFieldName(), field);
11357         }
11358       }
11359 
11360       /**
11361        * Find the _Fields constant that matches fieldId, or null if its not found.
11362        */
11363       public static _Fields findByThriftId(int fieldId) {
11364         return byId.get(fieldId);
11365       }
11366 
11367       /**
11368        * Find the _Fields constant that matches fieldId, throwing an exception
11369        * if it is not found.
11370        */
11371       public static _Fields findByThriftIdOrThrow(int fieldId) {
11372         _Fields fields = findByThriftId(fieldId);
11373         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
11374         return fields;
11375       }
11376 
11377       /**
11378        * Find the _Fields constant that matches name, or null if its not found.
11379        */
11380       public static _Fields findByName(String name) {
11381         return byName.get(name);
11382       }
11383 
11384       private final short _thriftId;
11385       private final String _fieldName;
11386 
11387       _Fields(short thriftId, String fieldName) {
11388         _thriftId = thriftId;
11389         _fieldName = fieldName;
11390       }
11391 
11392       public short getThriftFieldId() {
11393         return _thriftId;
11394       }
11395 
11396       public String getFieldName() {
11397         return _fieldName;
11398       }
11399     }
11400 
11401     // isset id assignments
11402     private static final int __TIMESTAMP_ISSET_ID = 0;
11403     private static final int __NUMVERSIONS_ISSET_ID = 1;
11404     private BitSet __isset_bit_vector = new BitSet(2);
11405 
11406     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
11407       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
11408           new FieldValueMetaData(TType.STRING)));
11409       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
11410           new FieldValueMetaData(TType.STRING)));
11411       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
11412           new FieldValueMetaData(TType.STRING)));
11413       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
11414           new FieldValueMetaData(TType.I64)));
11415       put(_Fields.NUM_VERSIONS, new FieldMetaData("numVersions", TFieldRequirementType.DEFAULT,
11416           new FieldValueMetaData(TType.I32)));
11417     }});
11418 
11419     static {
11420       FieldMetaData.addStructMetaDataMap(getVerTs_args.class, metaDataMap);
11421     }
11422 
11423     public getVerTs_args() {
11424     }
11425 
11426     public getVerTs_args(
11427       byte[] tableName,
11428       byte[] row,
11429       byte[] column,
11430       long timestamp,
11431       int numVersions)
11432     {
11433       this();
11434       this.tableName = tableName;
11435       this.row = row;
11436       this.column = column;
11437       this.timestamp = timestamp;
11438       setTimestampIsSet(true);
11439       this.numVersions = numVersions;
11440       setNumVersionsIsSet(true);
11441     }
11442 
11443     /**
11444      * Performs a deep copy on <i>other</i>.
11445      */
11446     public getVerTs_args(getVerTs_args other) {
11447       __isset_bit_vector.clear();
11448       __isset_bit_vector.or(other.__isset_bit_vector);
11449       if (other.isSetTableName()) {
11450         this.tableName = other.tableName;
11451       }
11452       if (other.isSetRow()) {
11453         this.row = other.row;
11454       }
11455       if (other.isSetColumn()) {
11456         this.column = other.column;
11457       }
11458       this.timestamp = other.timestamp;
11459       this.numVersions = other.numVersions;
11460     }
11461 
11462     public getVerTs_args deepCopy() {
11463       return new getVerTs_args(this);
11464     }
11465 
11466     @Deprecated
11467     public getVerTs_args clone() {
11468       return new getVerTs_args(this);
11469     }
11470 
11471     /**
11472      * name of table
11473      */
11474     public byte[] getTableName() {
11475       return this.tableName;
11476     }
11477 
11478     /**
11479      * name of table
11480      */
11481     public getVerTs_args setTableName(byte[] tableName) {
11482       this.tableName = tableName;
11483       return this;
11484     }
11485 
11486     public void unsetTableName() {
11487       this.tableName = null;
11488     }
11489 
11490     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
11491     public boolean isSetTableName() {
11492       return this.tableName != null;
11493     }
11494 
11495     public void setTableNameIsSet(boolean value) {
11496       if (!value) {
11497         this.tableName = null;
11498       }
11499     }
11500 
11501     /**
11502      * row key
11503      */
11504     public byte[] getRow() {
11505       return this.row;
11506     }
11507 
11508     /**
11509      * row key
11510      */
11511     public getVerTs_args setRow(byte[] row) {
11512       this.row = row;
11513       return this;
11514     }
11515 
11516     public void unsetRow() {
11517       this.row = null;
11518     }
11519 
11520     /** Returns true if field row is set (has been asigned a value) and false otherwise */
11521     public boolean isSetRow() {
11522       return this.row != null;
11523     }
11524 
11525     public void setRowIsSet(boolean value) {
11526       if (!value) {
11527         this.row = null;
11528       }
11529     }
11530 
11531     /**
11532      * column name
11533      */
11534     public byte[] getColumn() {
11535       return this.column;
11536     }
11537 
11538     /**
11539      * column name
11540      */
11541     public getVerTs_args setColumn(byte[] column) {
11542       this.column = column;
11543       return this;
11544     }
11545 
11546     public void unsetColumn() {
11547       this.column = null;
11548     }
11549 
11550     /** Returns true if field column is set (has been asigned a value) and false otherwise */
11551     public boolean isSetColumn() {
11552       return this.column != null;
11553     }
11554 
11555     public void setColumnIsSet(boolean value) {
11556       if (!value) {
11557         this.column = null;
11558       }
11559     }
11560 
11561     /**
11562      * timestamp
11563      */
11564     public long getTimestamp() {
11565       return this.timestamp;
11566     }
11567 
11568     /**
11569      * timestamp
11570      */
11571     public getVerTs_args setTimestamp(long timestamp) {
11572       this.timestamp = timestamp;
11573       setTimestampIsSet(true);
11574       return this;
11575     }
11576 
11577     public void unsetTimestamp() {
11578       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
11579     }
11580 
11581     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
11582     public boolean isSetTimestamp() {
11583       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
11584     }
11585 
11586     public void setTimestampIsSet(boolean value) {
11587       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
11588     }
11589 
11590     /**
11591      * number of versions to retrieve
11592      */
11593     public int getNumVersions() {
11594       return this.numVersions;
11595     }
11596 
11597     /**
11598      * number of versions to retrieve
11599      */
11600     public getVerTs_args setNumVersions(int numVersions) {
11601       this.numVersions = numVersions;
11602       setNumVersionsIsSet(true);
11603       return this;
11604     }
11605 
11606     public void unsetNumVersions() {
11607       __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID);
11608     }
11609 
11610     /** Returns true if field numVersions is set (has been asigned a value) and false otherwise */
11611     public boolean isSetNumVersions() {
11612       return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID);
11613     }
11614 
11615     public void setNumVersionsIsSet(boolean value) {
11616       __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value);
11617     }
11618 
11619     public void setFieldValue(_Fields field, Object value) {
11620       switch (field) {
11621       case TABLE_NAME:
11622         if (value == null) {
11623           unsetTableName();
11624         } else {
11625           setTableName((byte[])value);
11626         }
11627         break;
11628 
11629       case ROW:
11630         if (value == null) {
11631           unsetRow();
11632         } else {
11633           setRow((byte[])value);
11634         }
11635         break;
11636 
11637       case COLUMN:
11638         if (value == null) {
11639           unsetColumn();
11640         } else {
11641           setColumn((byte[])value);
11642         }
11643         break;
11644 
11645       case TIMESTAMP:
11646         if (value == null) {
11647           unsetTimestamp();
11648         } else {
11649           setTimestamp((Long)value);
11650         }
11651         break;
11652 
11653       case NUM_VERSIONS:
11654         if (value == null) {
11655           unsetNumVersions();
11656         } else {
11657           setNumVersions((Integer)value);
11658         }
11659         break;
11660 
11661       }
11662     }
11663 
11664     public void setFieldValue(int fieldID, Object value) {
11665       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
11666     }
11667 
11668     public Object getFieldValue(_Fields field) {
11669       switch (field) {
11670       case TABLE_NAME:
11671         return getTableName();
11672 
11673       case ROW:
11674         return getRow();
11675 
11676       case COLUMN:
11677         return getColumn();
11678 
11679       case TIMESTAMP:
11680         return new Long(getTimestamp());
11681 
11682       case NUM_VERSIONS:
11683         return new Integer(getNumVersions());
11684 
11685       }
11686       throw new IllegalStateException();
11687     }
11688 
11689     public Object getFieldValue(int fieldId) {
11690       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
11691     }
11692 
11693     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
11694     public boolean isSet(_Fields field) {
11695       switch (field) {
11696       case TABLE_NAME:
11697         return isSetTableName();
11698       case ROW:
11699         return isSetRow();
11700       case COLUMN:
11701         return isSetColumn();
11702       case TIMESTAMP:
11703         return isSetTimestamp();
11704       case NUM_VERSIONS:
11705         return isSetNumVersions();
11706       }
11707       throw new IllegalStateException();
11708     }
11709 
11710     public boolean isSet(int fieldID) {
11711       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
11712     }
11713 
11714     @Override
11715     public boolean equals(Object that) {
11716       if (that == null)
11717         return false;
11718       if (that instanceof getVerTs_args)
11719         return this.equals((getVerTs_args)that);
11720       return false;
11721     }
11722 
11723     public boolean equals(getVerTs_args that) {
11724       if (that == null)
11725         return false;
11726 
11727       boolean this_present_tableName = true && this.isSetTableName();
11728       boolean that_present_tableName = true && that.isSetTableName();
11729       if (this_present_tableName || that_present_tableName) {
11730         if (!(this_present_tableName && that_present_tableName))
11731           return false;
11732         if (!java.util.Arrays.equals(this.tableName, that.tableName))
11733           return false;
11734       }
11735 
11736       boolean this_present_row = true && this.isSetRow();
11737       boolean that_present_row = true && that.isSetRow();
11738       if (this_present_row || that_present_row) {
11739         if (!(this_present_row && that_present_row))
11740           return false;
11741         if (!java.util.Arrays.equals(this.row, that.row))
11742           return false;
11743       }
11744 
11745       boolean this_present_column = true && this.isSetColumn();
11746       boolean that_present_column = true && that.isSetColumn();
11747       if (this_present_column || that_present_column) {
11748         if (!(this_present_column && that_present_column))
11749           return false;
11750         if (!java.util.Arrays.equals(this.column, that.column))
11751           return false;
11752       }
11753 
11754       boolean this_present_timestamp = true;
11755       boolean that_present_timestamp = true;
11756       if (this_present_timestamp || that_present_timestamp) {
11757         if (!(this_present_timestamp && that_present_timestamp))
11758           return false;
11759         if (this.timestamp != that.timestamp)
11760           return false;
11761       }
11762 
11763       boolean this_present_numVersions = true;
11764       boolean that_present_numVersions = true;
11765       if (this_present_numVersions || that_present_numVersions) {
11766         if (!(this_present_numVersions && that_present_numVersions))
11767           return false;
11768         if (this.numVersions != that.numVersions)
11769           return false;
11770       }
11771 
11772       return true;
11773     }
11774 
11775     @Override
11776     public int hashCode() {
11777       HashCodeBuilder builder = new HashCodeBuilder();
11778 
11779       boolean present_tableName = true && (isSetTableName());
11780       builder.append(present_tableName);
11781       if (present_tableName)
11782         builder.append(tableName);
11783 
11784       boolean present_row = true && (isSetRow());
11785       builder.append(present_row);
11786       if (present_row)
11787         builder.append(row);
11788 
11789       boolean present_column = true && (isSetColumn());
11790       builder.append(present_column);
11791       if (present_column)
11792         builder.append(column);
11793 
11794       boolean present_timestamp = true;
11795       builder.append(present_timestamp);
11796       if (present_timestamp)
11797         builder.append(timestamp);
11798 
11799       boolean present_numVersions = true;
11800       builder.append(present_numVersions);
11801       if (present_numVersions)
11802         builder.append(numVersions);
11803 
11804       return builder.toHashCode();
11805     }
11806 
11807     public int compareTo(getVerTs_args other) {
11808       if (!getClass().equals(other.getClass())) {
11809         return getClass().getName().compareTo(other.getClass().getName());
11810       }
11811 
11812       int lastComparison = 0;
11813       getVerTs_args typedOther = (getVerTs_args)other;
11814 
11815       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
11816       if (lastComparison != 0) {
11817         return lastComparison;
11818       }
11819       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
11820       if (lastComparison != 0) {
11821         return lastComparison;
11822       }
11823       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
11824       if (lastComparison != 0) {
11825         return lastComparison;
11826       }
11827       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
11828       if (lastComparison != 0) {
11829         return lastComparison;
11830       }
11831       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
11832       if (lastComparison != 0) {
11833         return lastComparison;
11834       }
11835       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
11836       if (lastComparison != 0) {
11837         return lastComparison;
11838       }
11839       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
11840       if (lastComparison != 0) {
11841         return lastComparison;
11842       }
11843       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
11844       if (lastComparison != 0) {
11845         return lastComparison;
11846       }
11847       lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(isSetNumVersions());
11848       if (lastComparison != 0) {
11849         return lastComparison;
11850       }
11851       lastComparison = TBaseHelper.compareTo(numVersions, typedOther.numVersions);
11852       if (lastComparison != 0) {
11853         return lastComparison;
11854       }
11855       return 0;
11856     }
11857 
11858     public void read(TProtocol iprot) throws TException {
11859       TField field;
11860       iprot.readStructBegin();
11861       while (true)
11862       {
11863         field = iprot.readFieldBegin();
11864         if (field.type == TType.STOP) {
11865           break;
11866         }
11867         _Fields fieldId = _Fields.findByThriftId(field.id);
11868         if (fieldId == null) {
11869           TProtocolUtil.skip(iprot, field.type);
11870         } else {
11871           switch (fieldId) {
11872             case TABLE_NAME:
11873               if (field.type == TType.STRING) {
11874                 this.tableName = iprot.readBinary();
11875               } else {
11876                 TProtocolUtil.skip(iprot, field.type);
11877               }
11878               break;
11879             case ROW:
11880               if (field.type == TType.STRING) {
11881                 this.row = iprot.readBinary();
11882               } else {
11883                 TProtocolUtil.skip(iprot, field.type);
11884               }
11885               break;
11886             case COLUMN:
11887               if (field.type == TType.STRING) {
11888                 this.column = iprot.readBinary();
11889               } else {
11890                 TProtocolUtil.skip(iprot, field.type);
11891               }
11892               break;
11893             case TIMESTAMP:
11894               if (field.type == TType.I64) {
11895                 this.timestamp = iprot.readI64();
11896                 setTimestampIsSet(true);
11897               } else {
11898                 TProtocolUtil.skip(iprot, field.type);
11899               }
11900               break;
11901             case NUM_VERSIONS:
11902               if (field.type == TType.I32) {
11903                 this.numVersions = iprot.readI32();
11904                 setNumVersionsIsSet(true);
11905               } else {
11906                 TProtocolUtil.skip(iprot, field.type);
11907               }
11908               break;
11909           }
11910           iprot.readFieldEnd();
11911         }
11912       }
11913       iprot.readStructEnd();
11914 
11915       // check for required fields of primitive type, which can't be checked in the validate method
11916       validate();
11917     }
11918 
11919     public void write(TProtocol oprot) throws TException {
11920       validate();
11921 
11922       oprot.writeStructBegin(STRUCT_DESC);
11923       if (this.tableName != null) {
11924         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
11925         oprot.writeBinary(this.tableName);
11926         oprot.writeFieldEnd();
11927       }
11928       if (this.row != null) {
11929         oprot.writeFieldBegin(ROW_FIELD_DESC);
11930         oprot.writeBinary(this.row);
11931         oprot.writeFieldEnd();
11932       }
11933       if (this.column != null) {
11934         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
11935         oprot.writeBinary(this.column);
11936         oprot.writeFieldEnd();
11937       }
11938       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
11939       oprot.writeI64(this.timestamp);
11940       oprot.writeFieldEnd();
11941       oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC);
11942       oprot.writeI32(this.numVersions);
11943       oprot.writeFieldEnd();
11944       oprot.writeFieldStop();
11945       oprot.writeStructEnd();
11946     }
11947 
11948     @Override
11949     public String toString() {
11950       StringBuilder sb = new StringBuilder("getVerTs_args(");
11951       boolean first = true;
11952 
11953       sb.append("tableName:");
11954       if (this.tableName == null) {
11955         sb.append("null");
11956       } else {
11957         sb.append(this.tableName);
11958       }
11959       first = false;
11960       if (!first) sb.append(", ");
11961       sb.append("row:");
11962       if (this.row == null) {
11963         sb.append("null");
11964       } else {
11965         sb.append(this.row);
11966       }
11967       first = false;
11968       if (!first) sb.append(", ");
11969       sb.append("column:");
11970       if (this.column == null) {
11971         sb.append("null");
11972       } else {
11973         sb.append(this.column);
11974       }
11975       first = false;
11976       if (!first) sb.append(", ");
11977       sb.append("timestamp:");
11978       sb.append(this.timestamp);
11979       first = false;
11980       if (!first) sb.append(", ");
11981       sb.append("numVersions:");
11982       sb.append(this.numVersions);
11983       first = false;
11984       sb.append(")");
11985       return sb.toString();
11986     }
11987 
11988     public void validate() throws TException {
11989       // check for required fields
11990     }
11991 
11992   }
11993 
11994   public static class getVerTs_result implements TBase<getVerTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVerTs_result>   {
11995     private static final TStruct STRUCT_DESC = new TStruct("getVerTs_result");
11996 
11997     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
11998     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
11999 
12000     public List<TCell> success;
12001     public IOError io;
12002 
12003     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
12004     public enum _Fields implements TFieldIdEnum {
12005       SUCCESS((short)0, "success"),
12006       IO((short)1, "io");
12007 
12008       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12009       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12010 
12011       static {
12012         for (_Fields field : EnumSet.allOf(_Fields.class)) {
12013           byId.put((int)field._thriftId, field);
12014           byName.put(field.getFieldName(), field);
12015         }
12016       }
12017 
12018       /**
12019        * Find the _Fields constant that matches fieldId, or null if its not found.
12020        */
12021       public static _Fields findByThriftId(int fieldId) {
12022         return byId.get(fieldId);
12023       }
12024 
12025       /**
12026        * Find the _Fields constant that matches fieldId, throwing an exception
12027        * if it is not found.
12028        */
12029       public static _Fields findByThriftIdOrThrow(int fieldId) {
12030         _Fields fields = findByThriftId(fieldId);
12031         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12032         return fields;
12033       }
12034 
12035       /**
12036        * Find the _Fields constant that matches name, or null if its not found.
12037        */
12038       public static _Fields findByName(String name) {
12039         return byName.get(name);
12040       }
12041 
12042       private final short _thriftId;
12043       private final String _fieldName;
12044 
12045       _Fields(short thriftId, String fieldName) {
12046         _thriftId = thriftId;
12047         _fieldName = fieldName;
12048       }
12049 
12050       public short getThriftFieldId() {
12051         return _thriftId;
12052       }
12053 
12054       public String getFieldName() {
12055         return _fieldName;
12056       }
12057     }
12058 
12059     // isset id assignments
12060 
12061     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12062       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
12063           new ListMetaData(TType.LIST,
12064               new StructMetaData(TType.STRUCT, TCell.class))));
12065       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
12066           new FieldValueMetaData(TType.STRUCT)));
12067     }});
12068 
12069     static {
12070       FieldMetaData.addStructMetaDataMap(getVerTs_result.class, metaDataMap);
12071     }
12072 
12073     public getVerTs_result() {
12074     }
12075 
12076     public getVerTs_result(
12077       List<TCell> success,
12078       IOError io)
12079     {
12080       this();
12081       this.success = success;
12082       this.io = io;
12083     }
12084 
12085     /**
12086      * Performs a deep copy on <i>other</i>.
12087      */
12088     public getVerTs_result(getVerTs_result other) {
12089       if (other.isSetSuccess()) {
12090         List<TCell> __this__success = new ArrayList<TCell>();
12091         for (TCell other_element : other.success) {
12092           __this__success.add(new TCell(other_element));
12093         }
12094         this.success = __this__success;
12095       }
12096       if (other.isSetIo()) {
12097         this.io = new IOError(other.io);
12098       }
12099     }
12100 
12101     public getVerTs_result deepCopy() {
12102       return new getVerTs_result(this);
12103     }
12104 
12105     @Deprecated
12106     public getVerTs_result clone() {
12107       return new getVerTs_result(this);
12108     }
12109 
12110     public int getSuccessSize() {
12111       return (this.success == null) ? 0 : this.success.size();
12112     }
12113 
12114     public java.util.Iterator<TCell> getSuccessIterator() {
12115       return (this.success == null) ? null : this.success.iterator();
12116     }
12117 
12118     public void addToSuccess(TCell elem) {
12119       if (this.success == null) {
12120         this.success = new ArrayList<TCell>();
12121       }
12122       this.success.add(elem);
12123     }
12124 
12125     public List<TCell> getSuccess() {
12126       return this.success;
12127     }
12128 
12129     public getVerTs_result setSuccess(List<TCell> success) {
12130       this.success = success;
12131       return this;
12132     }
12133 
12134     public void unsetSuccess() {
12135       this.success = null;
12136     }
12137 
12138     /** Returns true if field success is set (has been asigned a value) and false otherwise */
12139     public boolean isSetSuccess() {
12140       return this.success != null;
12141     }
12142 
12143     public void setSuccessIsSet(boolean value) {
12144       if (!value) {
12145         this.success = null;
12146       }
12147     }
12148 
12149     public IOError getIo() {
12150       return this.io;
12151     }
12152 
12153     public getVerTs_result setIo(IOError io) {
12154       this.io = io;
12155       return this;
12156     }
12157 
12158     public void unsetIo() {
12159       this.io = null;
12160     }
12161 
12162     /** Returns true if field io is set (has been asigned a value) and false otherwise */
12163     public boolean isSetIo() {
12164       return this.io != null;
12165     }
12166 
12167     public void setIoIsSet(boolean value) {
12168       if (!value) {
12169         this.io = null;
12170       }
12171     }
12172 
12173     public void setFieldValue(_Fields field, Object value) {
12174       switch (field) {
12175       case SUCCESS:
12176         if (value == null) {
12177           unsetSuccess();
12178         } else {
12179           setSuccess((List<TCell>)value);
12180         }
12181         break;
12182 
12183       case IO:
12184         if (value == null) {
12185           unsetIo();
12186         } else {
12187           setIo((IOError)value);
12188         }
12189         break;
12190 
12191       }
12192     }
12193 
12194     public void setFieldValue(int fieldID, Object value) {
12195       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
12196     }
12197 
12198     public Object getFieldValue(_Fields field) {
12199       switch (field) {
12200       case SUCCESS:
12201         return getSuccess();
12202 
12203       case IO:
12204         return getIo();
12205 
12206       }
12207       throw new IllegalStateException();
12208     }
12209 
12210     public Object getFieldValue(int fieldId) {
12211       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12212     }
12213 
12214     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
12215     public boolean isSet(_Fields field) {
12216       switch (field) {
12217       case SUCCESS:
12218         return isSetSuccess();
12219       case IO:
12220         return isSetIo();
12221       }
12222       throw new IllegalStateException();
12223     }
12224 
12225     public boolean isSet(int fieldID) {
12226       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12227     }
12228 
12229     @Override
12230     public boolean equals(Object that) {
12231       if (that == null)
12232         return false;
12233       if (that instanceof getVerTs_result)
12234         return this.equals((getVerTs_result)that);
12235       return false;
12236     }
12237 
12238     public boolean equals(getVerTs_result that) {
12239       if (that == null)
12240         return false;
12241 
12242       boolean this_present_success = true && this.isSetSuccess();
12243       boolean that_present_success = true && that.isSetSuccess();
12244       if (this_present_success || that_present_success) {
12245         if (!(this_present_success && that_present_success))
12246           return false;
12247         if (!this.success.equals(that.success))
12248           return false;
12249       }
12250 
12251       boolean this_present_io = true && this.isSetIo();
12252       boolean that_present_io = true && that.isSetIo();
12253       if (this_present_io || that_present_io) {
12254         if (!(this_present_io && that_present_io))
12255           return false;
12256         if (!this.io.equals(that.io))
12257           return false;
12258       }
12259 
12260       return true;
12261     }
12262 
12263     @Override
12264     public int hashCode() {
12265       HashCodeBuilder builder = new HashCodeBuilder();
12266 
12267       boolean present_success = true && (isSetSuccess());
12268       builder.append(present_success);
12269       if (present_success)
12270         builder.append(success);
12271 
12272       boolean present_io = true && (isSetIo());
12273       builder.append(present_io);
12274       if (present_io)
12275         builder.append(io);
12276 
12277       return builder.toHashCode();
12278     }
12279 
12280     public int compareTo(getVerTs_result other) {
12281       if (!getClass().equals(other.getClass())) {
12282         return getClass().getName().compareTo(other.getClass().getName());
12283       }
12284 
12285       int lastComparison = 0;
12286       getVerTs_result typedOther = (getVerTs_result)other;
12287 
12288       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
12289       if (lastComparison != 0) {
12290         return lastComparison;
12291       }
12292       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
12293       if (lastComparison != 0) {
12294         return lastComparison;
12295       }
12296       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
12297       if (lastComparison != 0) {
12298         return lastComparison;
12299       }
12300       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
12301       if (lastComparison != 0) {
12302         return lastComparison;
12303       }
12304       return 0;
12305     }
12306 
12307     public void read(TProtocol iprot) throws TException {
12308       TField field;
12309       iprot.readStructBegin();
12310       while (true)
12311       {
12312         field = iprot.readFieldBegin();
12313         if (field.type == TType.STOP) {
12314           break;
12315         }
12316         _Fields fieldId = _Fields.findByThriftId(field.id);
12317         if (fieldId == null) {
12318           TProtocolUtil.skip(iprot, field.type);
12319         } else {
12320           switch (fieldId) {
12321             case SUCCESS:
12322               if (field.type == TType.LIST) {
12323                 {
12324                   TList _list34 = iprot.readListBegin();
12325                   this.success = new ArrayList<TCell>(_list34.size);
12326                   for (int _i35 = 0; _i35 < _list34.size; ++_i35)
12327                   {
12328                     TCell _elem36;
12329                     _elem36 = new TCell();
12330                     _elem36.read(iprot);
12331                     this.success.add(_elem36);
12332                   }
12333                   iprot.readListEnd();
12334                 }
12335               } else {
12336                 TProtocolUtil.skip(iprot, field.type);
12337               }
12338               break;
12339             case IO:
12340               if (field.type == TType.STRUCT) {
12341                 this.io = new IOError();
12342                 this.io.read(iprot);
12343               } else {
12344                 TProtocolUtil.skip(iprot, field.type);
12345               }
12346               break;
12347           }
12348           iprot.readFieldEnd();
12349         }
12350       }
12351       iprot.readStructEnd();
12352 
12353       // check for required fields of primitive type, which can't be checked in the validate method
12354       validate();
12355     }
12356 
12357     public void write(TProtocol oprot) throws TException {
12358       oprot.writeStructBegin(STRUCT_DESC);
12359 
12360       if (this.isSetSuccess()) {
12361         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12362         {
12363           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
12364           for (TCell _iter37 : this.success)
12365           {
12366             _iter37.write(oprot);
12367           }
12368           oprot.writeListEnd();
12369         }
12370         oprot.writeFieldEnd();
12371       } else if (this.isSetIo()) {
12372         oprot.writeFieldBegin(IO_FIELD_DESC);
12373         this.io.write(oprot);
12374         oprot.writeFieldEnd();
12375       }
12376       oprot.writeFieldStop();
12377       oprot.writeStructEnd();
12378     }
12379 
12380     @Override
12381     public String toString() {
12382       StringBuilder sb = new StringBuilder("getVerTs_result(");
12383       boolean first = true;
12384 
12385       sb.append("success:");
12386       if (this.success == null) {
12387         sb.append("null");
12388       } else {
12389         sb.append(this.success);
12390       }
12391       first = false;
12392       if (!first) sb.append(", ");
12393       sb.append("io:");
12394       if (this.io == null) {
12395         sb.append("null");
12396       } else {
12397         sb.append(this.io);
12398       }
12399       first = false;
12400       sb.append(")");
12401       return sb.toString();
12402     }
12403 
12404     public void validate() throws TException {
12405       // check for required fields
12406     }
12407 
12408   }
12409 
12410   public static class getRow_args implements TBase<getRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRow_args>   {
12411     private static final TStruct STRUCT_DESC = new TStruct("getRow_args");
12412 
12413     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
12414     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
12415 
12416     /**
12417      * name of table
12418      */
12419     public byte[] tableName;
12420     /**
12421      * row key
12422      */
12423     public byte[] row;
12424 
12425     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
12426     public enum _Fields implements TFieldIdEnum {
12427       /**
12428        * name of table
12429        */
12430       TABLE_NAME((short)1, "tableName"),
12431       /**
12432        * row key
12433        */
12434       ROW((short)2, "row");
12435 
12436       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12437       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12438 
12439       static {
12440         for (_Fields field : EnumSet.allOf(_Fields.class)) {
12441           byId.put((int)field._thriftId, field);
12442           byName.put(field.getFieldName(), field);
12443         }
12444       }
12445 
12446       /**
12447        * Find the _Fields constant that matches fieldId, or null if its not found.
12448        */
12449       public static _Fields findByThriftId(int fieldId) {
12450         return byId.get(fieldId);
12451       }
12452 
12453       /**
12454        * Find the _Fields constant that matches fieldId, throwing an exception
12455        * if it is not found.
12456        */
12457       public static _Fields findByThriftIdOrThrow(int fieldId) {
12458         _Fields fields = findByThriftId(fieldId);
12459         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12460         return fields;
12461       }
12462 
12463       /**
12464        * Find the _Fields constant that matches name, or null if its not found.
12465        */
12466       public static _Fields findByName(String name) {
12467         return byName.get(name);
12468       }
12469 
12470       private final short _thriftId;
12471       private final String _fieldName;
12472 
12473       _Fields(short thriftId, String fieldName) {
12474         _thriftId = thriftId;
12475         _fieldName = fieldName;
12476       }
12477 
12478       public short getThriftFieldId() {
12479         return _thriftId;
12480       }
12481 
12482       public String getFieldName() {
12483         return _fieldName;
12484       }
12485     }
12486 
12487     // isset id assignments
12488 
12489     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12490       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
12491           new FieldValueMetaData(TType.STRING)));
12492       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
12493           new FieldValueMetaData(TType.STRING)));
12494     }});
12495 
12496     static {
12497       FieldMetaData.addStructMetaDataMap(getRow_args.class, metaDataMap);
12498     }
12499 
12500     public getRow_args() {
12501     }
12502 
12503     public getRow_args(
12504       byte[] tableName,
12505       byte[] row)
12506     {
12507       this();
12508       this.tableName = tableName;
12509       this.row = row;
12510     }
12511 
12512     /**
12513      * Performs a deep copy on <i>other</i>.
12514      */
12515     public getRow_args(getRow_args other) {
12516       if (other.isSetTableName()) {
12517         this.tableName = other.tableName;
12518       }
12519       if (other.isSetRow()) {
12520         this.row = other.row;
12521       }
12522     }
12523 
12524     public getRow_args deepCopy() {
12525       return new getRow_args(this);
12526     }
12527 
12528     @Deprecated
12529     public getRow_args clone() {
12530       return new getRow_args(this);
12531     }
12532 
12533     /**
12534      * name of table
12535      */
12536     public byte[] getTableName() {
12537       return this.tableName;
12538     }
12539 
12540     /**
12541      * name of table
12542      */
12543     public getRow_args setTableName(byte[] tableName) {
12544       this.tableName = tableName;
12545       return this;
12546     }
12547 
12548     public void unsetTableName() {
12549       this.tableName = null;
12550     }
12551 
12552     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
12553     public boolean isSetTableName() {
12554       return this.tableName != null;
12555     }
12556 
12557     public void setTableNameIsSet(boolean value) {
12558       if (!value) {
12559         this.tableName = null;
12560       }
12561     }
12562 
12563     /**
12564      * row key
12565      */
12566     public byte[] getRow() {
12567       return this.row;
12568     }
12569 
12570     /**
12571      * row key
12572      */
12573     public getRow_args setRow(byte[] row) {
12574       this.row = row;
12575       return this;
12576     }
12577 
12578     public void unsetRow() {
12579       this.row = null;
12580     }
12581 
12582     /** Returns true if field row is set (has been asigned a value) and false otherwise */
12583     public boolean isSetRow() {
12584       return this.row != null;
12585     }
12586 
12587     public void setRowIsSet(boolean value) {
12588       if (!value) {
12589         this.row = null;
12590       }
12591     }
12592 
12593     public void setFieldValue(_Fields field, Object value) {
12594       switch (field) {
12595       case TABLE_NAME:
12596         if (value == null) {
12597           unsetTableName();
12598         } else {
12599           setTableName((byte[])value);
12600         }
12601         break;
12602 
12603       case ROW:
12604         if (value == null) {
12605           unsetRow();
12606         } else {
12607           setRow((byte[])value);
12608         }
12609         break;
12610 
12611       }
12612     }
12613 
12614     public void setFieldValue(int fieldID, Object value) {
12615       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
12616     }
12617 
12618     public Object getFieldValue(_Fields field) {
12619       switch (field) {
12620       case TABLE_NAME:
12621         return getTableName();
12622 
12623       case ROW:
12624         return getRow();
12625 
12626       }
12627       throw new IllegalStateException();
12628     }
12629 
12630     public Object getFieldValue(int fieldId) {
12631       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
12632     }
12633 
12634     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
12635     public boolean isSet(_Fields field) {
12636       switch (field) {
12637       case TABLE_NAME:
12638         return isSetTableName();
12639       case ROW:
12640         return isSetRow();
12641       }
12642       throw new IllegalStateException();
12643     }
12644 
12645     public boolean isSet(int fieldID) {
12646       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
12647     }
12648 
12649     @Override
12650     public boolean equals(Object that) {
12651       if (that == null)
12652         return false;
12653       if (that instanceof getRow_args)
12654         return this.equals((getRow_args)that);
12655       return false;
12656     }
12657 
12658     public boolean equals(getRow_args that) {
12659       if (that == null)
12660         return false;
12661 
12662       boolean this_present_tableName = true && this.isSetTableName();
12663       boolean that_present_tableName = true && that.isSetTableName();
12664       if (this_present_tableName || that_present_tableName) {
12665         if (!(this_present_tableName && that_present_tableName))
12666           return false;
12667         if (!java.util.Arrays.equals(this.tableName, that.tableName))
12668           return false;
12669       }
12670 
12671       boolean this_present_row = true && this.isSetRow();
12672       boolean that_present_row = true && that.isSetRow();
12673       if (this_present_row || that_present_row) {
12674         if (!(this_present_row && that_present_row))
12675           return false;
12676         if (!java.util.Arrays.equals(this.row, that.row))
12677           return false;
12678       }
12679 
12680       return true;
12681     }
12682 
12683     @Override
12684     public int hashCode() {
12685       HashCodeBuilder builder = new HashCodeBuilder();
12686 
12687       boolean present_tableName = true && (isSetTableName());
12688       builder.append(present_tableName);
12689       if (present_tableName)
12690         builder.append(tableName);
12691 
12692       boolean present_row = true && (isSetRow());
12693       builder.append(present_row);
12694       if (present_row)
12695         builder.append(row);
12696 
12697       return builder.toHashCode();
12698     }
12699 
12700     public int compareTo(getRow_args other) {
12701       if (!getClass().equals(other.getClass())) {
12702         return getClass().getName().compareTo(other.getClass().getName());
12703       }
12704 
12705       int lastComparison = 0;
12706       getRow_args typedOther = (getRow_args)other;
12707 
12708       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
12709       if (lastComparison != 0) {
12710         return lastComparison;
12711       }
12712       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
12713       if (lastComparison != 0) {
12714         return lastComparison;
12715       }
12716       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
12717       if (lastComparison != 0) {
12718         return lastComparison;
12719       }
12720       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
12721       if (lastComparison != 0) {
12722         return lastComparison;
12723       }
12724       return 0;
12725     }
12726 
12727     public void read(TProtocol iprot) throws TException {
12728       TField field;
12729       iprot.readStructBegin();
12730       while (true)
12731       {
12732         field = iprot.readFieldBegin();
12733         if (field.type == TType.STOP) {
12734           break;
12735         }
12736         _Fields fieldId = _Fields.findByThriftId(field.id);
12737         if (fieldId == null) {
12738           TProtocolUtil.skip(iprot, field.type);
12739         } else {
12740           switch (fieldId) {
12741             case TABLE_NAME:
12742               if (field.type == TType.STRING) {
12743                 this.tableName = iprot.readBinary();
12744               } else {
12745                 TProtocolUtil.skip(iprot, field.type);
12746               }
12747               break;
12748             case ROW:
12749               if (field.type == TType.STRING) {
12750                 this.row = iprot.readBinary();
12751               } else {
12752                 TProtocolUtil.skip(iprot, field.type);
12753               }
12754               break;
12755           }
12756           iprot.readFieldEnd();
12757         }
12758       }
12759       iprot.readStructEnd();
12760 
12761       // check for required fields of primitive type, which can't be checked in the validate method
12762       validate();
12763     }
12764 
12765     public void write(TProtocol oprot) throws TException {
12766       validate();
12767 
12768       oprot.writeStructBegin(STRUCT_DESC);
12769       if (this.tableName != null) {
12770         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
12771         oprot.writeBinary(this.tableName);
12772         oprot.writeFieldEnd();
12773       }
12774       if (this.row != null) {
12775         oprot.writeFieldBegin(ROW_FIELD_DESC);
12776         oprot.writeBinary(this.row);
12777         oprot.writeFieldEnd();
12778       }
12779       oprot.writeFieldStop();
12780       oprot.writeStructEnd();
12781     }
12782 
12783     @Override
12784     public String toString() {
12785       StringBuilder sb = new StringBuilder("getRow_args(");
12786       boolean first = true;
12787 
12788       sb.append("tableName:");
12789       if (this.tableName == null) {
12790         sb.append("null");
12791       } else {
12792         sb.append(this.tableName);
12793       }
12794       first = false;
12795       if (!first) sb.append(", ");
12796       sb.append("row:");
12797       if (this.row == null) {
12798         sb.append("null");
12799       } else {
12800         sb.append(this.row);
12801       }
12802       first = false;
12803       sb.append(")");
12804       return sb.toString();
12805     }
12806 
12807     public void validate() throws TException {
12808       // check for required fields
12809     }
12810 
12811   }
12812 
12813   public static class getRow_result implements TBase<getRow_result._Fields>, java.io.Serializable, Cloneable   {
12814     private static final TStruct STRUCT_DESC = new TStruct("getRow_result");
12815 
12816     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
12817     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
12818 
12819     public List<TRowResult> success;
12820     public IOError io;
12821 
12822     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
12823     public enum _Fields implements TFieldIdEnum {
12824       SUCCESS((short)0, "success"),
12825       IO((short)1, "io");
12826 
12827       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
12828       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
12829 
12830       static {
12831         for (_Fields field : EnumSet.allOf(_Fields.class)) {
12832           byId.put((int)field._thriftId, field);
12833           byName.put(field.getFieldName(), field);
12834         }
12835       }
12836 
12837       /**
12838        * Find the _Fields constant that matches fieldId, or null if its not found.
12839        */
12840       public static _Fields findByThriftId(int fieldId) {
12841         return byId.get(fieldId);
12842       }
12843 
12844       /**
12845        * Find the _Fields constant that matches fieldId, throwing an exception
12846        * if it is not found.
12847        */
12848       public static _Fields findByThriftIdOrThrow(int fieldId) {
12849         _Fields fields = findByThriftId(fieldId);
12850         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
12851         return fields;
12852       }
12853 
12854       /**
12855        * Find the _Fields constant that matches name, or null if its not found.
12856        */
12857       public static _Fields findByName(String name) {
12858         return byName.get(name);
12859       }
12860 
12861       private final short _thriftId;
12862       private final String _fieldName;
12863 
12864       _Fields(short thriftId, String fieldName) {
12865         _thriftId = thriftId;
12866         _fieldName = fieldName;
12867       }
12868 
12869       public short getThriftFieldId() {
12870         return _thriftId;
12871       }
12872 
12873       public String getFieldName() {
12874         return _fieldName;
12875       }
12876     }
12877 
12878     // isset id assignments
12879 
12880     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
12881       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
12882           new ListMetaData(TType.LIST,
12883               new StructMetaData(TType.STRUCT, TRowResult.class))));
12884       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
12885           new FieldValueMetaData(TType.STRUCT)));
12886     }});
12887 
12888     static {
12889       FieldMetaData.addStructMetaDataMap(getRow_result.class, metaDataMap);
12890     }
12891 
12892     public getRow_result() {
12893     }
12894 
12895     public getRow_result(
12896       List<TRowResult> success,
12897       IOError io)
12898     {
12899       this();
12900       this.success = success;
12901       this.io = io;
12902     }
12903 
12904     /**
12905      * Performs a deep copy on <i>other</i>.
12906      */
12907     public getRow_result(getRow_result other) {
12908       if (other.isSetSuccess()) {
12909         List<TRowResult> __this__success = new ArrayList<TRowResult>();
12910         for (TRowResult other_element : other.success) {
12911           __this__success.add(new TRowResult(other_element));
12912         }
12913         this.success = __this__success;
12914       }
12915       if (other.isSetIo()) {
12916         this.io = new IOError(other.io);
12917       }
12918     }
12919 
12920     public getRow_result deepCopy() {
12921       return new getRow_result(this);
12922     }
12923 
12924     @Deprecated
12925     public getRow_result clone() {
12926       return new getRow_result(this);
12927     }
12928 
12929     public int getSuccessSize() {
12930       return (this.success == null) ? 0 : this.success.size();
12931     }
12932 
12933     public java.util.Iterator<TRowResult> getSuccessIterator() {
12934       return (this.success == null) ? null : this.success.iterator();
12935     }
12936 
12937     public void addToSuccess(TRowResult elem) {
12938       if (this.success == null) {
12939         this.success = new ArrayList<TRowResult>();
12940       }
12941       this.success.add(elem);
12942     }
12943 
12944     public List<TRowResult> getSuccess() {
12945       return this.success;
12946     }
12947 
12948     public getRow_result setSuccess(List<TRowResult> success) {
12949       this.success = success;
12950       return this;
12951     }
12952 
12953     public void unsetSuccess() {
12954       this.success = null;
12955     }
12956 
12957     /** Returns true if field success is set (has been asigned a value) and false otherwise */
12958     public boolean isSetSuccess() {
12959       return this.success != null;
12960     }
12961 
12962     public void setSuccessIsSet(boolean value) {
12963       if (!value) {
12964         this.success = null;
12965       }
12966     }
12967 
12968     public IOError getIo() {
12969       return this.io;
12970     }
12971 
12972     public getRow_result setIo(IOError io) {
12973       this.io = io;
12974       return this;
12975     }
12976 
12977     public void unsetIo() {
12978       this.io = null;
12979     }
12980 
12981     /** Returns true if field io is set (has been asigned a value) and false otherwise */
12982     public boolean isSetIo() {
12983       return this.io != null;
12984     }
12985 
12986     public void setIoIsSet(boolean value) {
12987       if (!value) {
12988         this.io = null;
12989       }
12990     }
12991 
12992     public void setFieldValue(_Fields field, Object value) {
12993       switch (field) {
12994       case SUCCESS:
12995         if (value == null) {
12996           unsetSuccess();
12997         } else {
12998           setSuccess((List<TRowResult>)value);
12999         }
13000         break;
13001 
13002       case IO:
13003         if (value == null) {
13004           unsetIo();
13005         } else {
13006           setIo((IOError)value);
13007         }
13008         break;
13009 
13010       }
13011     }
13012 
13013     public void setFieldValue(int fieldID, Object value) {
13014       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13015     }
13016 
13017     public Object getFieldValue(_Fields field) {
13018       switch (field) {
13019       case SUCCESS:
13020         return getSuccess();
13021 
13022       case IO:
13023         return getIo();
13024 
13025       }
13026       throw new IllegalStateException();
13027     }
13028 
13029     public Object getFieldValue(int fieldId) {
13030       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13031     }
13032 
13033     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
13034     public boolean isSet(_Fields field) {
13035       switch (field) {
13036       case SUCCESS:
13037         return isSetSuccess();
13038       case IO:
13039         return isSetIo();
13040       }
13041       throw new IllegalStateException();
13042     }
13043 
13044     public boolean isSet(int fieldID) {
13045       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13046     }
13047 
13048     @Override
13049     public boolean equals(Object that) {
13050       if (that == null)
13051         return false;
13052       if (that instanceof getRow_result)
13053         return this.equals((getRow_result)that);
13054       return false;
13055     }
13056 
13057     public boolean equals(getRow_result that) {
13058       if (that == null)
13059         return false;
13060 
13061       boolean this_present_success = true && this.isSetSuccess();
13062       boolean that_present_success = true && that.isSetSuccess();
13063       if (this_present_success || that_present_success) {
13064         if (!(this_present_success && that_present_success))
13065           return false;
13066         if (!this.success.equals(that.success))
13067           return false;
13068       }
13069 
13070       boolean this_present_io = true && this.isSetIo();
13071       boolean that_present_io = true && that.isSetIo();
13072       if (this_present_io || that_present_io) {
13073         if (!(this_present_io && that_present_io))
13074           return false;
13075         if (!this.io.equals(that.io))
13076           return false;
13077       }
13078 
13079       return true;
13080     }
13081 
13082     @Override
13083     public int hashCode() {
13084       HashCodeBuilder builder = new HashCodeBuilder();
13085 
13086       boolean present_success = true && (isSetSuccess());
13087       builder.append(present_success);
13088       if (present_success)
13089         builder.append(success);
13090 
13091       boolean present_io = true && (isSetIo());
13092       builder.append(present_io);
13093       if (present_io)
13094         builder.append(io);
13095 
13096       return builder.toHashCode();
13097     }
13098 
13099     public void read(TProtocol iprot) throws TException {
13100       TField field;
13101       iprot.readStructBegin();
13102       while (true)
13103       {
13104         field = iprot.readFieldBegin();
13105         if (field.type == TType.STOP) {
13106           break;
13107         }
13108         _Fields fieldId = _Fields.findByThriftId(field.id);
13109         if (fieldId == null) {
13110           TProtocolUtil.skip(iprot, field.type);
13111         } else {
13112           switch (fieldId) {
13113             case SUCCESS:
13114               if (field.type == TType.LIST) {
13115                 {
13116                   TList _list38 = iprot.readListBegin();
13117                   this.success = new ArrayList<TRowResult>(_list38.size);
13118                   for (int _i39 = 0; _i39 < _list38.size; ++_i39)
13119                   {
13120                     TRowResult _elem40;
13121                     _elem40 = new TRowResult();
13122                     _elem40.read(iprot);
13123                     this.success.add(_elem40);
13124                   }
13125                   iprot.readListEnd();
13126                 }
13127               } else {
13128                 TProtocolUtil.skip(iprot, field.type);
13129               }
13130               break;
13131             case IO:
13132               if (field.type == TType.STRUCT) {
13133                 this.io = new IOError();
13134                 this.io.read(iprot);
13135               } else {
13136                 TProtocolUtil.skip(iprot, field.type);
13137               }
13138               break;
13139           }
13140           iprot.readFieldEnd();
13141         }
13142       }
13143       iprot.readStructEnd();
13144 
13145       // check for required fields of primitive type, which can't be checked in the validate method
13146       validate();
13147     }
13148 
13149     public void write(TProtocol oprot) throws TException {
13150       oprot.writeStructBegin(STRUCT_DESC);
13151 
13152       if (this.isSetSuccess()) {
13153         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13154         {
13155           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
13156           for (TRowResult _iter41 : this.success)
13157           {
13158             _iter41.write(oprot);
13159           }
13160           oprot.writeListEnd();
13161         }
13162         oprot.writeFieldEnd();
13163       } else if (this.isSetIo()) {
13164         oprot.writeFieldBegin(IO_FIELD_DESC);
13165         this.io.write(oprot);
13166         oprot.writeFieldEnd();
13167       }
13168       oprot.writeFieldStop();
13169       oprot.writeStructEnd();
13170     }
13171 
13172     @Override
13173     public String toString() {
13174       StringBuilder sb = new StringBuilder("getRow_result(");
13175       boolean first = true;
13176 
13177       sb.append("success:");
13178       if (this.success == null) {
13179         sb.append("null");
13180       } else {
13181         sb.append(this.success);
13182       }
13183       first = false;
13184       if (!first) sb.append(", ");
13185       sb.append("io:");
13186       if (this.io == null) {
13187         sb.append("null");
13188       } else {
13189         sb.append(this.io);
13190       }
13191       first = false;
13192       sb.append(")");
13193       return sb.toString();
13194     }
13195 
13196     public void validate() throws TException {
13197       // check for required fields
13198     }
13199 
13200   }
13201 
13202   public static class getRowWithColumns_args implements TBase<getRowWithColumns_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumns_args>   {
13203     private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_args");
13204 
13205     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
13206     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
13207     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
13208 
13209     /**
13210      * name of table
13211      */
13212     public byte[] tableName;
13213     /**
13214      * row key
13215      */
13216     public byte[] row;
13217     /**
13218      * List of columns to return, null for all columns
13219      */
13220     public List<byte[]> columns;
13221 
13222     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
13223     public enum _Fields implements TFieldIdEnum {
13224       /**
13225        * name of table
13226        */
13227       TABLE_NAME((short)1, "tableName"),
13228       /**
13229        * row key
13230        */
13231       ROW((short)2, "row"),
13232       /**
13233        * List of columns to return, null for all columns
13234        */
13235       COLUMNS((short)3, "columns");
13236 
13237       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
13238       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13239 
13240       static {
13241         for (_Fields field : EnumSet.allOf(_Fields.class)) {
13242           byId.put((int)field._thriftId, field);
13243           byName.put(field.getFieldName(), field);
13244         }
13245       }
13246 
13247       /**
13248        * Find the _Fields constant that matches fieldId, or null if its not found.
13249        */
13250       public static _Fields findByThriftId(int fieldId) {
13251         return byId.get(fieldId);
13252       }
13253 
13254       /**
13255        * Find the _Fields constant that matches fieldId, throwing an exception
13256        * if it is not found.
13257        */
13258       public static _Fields findByThriftIdOrThrow(int fieldId) {
13259         _Fields fields = findByThriftId(fieldId);
13260         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13261         return fields;
13262       }
13263 
13264       /**
13265        * Find the _Fields constant that matches name, or null if its not found.
13266        */
13267       public static _Fields findByName(String name) {
13268         return byName.get(name);
13269       }
13270 
13271       private final short _thriftId;
13272       private final String _fieldName;
13273 
13274       _Fields(short thriftId, String fieldName) {
13275         _thriftId = thriftId;
13276         _fieldName = fieldName;
13277       }
13278 
13279       public short getThriftFieldId() {
13280         return _thriftId;
13281       }
13282 
13283       public String getFieldName() {
13284         return _fieldName;
13285       }
13286     }
13287 
13288     // isset id assignments
13289 
13290     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
13291       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
13292           new FieldValueMetaData(TType.STRING)));
13293       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
13294           new FieldValueMetaData(TType.STRING)));
13295       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
13296           new ListMetaData(TType.LIST,
13297               new FieldValueMetaData(TType.STRING))));
13298     }});
13299 
13300     static {
13301       FieldMetaData.addStructMetaDataMap(getRowWithColumns_args.class, metaDataMap);
13302     }
13303 
13304     public getRowWithColumns_args() {
13305     }
13306 
13307     public getRowWithColumns_args(
13308       byte[] tableName,
13309       byte[] row,
13310       List<byte[]> columns)
13311     {
13312       this();
13313       this.tableName = tableName;
13314       this.row = row;
13315       this.columns = columns;
13316     }
13317 
13318     /**
13319      * Performs a deep copy on <i>other</i>.
13320      */
13321     public getRowWithColumns_args(getRowWithColumns_args other) {
13322       if (other.isSetTableName()) {
13323         this.tableName = other.tableName;
13324       }
13325       if (other.isSetRow()) {
13326         this.row = other.row;
13327       }
13328       if (other.isSetColumns()) {
13329         List<byte[]> __this__columns = new ArrayList<byte[]>();
13330         for (byte[] other_element : other.columns) {
13331           __this__columns.add(other_element);
13332         }
13333         this.columns = __this__columns;
13334       }
13335     }
13336 
13337     public getRowWithColumns_args deepCopy() {
13338       return new getRowWithColumns_args(this);
13339     }
13340 
13341     @Deprecated
13342     public getRowWithColumns_args clone() {
13343       return new getRowWithColumns_args(this);
13344     }
13345 
13346     /**
13347      * name of table
13348      */
13349     public byte[] getTableName() {
13350       return this.tableName;
13351     }
13352 
13353     /**
13354      * name of table
13355      */
13356     public getRowWithColumns_args setTableName(byte[] tableName) {
13357       this.tableName = tableName;
13358       return this;
13359     }
13360 
13361     public void unsetTableName() {
13362       this.tableName = null;
13363     }
13364 
13365     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
13366     public boolean isSetTableName() {
13367       return this.tableName != null;
13368     }
13369 
13370     public void setTableNameIsSet(boolean value) {
13371       if (!value) {
13372         this.tableName = null;
13373       }
13374     }
13375 
13376     /**
13377      * row key
13378      */
13379     public byte[] getRow() {
13380       return this.row;
13381     }
13382 
13383     /**
13384      * row key
13385      */
13386     public getRowWithColumns_args setRow(byte[] row) {
13387       this.row = row;
13388       return this;
13389     }
13390 
13391     public void unsetRow() {
13392       this.row = null;
13393     }
13394 
13395     /** Returns true if field row is set (has been asigned a value) and false otherwise */
13396     public boolean isSetRow() {
13397       return this.row != null;
13398     }
13399 
13400     public void setRowIsSet(boolean value) {
13401       if (!value) {
13402         this.row = null;
13403       }
13404     }
13405 
13406     public int getColumnsSize() {
13407       return (this.columns == null) ? 0 : this.columns.size();
13408     }
13409 
13410     public java.util.Iterator<byte[]> getColumnsIterator() {
13411       return (this.columns == null) ? null : this.columns.iterator();
13412     }
13413 
13414     public void addToColumns(byte[] elem) {
13415       if (this.columns == null) {
13416         this.columns = new ArrayList<byte[]>();
13417       }
13418       this.columns.add(elem);
13419     }
13420 
13421     /**
13422      * List of columns to return, null for all columns
13423      */
13424     public List<byte[]> getColumns() {
13425       return this.columns;
13426     }
13427 
13428     /**
13429      * List of columns to return, null for all columns
13430      */
13431     public getRowWithColumns_args setColumns(List<byte[]> columns) {
13432       this.columns = columns;
13433       return this;
13434     }
13435 
13436     public void unsetColumns() {
13437       this.columns = null;
13438     }
13439 
13440     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
13441     public boolean isSetColumns() {
13442       return this.columns != null;
13443     }
13444 
13445     public void setColumnsIsSet(boolean value) {
13446       if (!value) {
13447         this.columns = null;
13448       }
13449     }
13450 
13451     public void setFieldValue(_Fields field, Object value) {
13452       switch (field) {
13453       case TABLE_NAME:
13454         if (value == null) {
13455           unsetTableName();
13456         } else {
13457           setTableName((byte[])value);
13458         }
13459         break;
13460 
13461       case ROW:
13462         if (value == null) {
13463           unsetRow();
13464         } else {
13465           setRow((byte[])value);
13466         }
13467         break;
13468 
13469       case COLUMNS:
13470         if (value == null) {
13471           unsetColumns();
13472         } else {
13473           setColumns((List<byte[]>)value);
13474         }
13475         break;
13476 
13477       }
13478     }
13479 
13480     public void setFieldValue(int fieldID, Object value) {
13481       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13482     }
13483 
13484     public Object getFieldValue(_Fields field) {
13485       switch (field) {
13486       case TABLE_NAME:
13487         return getTableName();
13488 
13489       case ROW:
13490         return getRow();
13491 
13492       case COLUMNS:
13493         return getColumns();
13494 
13495       }
13496       throw new IllegalStateException();
13497     }
13498 
13499     public Object getFieldValue(int fieldId) {
13500       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13501     }
13502 
13503     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
13504     public boolean isSet(_Fields field) {
13505       switch (field) {
13506       case TABLE_NAME:
13507         return isSetTableName();
13508       case ROW:
13509         return isSetRow();
13510       case COLUMNS:
13511         return isSetColumns();
13512       }
13513       throw new IllegalStateException();
13514     }
13515 
13516     public boolean isSet(int fieldID) {
13517       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13518     }
13519 
13520     @Override
13521     public boolean equals(Object that) {
13522       if (that == null)
13523         return false;
13524       if (that instanceof getRowWithColumns_args)
13525         return this.equals((getRowWithColumns_args)that);
13526       return false;
13527     }
13528 
13529     public boolean equals(getRowWithColumns_args that) {
13530       if (that == null)
13531         return false;
13532 
13533       boolean this_present_tableName = true && this.isSetTableName();
13534       boolean that_present_tableName = true && that.isSetTableName();
13535       if (this_present_tableName || that_present_tableName) {
13536         if (!(this_present_tableName && that_present_tableName))
13537           return false;
13538         if (!java.util.Arrays.equals(this.tableName, that.tableName))
13539           return false;
13540       }
13541 
13542       boolean this_present_row = true && this.isSetRow();
13543       boolean that_present_row = true && that.isSetRow();
13544       if (this_present_row || that_present_row) {
13545         if (!(this_present_row && that_present_row))
13546           return false;
13547         if (!java.util.Arrays.equals(this.row, that.row))
13548           return false;
13549       }
13550 
13551       boolean this_present_columns = true && this.isSetColumns();
13552       boolean that_present_columns = true && that.isSetColumns();
13553       if (this_present_columns || that_present_columns) {
13554         if (!(this_present_columns && that_present_columns))
13555           return false;
13556         if (!this.columns.equals(that.columns))
13557           return false;
13558       }
13559 
13560       return true;
13561     }
13562 
13563     @Override
13564     public int hashCode() {
13565       HashCodeBuilder builder = new HashCodeBuilder();
13566 
13567       boolean present_tableName = true && (isSetTableName());
13568       builder.append(present_tableName);
13569       if (present_tableName)
13570         builder.append(tableName);
13571 
13572       boolean present_row = true && (isSetRow());
13573       builder.append(present_row);
13574       if (present_row)
13575         builder.append(row);
13576 
13577       boolean present_columns = true && (isSetColumns());
13578       builder.append(present_columns);
13579       if (present_columns)
13580         builder.append(columns);
13581 
13582       return builder.toHashCode();
13583     }
13584 
13585     public int compareTo(getRowWithColumns_args other) {
13586       if (!getClass().equals(other.getClass())) {
13587         return getClass().getName().compareTo(other.getClass().getName());
13588       }
13589 
13590       int lastComparison = 0;
13591       getRowWithColumns_args typedOther = (getRowWithColumns_args)other;
13592 
13593       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
13594       if (lastComparison != 0) {
13595         return lastComparison;
13596       }
13597       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
13598       if (lastComparison != 0) {
13599         return lastComparison;
13600       }
13601       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
13602       if (lastComparison != 0) {
13603         return lastComparison;
13604       }
13605       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
13606       if (lastComparison != 0) {
13607         return lastComparison;
13608       }
13609       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
13610       if (lastComparison != 0) {
13611         return lastComparison;
13612       }
13613       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
13614       if (lastComparison != 0) {
13615         return lastComparison;
13616       }
13617       return 0;
13618     }
13619 
13620     public void read(TProtocol iprot) throws TException {
13621       TField field;
13622       iprot.readStructBegin();
13623       while (true)
13624       {
13625         field = iprot.readFieldBegin();
13626         if (field.type == TType.STOP) {
13627           break;
13628         }
13629         _Fields fieldId = _Fields.findByThriftId(field.id);
13630         if (fieldId == null) {
13631           TProtocolUtil.skip(iprot, field.type);
13632         } else {
13633           switch (fieldId) {
13634             case TABLE_NAME:
13635               if (field.type == TType.STRING) {
13636                 this.tableName = iprot.readBinary();
13637               } else {
13638                 TProtocolUtil.skip(iprot, field.type);
13639               }
13640               break;
13641             case ROW:
13642               if (field.type == TType.STRING) {
13643                 this.row = iprot.readBinary();
13644               } else {
13645                 TProtocolUtil.skip(iprot, field.type);
13646               }
13647               break;
13648             case COLUMNS:
13649               if (field.type == TType.LIST) {
13650                 {
13651                   TList _list42 = iprot.readListBegin();
13652                   this.columns = new ArrayList<byte[]>(_list42.size);
13653                   for (int _i43 = 0; _i43 < _list42.size; ++_i43)
13654                   {
13655                     byte[] _elem44;
13656                     _elem44 = iprot.readBinary();
13657                     this.columns.add(_elem44);
13658                   }
13659                   iprot.readListEnd();
13660                 }
13661               } else {
13662                 TProtocolUtil.skip(iprot, field.type);
13663               }
13664               break;
13665           }
13666           iprot.readFieldEnd();
13667         }
13668       }
13669       iprot.readStructEnd();
13670 
13671       // check for required fields of primitive type, which can't be checked in the validate method
13672       validate();
13673     }
13674 
13675     public void write(TProtocol oprot) throws TException {
13676       validate();
13677 
13678       oprot.writeStructBegin(STRUCT_DESC);
13679       if (this.tableName != null) {
13680         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
13681         oprot.writeBinary(this.tableName);
13682         oprot.writeFieldEnd();
13683       }
13684       if (this.row != null) {
13685         oprot.writeFieldBegin(ROW_FIELD_DESC);
13686         oprot.writeBinary(this.row);
13687         oprot.writeFieldEnd();
13688       }
13689       if (this.columns != null) {
13690         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
13691         {
13692           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
13693           for (byte[] _iter45 : this.columns)
13694           {
13695             oprot.writeBinary(_iter45);
13696           }
13697           oprot.writeListEnd();
13698         }
13699         oprot.writeFieldEnd();
13700       }
13701       oprot.writeFieldStop();
13702       oprot.writeStructEnd();
13703     }
13704 
13705     @Override
13706     public String toString() {
13707       StringBuilder sb = new StringBuilder("getRowWithColumns_args(");
13708       boolean first = true;
13709 
13710       sb.append("tableName:");
13711       if (this.tableName == null) {
13712         sb.append("null");
13713       } else {
13714         sb.append(this.tableName);
13715       }
13716       first = false;
13717       if (!first) sb.append(", ");
13718       sb.append("row:");
13719       if (this.row == null) {
13720         sb.append("null");
13721       } else {
13722         sb.append(this.row);
13723       }
13724       first = false;
13725       if (!first) sb.append(", ");
13726       sb.append("columns:");
13727       if (this.columns == null) {
13728         sb.append("null");
13729       } else {
13730         sb.append(this.columns);
13731       }
13732       first = false;
13733       sb.append(")");
13734       return sb.toString();
13735     }
13736 
13737     public void validate() throws TException {
13738       // check for required fields
13739     }
13740 
13741   }
13742 
13743   public static class getRowWithColumns_result implements TBase<getRowWithColumns_result._Fields>, java.io.Serializable, Cloneable   {
13744     private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumns_result");
13745 
13746     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
13747     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
13748 
13749     public List<TRowResult> success;
13750     public IOError io;
13751 
13752     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
13753     public enum _Fields implements TFieldIdEnum {
13754       SUCCESS((short)0, "success"),
13755       IO((short)1, "io");
13756 
13757       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
13758       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
13759 
13760       static {
13761         for (_Fields field : EnumSet.allOf(_Fields.class)) {
13762           byId.put((int)field._thriftId, field);
13763           byName.put(field.getFieldName(), field);
13764         }
13765       }
13766 
13767       /**
13768        * Find the _Fields constant that matches fieldId, or null if its not found.
13769        */
13770       public static _Fields findByThriftId(int fieldId) {
13771         return byId.get(fieldId);
13772       }
13773 
13774       /**
13775        * Find the _Fields constant that matches fieldId, throwing an exception
13776        * if it is not found.
13777        */
13778       public static _Fields findByThriftIdOrThrow(int fieldId) {
13779         _Fields fields = findByThriftId(fieldId);
13780         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
13781         return fields;
13782       }
13783 
13784       /**
13785        * Find the _Fields constant that matches name, or null if its not found.
13786        */
13787       public static _Fields findByName(String name) {
13788         return byName.get(name);
13789       }
13790 
13791       private final short _thriftId;
13792       private final String _fieldName;
13793 
13794       _Fields(short thriftId, String fieldName) {
13795         _thriftId = thriftId;
13796         _fieldName = fieldName;
13797       }
13798 
13799       public short getThriftFieldId() {
13800         return _thriftId;
13801       }
13802 
13803       public String getFieldName() {
13804         return _fieldName;
13805       }
13806     }
13807 
13808     // isset id assignments
13809 
13810     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
13811       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
13812           new ListMetaData(TType.LIST,
13813               new StructMetaData(TType.STRUCT, TRowResult.class))));
13814       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
13815           new FieldValueMetaData(TType.STRUCT)));
13816     }});
13817 
13818     static {
13819       FieldMetaData.addStructMetaDataMap(getRowWithColumns_result.class, metaDataMap);
13820     }
13821 
13822     public getRowWithColumns_result() {
13823     }
13824 
13825     public getRowWithColumns_result(
13826       List<TRowResult> success,
13827       IOError io)
13828     {
13829       this();
13830       this.success = success;
13831       this.io = io;
13832     }
13833 
13834     /**
13835      * Performs a deep copy on <i>other</i>.
13836      */
13837     public getRowWithColumns_result(getRowWithColumns_result other) {
13838       if (other.isSetSuccess()) {
13839         List<TRowResult> __this__success = new ArrayList<TRowResult>();
13840         for (TRowResult other_element : other.success) {
13841           __this__success.add(new TRowResult(other_element));
13842         }
13843         this.success = __this__success;
13844       }
13845       if (other.isSetIo()) {
13846         this.io = new IOError(other.io);
13847       }
13848     }
13849 
13850     public getRowWithColumns_result deepCopy() {
13851       return new getRowWithColumns_result(this);
13852     }
13853 
13854     @Deprecated
13855     public getRowWithColumns_result clone() {
13856       return new getRowWithColumns_result(this);
13857     }
13858 
13859     public int getSuccessSize() {
13860       return (this.success == null) ? 0 : this.success.size();
13861     }
13862 
13863     public java.util.Iterator<TRowResult> getSuccessIterator() {
13864       return (this.success == null) ? null : this.success.iterator();
13865     }
13866 
13867     public void addToSuccess(TRowResult elem) {
13868       if (this.success == null) {
13869         this.success = new ArrayList<TRowResult>();
13870       }
13871       this.success.add(elem);
13872     }
13873 
13874     public List<TRowResult> getSuccess() {
13875       return this.success;
13876     }
13877 
13878     public getRowWithColumns_result setSuccess(List<TRowResult> success) {
13879       this.success = success;
13880       return this;
13881     }
13882 
13883     public void unsetSuccess() {
13884       this.success = null;
13885     }
13886 
13887     /** Returns true if field success is set (has been asigned a value) and false otherwise */
13888     public boolean isSetSuccess() {
13889       return this.success != null;
13890     }
13891 
13892     public void setSuccessIsSet(boolean value) {
13893       if (!value) {
13894         this.success = null;
13895       }
13896     }
13897 
13898     public IOError getIo() {
13899       return this.io;
13900     }
13901 
13902     public getRowWithColumns_result setIo(IOError io) {
13903       this.io = io;
13904       return this;
13905     }
13906 
13907     public void unsetIo() {
13908       this.io = null;
13909     }
13910 
13911     /** Returns true if field io is set (has been asigned a value) and false otherwise */
13912     public boolean isSetIo() {
13913       return this.io != null;
13914     }
13915 
13916     public void setIoIsSet(boolean value) {
13917       if (!value) {
13918         this.io = null;
13919       }
13920     }
13921 
13922     public void setFieldValue(_Fields field, Object value) {
13923       switch (field) {
13924       case SUCCESS:
13925         if (value == null) {
13926           unsetSuccess();
13927         } else {
13928           setSuccess((List<TRowResult>)value);
13929         }
13930         break;
13931 
13932       case IO:
13933         if (value == null) {
13934           unsetIo();
13935         } else {
13936           setIo((IOError)value);
13937         }
13938         break;
13939 
13940       }
13941     }
13942 
13943     public void setFieldValue(int fieldID, Object value) {
13944       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
13945     }
13946 
13947     public Object getFieldValue(_Fields field) {
13948       switch (field) {
13949       case SUCCESS:
13950         return getSuccess();
13951 
13952       case IO:
13953         return getIo();
13954 
13955       }
13956       throw new IllegalStateException();
13957     }
13958 
13959     public Object getFieldValue(int fieldId) {
13960       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
13961     }
13962 
13963     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
13964     public boolean isSet(_Fields field) {
13965       switch (field) {
13966       case SUCCESS:
13967         return isSetSuccess();
13968       case IO:
13969         return isSetIo();
13970       }
13971       throw new IllegalStateException();
13972     }
13973 
13974     public boolean isSet(int fieldID) {
13975       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
13976     }
13977 
13978     @Override
13979     public boolean equals(Object that) {
13980       if (that == null)
13981         return false;
13982       if (that instanceof getRowWithColumns_result)
13983         return this.equals((getRowWithColumns_result)that);
13984       return false;
13985     }
13986 
13987     public boolean equals(getRowWithColumns_result that) {
13988       if (that == null)
13989         return false;
13990 
13991       boolean this_present_success = true && this.isSetSuccess();
13992       boolean that_present_success = true && that.isSetSuccess();
13993       if (this_present_success || that_present_success) {
13994         if (!(this_present_success && that_present_success))
13995           return false;
13996         if (!this.success.equals(that.success))
13997           return false;
13998       }
13999 
14000       boolean this_present_io = true && this.isSetIo();
14001       boolean that_present_io = true && that.isSetIo();
14002       if (this_present_io || that_present_io) {
14003         if (!(this_present_io && that_present_io))
14004           return false;
14005         if (!this.io.equals(that.io))
14006           return false;
14007       }
14008 
14009       return true;
14010     }
14011 
14012     @Override
14013     public int hashCode() {
14014       HashCodeBuilder builder = new HashCodeBuilder();
14015 
14016       boolean present_success = true && (isSetSuccess());
14017       builder.append(present_success);
14018       if (present_success)
14019         builder.append(success);
14020 
14021       boolean present_io = true && (isSetIo());
14022       builder.append(present_io);
14023       if (present_io)
14024         builder.append(io);
14025 
14026       return builder.toHashCode();
14027     }
14028 
14029     public void read(TProtocol iprot) throws TException {
14030       TField field;
14031       iprot.readStructBegin();
14032       while (true)
14033       {
14034         field = iprot.readFieldBegin();
14035         if (field.type == TType.STOP) {
14036           break;
14037         }
14038         _Fields fieldId = _Fields.findByThriftId(field.id);
14039         if (fieldId == null) {
14040           TProtocolUtil.skip(iprot, field.type);
14041         } else {
14042           switch (fieldId) {
14043             case SUCCESS:
14044               if (field.type == TType.LIST) {
14045                 {
14046                   TList _list46 = iprot.readListBegin();
14047                   this.success = new ArrayList<TRowResult>(_list46.size);
14048                   for (int _i47 = 0; _i47 < _list46.size; ++_i47)
14049                   {
14050                     TRowResult _elem48;
14051                     _elem48 = new TRowResult();
14052                     _elem48.read(iprot);
14053                     this.success.add(_elem48);
14054                   }
14055                   iprot.readListEnd();
14056                 }
14057               } else {
14058                 TProtocolUtil.skip(iprot, field.type);
14059               }
14060               break;
14061             case IO:
14062               if (field.type == TType.STRUCT) {
14063                 this.io = new IOError();
14064                 this.io.read(iprot);
14065               } else {
14066                 TProtocolUtil.skip(iprot, field.type);
14067               }
14068               break;
14069           }
14070           iprot.readFieldEnd();
14071         }
14072       }
14073       iprot.readStructEnd();
14074 
14075       // check for required fields of primitive type, which can't be checked in the validate method
14076       validate();
14077     }
14078 
14079     public void write(TProtocol oprot) throws TException {
14080       oprot.writeStructBegin(STRUCT_DESC);
14081 
14082       if (this.isSetSuccess()) {
14083         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
14084         {
14085           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
14086           for (TRowResult _iter49 : this.success)
14087           {
14088             _iter49.write(oprot);
14089           }
14090           oprot.writeListEnd();
14091         }
14092         oprot.writeFieldEnd();
14093       } else if (this.isSetIo()) {
14094         oprot.writeFieldBegin(IO_FIELD_DESC);
14095         this.io.write(oprot);
14096         oprot.writeFieldEnd();
14097       }
14098       oprot.writeFieldStop();
14099       oprot.writeStructEnd();
14100     }
14101 
14102     @Override
14103     public String toString() {
14104       StringBuilder sb = new StringBuilder("getRowWithColumns_result(");
14105       boolean first = true;
14106 
14107       sb.append("success:");
14108       if (this.success == null) {
14109         sb.append("null");
14110       } else {
14111         sb.append(this.success);
14112       }
14113       first = false;
14114       if (!first) sb.append(", ");
14115       sb.append("io:");
14116       if (this.io == null) {
14117         sb.append("null");
14118       } else {
14119         sb.append(this.io);
14120       }
14121       first = false;
14122       sb.append(")");
14123       return sb.toString();
14124     }
14125 
14126     public void validate() throws TException {
14127       // check for required fields
14128     }
14129 
14130   }
14131 
14132   public static class getRowTs_args implements TBase<getRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowTs_args>   {
14133     private static final TStruct STRUCT_DESC = new TStruct("getRowTs_args");
14134 
14135     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
14136     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
14137     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
14138 
14139     /**
14140      * name of the table
14141      */
14142     public byte[] tableName;
14143     /**
14144      * row key
14145      */
14146     public byte[] row;
14147     /**
14148      * timestamp
14149      */
14150     public long timestamp;
14151 
14152     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
14153     public enum _Fields implements TFieldIdEnum {
14154       /**
14155        * name of the table
14156        */
14157       TABLE_NAME((short)1, "tableName"),
14158       /**
14159        * row key
14160        */
14161       ROW((short)2, "row"),
14162       /**
14163        * timestamp
14164        */
14165       TIMESTAMP((short)3, "timestamp");
14166 
14167       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14168       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14169 
14170       static {
14171         for (_Fields field : EnumSet.allOf(_Fields.class)) {
14172           byId.put((int)field._thriftId, field);
14173           byName.put(field.getFieldName(), field);
14174         }
14175       }
14176 
14177       /**
14178        * Find the _Fields constant that matches fieldId, or null if its not found.
14179        */
14180       public static _Fields findByThriftId(int fieldId) {
14181         return byId.get(fieldId);
14182       }
14183 
14184       /**
14185        * Find the _Fields constant that matches fieldId, throwing an exception
14186        * if it is not found.
14187        */
14188       public static _Fields findByThriftIdOrThrow(int fieldId) {
14189         _Fields fields = findByThriftId(fieldId);
14190         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14191         return fields;
14192       }
14193 
14194       /**
14195        * Find the _Fields constant that matches name, or null if its not found.
14196        */
14197       public static _Fields findByName(String name) {
14198         return byName.get(name);
14199       }
14200 
14201       private final short _thriftId;
14202       private final String _fieldName;
14203 
14204       _Fields(short thriftId, String fieldName) {
14205         _thriftId = thriftId;
14206         _fieldName = fieldName;
14207       }
14208 
14209       public short getThriftFieldId() {
14210         return _thriftId;
14211       }
14212 
14213       public String getFieldName() {
14214         return _fieldName;
14215       }
14216     }
14217 
14218     // isset id assignments
14219     private static final int __TIMESTAMP_ISSET_ID = 0;
14220     private BitSet __isset_bit_vector = new BitSet(1);
14221 
14222     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
14223       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
14224           new FieldValueMetaData(TType.STRING)));
14225       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
14226           new FieldValueMetaData(TType.STRING)));
14227       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
14228           new FieldValueMetaData(TType.I64)));
14229     }});
14230 
14231     static {
14232       FieldMetaData.addStructMetaDataMap(getRowTs_args.class, metaDataMap);
14233     }
14234 
14235     public getRowTs_args() {
14236     }
14237 
14238     public getRowTs_args(
14239       byte[] tableName,
14240       byte[] row,
14241       long timestamp)
14242     {
14243       this();
14244       this.tableName = tableName;
14245       this.row = row;
14246       this.timestamp = timestamp;
14247       setTimestampIsSet(true);
14248     }
14249 
14250     /**
14251      * Performs a deep copy on <i>other</i>.
14252      */
14253     public getRowTs_args(getRowTs_args other) {
14254       __isset_bit_vector.clear();
14255       __isset_bit_vector.or(other.__isset_bit_vector);
14256       if (other.isSetTableName()) {
14257         this.tableName = other.tableName;
14258       }
14259       if (other.isSetRow()) {
14260         this.row = other.row;
14261       }
14262       this.timestamp = other.timestamp;
14263     }
14264 
14265     public getRowTs_args deepCopy() {
14266       return new getRowTs_args(this);
14267     }
14268 
14269     @Deprecated
14270     public getRowTs_args clone() {
14271       return new getRowTs_args(this);
14272     }
14273 
14274     /**
14275      * name of the table
14276      */
14277     public byte[] getTableName() {
14278       return this.tableName;
14279     }
14280 
14281     /**
14282      * name of the table
14283      */
14284     public getRowTs_args setTableName(byte[] tableName) {
14285       this.tableName = tableName;
14286       return this;
14287     }
14288 
14289     public void unsetTableName() {
14290       this.tableName = null;
14291     }
14292 
14293     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
14294     public boolean isSetTableName() {
14295       return this.tableName != null;
14296     }
14297 
14298     public void setTableNameIsSet(boolean value) {
14299       if (!value) {
14300         this.tableName = null;
14301       }
14302     }
14303 
14304     /**
14305      * row key
14306      */
14307     public byte[] getRow() {
14308       return this.row;
14309     }
14310 
14311     /**
14312      * row key
14313      */
14314     public getRowTs_args setRow(byte[] row) {
14315       this.row = row;
14316       return this;
14317     }
14318 
14319     public void unsetRow() {
14320       this.row = null;
14321     }
14322 
14323     /** Returns true if field row is set (has been asigned a value) and false otherwise */
14324     public boolean isSetRow() {
14325       return this.row != null;
14326     }
14327 
14328     public void setRowIsSet(boolean value) {
14329       if (!value) {
14330         this.row = null;
14331       }
14332     }
14333 
14334     /**
14335      * timestamp
14336      */
14337     public long getTimestamp() {
14338       return this.timestamp;
14339     }
14340 
14341     /**
14342      * timestamp
14343      */
14344     public getRowTs_args setTimestamp(long timestamp) {
14345       this.timestamp = timestamp;
14346       setTimestampIsSet(true);
14347       return this;
14348     }
14349 
14350     public void unsetTimestamp() {
14351       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
14352     }
14353 
14354     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
14355     public boolean isSetTimestamp() {
14356       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
14357     }
14358 
14359     public void setTimestampIsSet(boolean value) {
14360       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
14361     }
14362 
14363     public void setFieldValue(_Fields field, Object value) {
14364       switch (field) {
14365       case TABLE_NAME:
14366         if (value == null) {
14367           unsetTableName();
14368         } else {
14369           setTableName((byte[])value);
14370         }
14371         break;
14372 
14373       case ROW:
14374         if (value == null) {
14375           unsetRow();
14376         } else {
14377           setRow((byte[])value);
14378         }
14379         break;
14380 
14381       case TIMESTAMP:
14382         if (value == null) {
14383           unsetTimestamp();
14384         } else {
14385           setTimestamp((Long)value);
14386         }
14387         break;
14388 
14389       }
14390     }
14391 
14392     public void setFieldValue(int fieldID, Object value) {
14393       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
14394     }
14395 
14396     public Object getFieldValue(_Fields field) {
14397       switch (field) {
14398       case TABLE_NAME:
14399         return getTableName();
14400 
14401       case ROW:
14402         return getRow();
14403 
14404       case TIMESTAMP:
14405         return new Long(getTimestamp());
14406 
14407       }
14408       throw new IllegalStateException();
14409     }
14410 
14411     public Object getFieldValue(int fieldId) {
14412       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
14413     }
14414 
14415     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
14416     public boolean isSet(_Fields field) {
14417       switch (field) {
14418       case TABLE_NAME:
14419         return isSetTableName();
14420       case ROW:
14421         return isSetRow();
14422       case TIMESTAMP:
14423         return isSetTimestamp();
14424       }
14425       throw new IllegalStateException();
14426     }
14427 
14428     public boolean isSet(int fieldID) {
14429       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
14430     }
14431 
14432     @Override
14433     public boolean equals(Object that) {
14434       if (that == null)
14435         return false;
14436       if (that instanceof getRowTs_args)
14437         return this.equals((getRowTs_args)that);
14438       return false;
14439     }
14440 
14441     public boolean equals(getRowTs_args that) {
14442       if (that == null)
14443         return false;
14444 
14445       boolean this_present_tableName = true && this.isSetTableName();
14446       boolean that_present_tableName = true && that.isSetTableName();
14447       if (this_present_tableName || that_present_tableName) {
14448         if (!(this_present_tableName && that_present_tableName))
14449           return false;
14450         if (!java.util.Arrays.equals(this.tableName, that.tableName))
14451           return false;
14452       }
14453 
14454       boolean this_present_row = true && this.isSetRow();
14455       boolean that_present_row = true && that.isSetRow();
14456       if (this_present_row || that_present_row) {
14457         if (!(this_present_row && that_present_row))
14458           return false;
14459         if (!java.util.Arrays.equals(this.row, that.row))
14460           return false;
14461       }
14462 
14463       boolean this_present_timestamp = true;
14464       boolean that_present_timestamp = true;
14465       if (this_present_timestamp || that_present_timestamp) {
14466         if (!(this_present_timestamp && that_present_timestamp))
14467           return false;
14468         if (this.timestamp != that.timestamp)
14469           return false;
14470       }
14471 
14472       return true;
14473     }
14474 
14475     @Override
14476     public int hashCode() {
14477       HashCodeBuilder builder = new HashCodeBuilder();
14478 
14479       boolean present_tableName = true && (isSetTableName());
14480       builder.append(present_tableName);
14481       if (present_tableName)
14482         builder.append(tableName);
14483 
14484       boolean present_row = true && (isSetRow());
14485       builder.append(present_row);
14486       if (present_row)
14487         builder.append(row);
14488 
14489       boolean present_timestamp = true;
14490       builder.append(present_timestamp);
14491       if (present_timestamp)
14492         builder.append(timestamp);
14493 
14494       return builder.toHashCode();
14495     }
14496 
14497     public int compareTo(getRowTs_args other) {
14498       if (!getClass().equals(other.getClass())) {
14499         return getClass().getName().compareTo(other.getClass().getName());
14500       }
14501 
14502       int lastComparison = 0;
14503       getRowTs_args typedOther = (getRowTs_args)other;
14504 
14505       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
14506       if (lastComparison != 0) {
14507         return lastComparison;
14508       }
14509       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
14510       if (lastComparison != 0) {
14511         return lastComparison;
14512       }
14513       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
14514       if (lastComparison != 0) {
14515         return lastComparison;
14516       }
14517       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
14518       if (lastComparison != 0) {
14519         return lastComparison;
14520       }
14521       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
14522       if (lastComparison != 0) {
14523         return lastComparison;
14524       }
14525       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
14526       if (lastComparison != 0) {
14527         return lastComparison;
14528       }
14529       return 0;
14530     }
14531 
14532     public void read(TProtocol iprot) throws TException {
14533       TField field;
14534       iprot.readStructBegin();
14535       while (true)
14536       {
14537         field = iprot.readFieldBegin();
14538         if (field.type == TType.STOP) {
14539           break;
14540         }
14541         _Fields fieldId = _Fields.findByThriftId(field.id);
14542         if (fieldId == null) {
14543           TProtocolUtil.skip(iprot, field.type);
14544         } else {
14545           switch (fieldId) {
14546             case TABLE_NAME:
14547               if (field.type == TType.STRING) {
14548                 this.tableName = iprot.readBinary();
14549               } else {
14550                 TProtocolUtil.skip(iprot, field.type);
14551               }
14552               break;
14553             case ROW:
14554               if (field.type == TType.STRING) {
14555                 this.row = iprot.readBinary();
14556               } else {
14557                 TProtocolUtil.skip(iprot, field.type);
14558               }
14559               break;
14560             case TIMESTAMP:
14561               if (field.type == TType.I64) {
14562                 this.timestamp = iprot.readI64();
14563                 setTimestampIsSet(true);
14564               } else {
14565                 TProtocolUtil.skip(iprot, field.type);
14566               }
14567               break;
14568           }
14569           iprot.readFieldEnd();
14570         }
14571       }
14572       iprot.readStructEnd();
14573 
14574       // check for required fields of primitive type, which can't be checked in the validate method
14575       validate();
14576     }
14577 
14578     public void write(TProtocol oprot) throws TException {
14579       validate();
14580 
14581       oprot.writeStructBegin(STRUCT_DESC);
14582       if (this.tableName != null) {
14583         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
14584         oprot.writeBinary(this.tableName);
14585         oprot.writeFieldEnd();
14586       }
14587       if (this.row != null) {
14588         oprot.writeFieldBegin(ROW_FIELD_DESC);
14589         oprot.writeBinary(this.row);
14590         oprot.writeFieldEnd();
14591       }
14592       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
14593       oprot.writeI64(this.timestamp);
14594       oprot.writeFieldEnd();
14595       oprot.writeFieldStop();
14596       oprot.writeStructEnd();
14597     }
14598 
14599     @Override
14600     public String toString() {
14601       StringBuilder sb = new StringBuilder("getRowTs_args(");
14602       boolean first = true;
14603 
14604       sb.append("tableName:");
14605       if (this.tableName == null) {
14606         sb.append("null");
14607       } else {
14608         sb.append(this.tableName);
14609       }
14610       first = false;
14611       if (!first) sb.append(", ");
14612       sb.append("row:");
14613       if (this.row == null) {
14614         sb.append("null");
14615       } else {
14616         sb.append(this.row);
14617       }
14618       first = false;
14619       if (!first) sb.append(", ");
14620       sb.append("timestamp:");
14621       sb.append(this.timestamp);
14622       first = false;
14623       sb.append(")");
14624       return sb.toString();
14625     }
14626 
14627     public void validate() throws TException {
14628       // check for required fields
14629     }
14630 
14631   }
14632 
14633   public static class getRowTs_result implements TBase<getRowTs_result._Fields>, java.io.Serializable, Cloneable   {
14634     private static final TStruct STRUCT_DESC = new TStruct("getRowTs_result");
14635 
14636     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
14637     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
14638 
14639     public List<TRowResult> success;
14640     public IOError io;
14641 
14642     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
14643     public enum _Fields implements TFieldIdEnum {
14644       SUCCESS((short)0, "success"),
14645       IO((short)1, "io");
14646 
14647       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
14648       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
14649 
14650       static {
14651         for (_Fields field : EnumSet.allOf(_Fields.class)) {
14652           byId.put((int)field._thriftId, field);
14653           byName.put(field.getFieldName(), field);
14654         }
14655       }
14656 
14657       /**
14658        * Find the _Fields constant that matches fieldId, or null if its not found.
14659        */
14660       public static _Fields findByThriftId(int fieldId) {
14661         return byId.get(fieldId);
14662       }
14663 
14664       /**
14665        * Find the _Fields constant that matches fieldId, throwing an exception
14666        * if it is not found.
14667        */
14668       public static _Fields findByThriftIdOrThrow(int fieldId) {
14669         _Fields fields = findByThriftId(fieldId);
14670         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
14671         return fields;
14672       }
14673 
14674       /**
14675        * Find the _Fields constant that matches name, or null if its not found.
14676        */
14677       public static _Fields findByName(String name) {
14678         return byName.get(name);
14679       }
14680 
14681       private final short _thriftId;
14682       private final String _fieldName;
14683 
14684       _Fields(short thriftId, String fieldName) {
14685         _thriftId = thriftId;
14686         _fieldName = fieldName;
14687       }
14688 
14689       public short getThriftFieldId() {
14690         return _thriftId;
14691       }
14692 
14693       public String getFieldName() {
14694         return _fieldName;
14695       }
14696     }
14697 
14698     // isset id assignments
14699 
14700     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
14701       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
14702           new ListMetaData(TType.LIST,
14703               new StructMetaData(TType.STRUCT, TRowResult.class))));
14704       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
14705           new FieldValueMetaData(TType.STRUCT)));
14706     }});
14707 
14708     static {
14709       FieldMetaData.addStructMetaDataMap(getRowTs_result.class, metaDataMap);
14710     }
14711 
14712     public getRowTs_result() {
14713     }
14714 
14715     public getRowTs_result(
14716       List<TRowResult> success,
14717       IOError io)
14718     {
14719       this();
14720       this.success = success;
14721       this.io = io;
14722     }
14723 
14724     /**
14725      * Performs a deep copy on <i>other</i>.
14726      */
14727     public getRowTs_result(getRowTs_result other) {
14728       if (other.isSetSuccess()) {
14729         List<TRowResult> __this__success = new ArrayList<TRowResult>();
14730         for (TRowResult other_element : other.success) {
14731           __this__success.add(new TRowResult(other_element));
14732         }
14733         this.success = __this__success;
14734       }
14735       if (other.isSetIo()) {
14736         this.io = new IOError(other.io);
14737       }
14738     }
14739 
14740     public getRowTs_result deepCopy() {
14741       return new getRowTs_result(this);
14742     }
14743 
14744     @Deprecated
14745     public getRowTs_result clone() {
14746       return new getRowTs_result(this);
14747     }
14748 
14749     public int getSuccessSize() {
14750       return (this.success == null) ? 0 : this.success.size();
14751     }
14752 
14753     public java.util.Iterator<TRowResult> getSuccessIterator() {
14754       return (this.success == null) ? null : this.success.iterator();
14755     }
14756 
14757     public void addToSuccess(TRowResult elem) {
14758       if (this.success == null) {
14759         this.success = new ArrayList<TRowResult>();
14760       }
14761       this.success.add(elem);
14762     }
14763 
14764     public List<TRowResult> getSuccess() {
14765       return this.success;
14766     }
14767 
14768     public getRowTs_result setSuccess(List<TRowResult> success) {
14769       this.success = success;
14770       return this;
14771     }
14772 
14773     public void unsetSuccess() {
14774       this.success = null;
14775     }
14776 
14777     /** Returns true if field success is set (has been asigned a value) and false otherwise */
14778     public boolean isSetSuccess() {
14779       return this.success != null;
14780     }
14781 
14782     public void setSuccessIsSet(boolean value) {
14783       if (!value) {
14784         this.success = null;
14785       }
14786     }
14787 
14788     public IOError getIo() {
14789       return this.io;
14790     }
14791 
14792     public getRowTs_result setIo(IOError io) {
14793       this.io = io;
14794       return this;
14795     }
14796 
14797     public void unsetIo() {
14798       this.io = null;
14799     }
14800 
14801     /** Returns true if field io is set (has been asigned a value) and false otherwise */
14802     public boolean isSetIo() {
14803       return this.io != null;
14804     }
14805 
14806     public void setIoIsSet(boolean value) {
14807       if (!value) {
14808         this.io = null;
14809       }
14810     }
14811 
14812     public void setFieldValue(_Fields field, Object value) {
14813       switch (field) {
14814       case SUCCESS:
14815         if (value == null) {
14816           unsetSuccess();
14817         } else {
14818           setSuccess((List<TRowResult>)value);
14819         }
14820         break;
14821 
14822       case IO:
14823         if (value == null) {
14824           unsetIo();
14825         } else {
14826           setIo((IOError)value);
14827         }
14828         break;
14829 
14830       }
14831     }
14832 
14833     public void setFieldValue(int fieldID, Object value) {
14834       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
14835     }
14836 
14837     public Object getFieldValue(_Fields field) {
14838       switch (field) {
14839       case SUCCESS:
14840         return getSuccess();
14841 
14842       case IO:
14843         return getIo();
14844 
14845       }
14846       throw new IllegalStateException();
14847     }
14848 
14849     public Object getFieldValue(int fieldId) {
14850       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
14851     }
14852 
14853     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
14854     public boolean isSet(_Fields field) {
14855       switch (field) {
14856       case SUCCESS:
14857         return isSetSuccess();
14858       case IO:
14859         return isSetIo();
14860       }
14861       throw new IllegalStateException();
14862     }
14863 
14864     public boolean isSet(int fieldID) {
14865       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
14866     }
14867 
14868     @Override
14869     public boolean equals(Object that) {
14870       if (that == null)
14871         return false;
14872       if (that instanceof getRowTs_result)
14873         return this.equals((getRowTs_result)that);
14874       return false;
14875     }
14876 
14877     public boolean equals(getRowTs_result that) {
14878       if (that == null)
14879         return false;
14880 
14881       boolean this_present_success = true && this.isSetSuccess();
14882       boolean that_present_success = true && that.isSetSuccess();
14883       if (this_present_success || that_present_success) {
14884         if (!(this_present_success && that_present_success))
14885           return false;
14886         if (!this.success.equals(that.success))
14887           return false;
14888       }
14889 
14890       boolean this_present_io = true && this.isSetIo();
14891       boolean that_present_io = true && that.isSetIo();
14892       if (this_present_io || that_present_io) {
14893         if (!(this_present_io && that_present_io))
14894           return false;
14895         if (!this.io.equals(that.io))
14896           return false;
14897       }
14898 
14899       return true;
14900     }
14901 
14902     @Override
14903     public int hashCode() {
14904       HashCodeBuilder builder = new HashCodeBuilder();
14905 
14906       boolean present_success = true && (isSetSuccess());
14907       builder.append(present_success);
14908       if (present_success)
14909         builder.append(success);
14910 
14911       boolean present_io = true && (isSetIo());
14912       builder.append(present_io);
14913       if (present_io)
14914         builder.append(io);
14915 
14916       return builder.toHashCode();
14917     }
14918 
14919     public void read(TProtocol iprot) throws TException {
14920       TField field;
14921       iprot.readStructBegin();
14922       while (true)
14923       {
14924         field = iprot.readFieldBegin();
14925         if (field.type == TType.STOP) {
14926           break;
14927         }
14928         _Fields fieldId = _Fields.findByThriftId(field.id);
14929         if (fieldId == null) {
14930           TProtocolUtil.skip(iprot, field.type);
14931         } else {
14932           switch (fieldId) {
14933             case SUCCESS:
14934               if (field.type == TType.LIST) {
14935                 {
14936                   TList _list50 = iprot.readListBegin();
14937                   this.success = new ArrayList<TRowResult>(_list50.size);
14938                   for (int _i51 = 0; _i51 < _list50.size; ++_i51)
14939                   {
14940                     TRowResult _elem52;
14941                     _elem52 = new TRowResult();
14942                     _elem52.read(iprot);
14943                     this.success.add(_elem52);
14944                   }
14945                   iprot.readListEnd();
14946                 }
14947               } else {
14948                 TProtocolUtil.skip(iprot, field.type);
14949               }
14950               break;
14951             case IO:
14952               if (field.type == TType.STRUCT) {
14953                 this.io = new IOError();
14954                 this.io.read(iprot);
14955               } else {
14956                 TProtocolUtil.skip(iprot, field.type);
14957               }
14958               break;
14959           }
14960           iprot.readFieldEnd();
14961         }
14962       }
14963       iprot.readStructEnd();
14964 
14965       // check for required fields of primitive type, which can't be checked in the validate method
14966       validate();
14967     }
14968 
14969     public void write(TProtocol oprot) throws TException {
14970       oprot.writeStructBegin(STRUCT_DESC);
14971 
14972       if (this.isSetSuccess()) {
14973         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
14974         {
14975           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
14976           for (TRowResult _iter53 : this.success)
14977           {
14978             _iter53.write(oprot);
14979           }
14980           oprot.writeListEnd();
14981         }
14982         oprot.writeFieldEnd();
14983       } else if (this.isSetIo()) {
14984         oprot.writeFieldBegin(IO_FIELD_DESC);
14985         this.io.write(oprot);
14986         oprot.writeFieldEnd();
14987       }
14988       oprot.writeFieldStop();
14989       oprot.writeStructEnd();
14990     }
14991 
14992     @Override
14993     public String toString() {
14994       StringBuilder sb = new StringBuilder("getRowTs_result(");
14995       boolean first = true;
14996 
14997       sb.append("success:");
14998       if (this.success == null) {
14999         sb.append("null");
15000       } else {
15001         sb.append(this.success);
15002       }
15003       first = false;
15004       if (!first) sb.append(", ");
15005       sb.append("io:");
15006       if (this.io == null) {
15007         sb.append("null");
15008       } else {
15009         sb.append(this.io);
15010       }
15011       first = false;
15012       sb.append(")");
15013       return sb.toString();
15014     }
15015 
15016     public void validate() throws TException {
15017       // check for required fields
15018     }
15019 
15020   }
15021 
15022   public static class getRowWithColumnsTs_args implements TBase<getRowWithColumnsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowWithColumnsTs_args>   {
15023     private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_args");
15024 
15025     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
15026     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
15027     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
15028     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
15029 
15030     /**
15031      * name of table
15032      */
15033     public byte[] tableName;
15034     /**
15035      * row key
15036      */
15037     public byte[] row;
15038     /**
15039      * List of columns to return, null for all columns
15040      */
15041     public List<byte[]> columns;
15042     public long timestamp;
15043 
15044     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
15045     public enum _Fields implements TFieldIdEnum {
15046       /**
15047        * name of table
15048        */
15049       TABLE_NAME((short)1, "tableName"),
15050       /**
15051        * row key
15052        */
15053       ROW((short)2, "row"),
15054       /**
15055        * List of columns to return, null for all columns
15056        */
15057       COLUMNS((short)3, "columns"),
15058       TIMESTAMP((short)4, "timestamp");
15059 
15060       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
15061       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15062 
15063       static {
15064         for (_Fields field : EnumSet.allOf(_Fields.class)) {
15065           byId.put((int)field._thriftId, field);
15066           byName.put(field.getFieldName(), field);
15067         }
15068       }
15069 
15070       /**
15071        * Find the _Fields constant that matches fieldId, or null if its not found.
15072        */
15073       public static _Fields findByThriftId(int fieldId) {
15074         return byId.get(fieldId);
15075       }
15076 
15077       /**
15078        * Find the _Fields constant that matches fieldId, throwing an exception
15079        * if it is not found.
15080        */
15081       public static _Fields findByThriftIdOrThrow(int fieldId) {
15082         _Fields fields = findByThriftId(fieldId);
15083         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15084         return fields;
15085       }
15086 
15087       /**
15088        * Find the _Fields constant that matches name, or null if its not found.
15089        */
15090       public static _Fields findByName(String name) {
15091         return byName.get(name);
15092       }
15093 
15094       private final short _thriftId;
15095       private final String _fieldName;
15096 
15097       _Fields(short thriftId, String fieldName) {
15098         _thriftId = thriftId;
15099         _fieldName = fieldName;
15100       }
15101 
15102       public short getThriftFieldId() {
15103         return _thriftId;
15104       }
15105 
15106       public String getFieldName() {
15107         return _fieldName;
15108       }
15109     }
15110 
15111     // isset id assignments
15112     private static final int __TIMESTAMP_ISSET_ID = 0;
15113     private BitSet __isset_bit_vector = new BitSet(1);
15114 
15115     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
15116       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
15117           new FieldValueMetaData(TType.STRING)));
15118       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
15119           new FieldValueMetaData(TType.STRING)));
15120       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
15121           new ListMetaData(TType.LIST,
15122               new FieldValueMetaData(TType.STRING))));
15123       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
15124           new FieldValueMetaData(TType.I64)));
15125     }});
15126 
15127     static {
15128       FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_args.class, metaDataMap);
15129     }
15130 
15131     public getRowWithColumnsTs_args() {
15132     }
15133 
15134     public getRowWithColumnsTs_args(
15135       byte[] tableName,
15136       byte[] row,
15137       List<byte[]> columns,
15138       long timestamp)
15139     {
15140       this();
15141       this.tableName = tableName;
15142       this.row = row;
15143       this.columns = columns;
15144       this.timestamp = timestamp;
15145       setTimestampIsSet(true);
15146     }
15147 
15148     /**
15149      * Performs a deep copy on <i>other</i>.
15150      */
15151     public getRowWithColumnsTs_args(getRowWithColumnsTs_args other) {
15152       __isset_bit_vector.clear();
15153       __isset_bit_vector.or(other.__isset_bit_vector);
15154       if (other.isSetTableName()) {
15155         this.tableName = other.tableName;
15156       }
15157       if (other.isSetRow()) {
15158         this.row = other.row;
15159       }
15160       if (other.isSetColumns()) {
15161         List<byte[]> __this__columns = new ArrayList<byte[]>();
15162         for (byte[] other_element : other.columns) {
15163           __this__columns.add(other_element);
15164         }
15165         this.columns = __this__columns;
15166       }
15167       this.timestamp = other.timestamp;
15168     }
15169 
15170     public getRowWithColumnsTs_args deepCopy() {
15171       return new getRowWithColumnsTs_args(this);
15172     }
15173 
15174     @Deprecated
15175     public getRowWithColumnsTs_args clone() {
15176       return new getRowWithColumnsTs_args(this);
15177     }
15178 
15179     /**
15180      * name of table
15181      */
15182     public byte[] getTableName() {
15183       return this.tableName;
15184     }
15185 
15186     /**
15187      * name of table
15188      */
15189     public getRowWithColumnsTs_args setTableName(byte[] tableName) {
15190       this.tableName = tableName;
15191       return this;
15192     }
15193 
15194     public void unsetTableName() {
15195       this.tableName = null;
15196     }
15197 
15198     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
15199     public boolean isSetTableName() {
15200       return this.tableName != null;
15201     }
15202 
15203     public void setTableNameIsSet(boolean value) {
15204       if (!value) {
15205         this.tableName = null;
15206       }
15207     }
15208 
15209     /**
15210      * row key
15211      */
15212     public byte[] getRow() {
15213       return this.row;
15214     }
15215 
15216     /**
15217      * row key
15218      */
15219     public getRowWithColumnsTs_args setRow(byte[] row) {
15220       this.row = row;
15221       return this;
15222     }
15223 
15224     public void unsetRow() {
15225       this.row = null;
15226     }
15227 
15228     /** Returns true if field row is set (has been asigned a value) and false otherwise */
15229     public boolean isSetRow() {
15230       return this.row != null;
15231     }
15232 
15233     public void setRowIsSet(boolean value) {
15234       if (!value) {
15235         this.row = null;
15236       }
15237     }
15238 
15239     public int getColumnsSize() {
15240       return (this.columns == null) ? 0 : this.columns.size();
15241     }
15242 
15243     public java.util.Iterator<byte[]> getColumnsIterator() {
15244       return (this.columns == null) ? null : this.columns.iterator();
15245     }
15246 
15247     public void addToColumns(byte[] elem) {
15248       if (this.columns == null) {
15249         this.columns = new ArrayList<byte[]>();
15250       }
15251       this.columns.add(elem);
15252     }
15253 
15254     /**
15255      * List of columns to return, null for all columns
15256      */
15257     public List<byte[]> getColumns() {
15258       return this.columns;
15259     }
15260 
15261     /**
15262      * List of columns to return, null for all columns
15263      */
15264     public getRowWithColumnsTs_args setColumns(List<byte[]> columns) {
15265       this.columns = columns;
15266       return this;
15267     }
15268 
15269     public void unsetColumns() {
15270       this.columns = null;
15271     }
15272 
15273     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
15274     public boolean isSetColumns() {
15275       return this.columns != null;
15276     }
15277 
15278     public void setColumnsIsSet(boolean value) {
15279       if (!value) {
15280         this.columns = null;
15281       }
15282     }
15283 
15284     public long getTimestamp() {
15285       return this.timestamp;
15286     }
15287 
15288     public getRowWithColumnsTs_args setTimestamp(long timestamp) {
15289       this.timestamp = timestamp;
15290       setTimestampIsSet(true);
15291       return this;
15292     }
15293 
15294     public void unsetTimestamp() {
15295       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
15296     }
15297 
15298     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
15299     public boolean isSetTimestamp() {
15300       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
15301     }
15302 
15303     public void setTimestampIsSet(boolean value) {
15304       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
15305     }
15306 
15307     public void setFieldValue(_Fields field, Object value) {
15308       switch (field) {
15309       case TABLE_NAME:
15310         if (value == null) {
15311           unsetTableName();
15312         } else {
15313           setTableName((byte[])value);
15314         }
15315         break;
15316 
15317       case ROW:
15318         if (value == null) {
15319           unsetRow();
15320         } else {
15321           setRow((byte[])value);
15322         }
15323         break;
15324 
15325       case COLUMNS:
15326         if (value == null) {
15327           unsetColumns();
15328         } else {
15329           setColumns((List<byte[]>)value);
15330         }
15331         break;
15332 
15333       case TIMESTAMP:
15334         if (value == null) {
15335           unsetTimestamp();
15336         } else {
15337           setTimestamp((Long)value);
15338         }
15339         break;
15340 
15341       }
15342     }
15343 
15344     public void setFieldValue(int fieldID, Object value) {
15345       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
15346     }
15347 
15348     public Object getFieldValue(_Fields field) {
15349       switch (field) {
15350       case TABLE_NAME:
15351         return getTableName();
15352 
15353       case ROW:
15354         return getRow();
15355 
15356       case COLUMNS:
15357         return getColumns();
15358 
15359       case TIMESTAMP:
15360         return new Long(getTimestamp());
15361 
15362       }
15363       throw new IllegalStateException();
15364     }
15365 
15366     public Object getFieldValue(int fieldId) {
15367       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
15368     }
15369 
15370     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
15371     public boolean isSet(_Fields field) {
15372       switch (field) {
15373       case TABLE_NAME:
15374         return isSetTableName();
15375       case ROW:
15376         return isSetRow();
15377       case COLUMNS:
15378         return isSetColumns();
15379       case TIMESTAMP:
15380         return isSetTimestamp();
15381       }
15382       throw new IllegalStateException();
15383     }
15384 
15385     public boolean isSet(int fieldID) {
15386       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
15387     }
15388 
15389     @Override
15390     public boolean equals(Object that) {
15391       if (that == null)
15392         return false;
15393       if (that instanceof getRowWithColumnsTs_args)
15394         return this.equals((getRowWithColumnsTs_args)that);
15395       return false;
15396     }
15397 
15398     public boolean equals(getRowWithColumnsTs_args that) {
15399       if (that == null)
15400         return false;
15401 
15402       boolean this_present_tableName = true && this.isSetTableName();
15403       boolean that_present_tableName = true && that.isSetTableName();
15404       if (this_present_tableName || that_present_tableName) {
15405         if (!(this_present_tableName && that_present_tableName))
15406           return false;
15407         if (!java.util.Arrays.equals(this.tableName, that.tableName))
15408           return false;
15409       }
15410 
15411       boolean this_present_row = true && this.isSetRow();
15412       boolean that_present_row = true && that.isSetRow();
15413       if (this_present_row || that_present_row) {
15414         if (!(this_present_row && that_present_row))
15415           return false;
15416         if (!java.util.Arrays.equals(this.row, that.row))
15417           return false;
15418       }
15419 
15420       boolean this_present_columns = true && this.isSetColumns();
15421       boolean that_present_columns = true && that.isSetColumns();
15422       if (this_present_columns || that_present_columns) {
15423         if (!(this_present_columns && that_present_columns))
15424           return false;
15425         if (!this.columns.equals(that.columns))
15426           return false;
15427       }
15428 
15429       boolean this_present_timestamp = true;
15430       boolean that_present_timestamp = true;
15431       if (this_present_timestamp || that_present_timestamp) {
15432         if (!(this_present_timestamp && that_present_timestamp))
15433           return false;
15434         if (this.timestamp != that.timestamp)
15435           return false;
15436       }
15437 
15438       return true;
15439     }
15440 
15441     @Override
15442     public int hashCode() {
15443       HashCodeBuilder builder = new HashCodeBuilder();
15444 
15445       boolean present_tableName = true && (isSetTableName());
15446       builder.append(present_tableName);
15447       if (present_tableName)
15448         builder.append(tableName);
15449 
15450       boolean present_row = true && (isSetRow());
15451       builder.append(present_row);
15452       if (present_row)
15453         builder.append(row);
15454 
15455       boolean present_columns = true && (isSetColumns());
15456       builder.append(present_columns);
15457       if (present_columns)
15458         builder.append(columns);
15459 
15460       boolean present_timestamp = true;
15461       builder.append(present_timestamp);
15462       if (present_timestamp)
15463         builder.append(timestamp);
15464 
15465       return builder.toHashCode();
15466     }
15467 
15468     public int compareTo(getRowWithColumnsTs_args other) {
15469       if (!getClass().equals(other.getClass())) {
15470         return getClass().getName().compareTo(other.getClass().getName());
15471       }
15472 
15473       int lastComparison = 0;
15474       getRowWithColumnsTs_args typedOther = (getRowWithColumnsTs_args)other;
15475 
15476       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
15477       if (lastComparison != 0) {
15478         return lastComparison;
15479       }
15480       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
15481       if (lastComparison != 0) {
15482         return lastComparison;
15483       }
15484       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
15485       if (lastComparison != 0) {
15486         return lastComparison;
15487       }
15488       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
15489       if (lastComparison != 0) {
15490         return lastComparison;
15491       }
15492       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
15493       if (lastComparison != 0) {
15494         return lastComparison;
15495       }
15496       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
15497       if (lastComparison != 0) {
15498         return lastComparison;
15499       }
15500       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
15501       if (lastComparison != 0) {
15502         return lastComparison;
15503       }
15504       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
15505       if (lastComparison != 0) {
15506         return lastComparison;
15507       }
15508       return 0;
15509     }
15510 
15511     public void read(TProtocol iprot) throws TException {
15512       TField field;
15513       iprot.readStructBegin();
15514       while (true)
15515       {
15516         field = iprot.readFieldBegin();
15517         if (field.type == TType.STOP) {
15518           break;
15519         }
15520         _Fields fieldId = _Fields.findByThriftId(field.id);
15521         if (fieldId == null) {
15522           TProtocolUtil.skip(iprot, field.type);
15523         } else {
15524           switch (fieldId) {
15525             case TABLE_NAME:
15526               if (field.type == TType.STRING) {
15527                 this.tableName = iprot.readBinary();
15528               } else {
15529                 TProtocolUtil.skip(iprot, field.type);
15530               }
15531               break;
15532             case ROW:
15533               if (field.type == TType.STRING) {
15534                 this.row = iprot.readBinary();
15535               } else {
15536                 TProtocolUtil.skip(iprot, field.type);
15537               }
15538               break;
15539             case COLUMNS:
15540               if (field.type == TType.LIST) {
15541                 {
15542                   TList _list54 = iprot.readListBegin();
15543                   this.columns = new ArrayList<byte[]>(_list54.size);
15544                   for (int _i55 = 0; _i55 < _list54.size; ++_i55)
15545                   {
15546                     byte[] _elem56;
15547                     _elem56 = iprot.readBinary();
15548                     this.columns.add(_elem56);
15549                   }
15550                   iprot.readListEnd();
15551                 }
15552               } else {
15553                 TProtocolUtil.skip(iprot, field.type);
15554               }
15555               break;
15556             case TIMESTAMP:
15557               if (field.type == TType.I64) {
15558                 this.timestamp = iprot.readI64();
15559                 setTimestampIsSet(true);
15560               } else {
15561                 TProtocolUtil.skip(iprot, field.type);
15562               }
15563               break;
15564           }
15565           iprot.readFieldEnd();
15566         }
15567       }
15568       iprot.readStructEnd();
15569 
15570       // check for required fields of primitive type, which can't be checked in the validate method
15571       validate();
15572     }
15573 
15574     public void write(TProtocol oprot) throws TException {
15575       validate();
15576 
15577       oprot.writeStructBegin(STRUCT_DESC);
15578       if (this.tableName != null) {
15579         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
15580         oprot.writeBinary(this.tableName);
15581         oprot.writeFieldEnd();
15582       }
15583       if (this.row != null) {
15584         oprot.writeFieldBegin(ROW_FIELD_DESC);
15585         oprot.writeBinary(this.row);
15586         oprot.writeFieldEnd();
15587       }
15588       if (this.columns != null) {
15589         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
15590         {
15591           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
15592           for (byte[] _iter57 : this.columns)
15593           {
15594             oprot.writeBinary(_iter57);
15595           }
15596           oprot.writeListEnd();
15597         }
15598         oprot.writeFieldEnd();
15599       }
15600       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
15601       oprot.writeI64(this.timestamp);
15602       oprot.writeFieldEnd();
15603       oprot.writeFieldStop();
15604       oprot.writeStructEnd();
15605     }
15606 
15607     @Override
15608     public String toString() {
15609       StringBuilder sb = new StringBuilder("getRowWithColumnsTs_args(");
15610       boolean first = true;
15611 
15612       sb.append("tableName:");
15613       if (this.tableName == null) {
15614         sb.append("null");
15615       } else {
15616         sb.append(this.tableName);
15617       }
15618       first = false;
15619       if (!first) sb.append(", ");
15620       sb.append("row:");
15621       if (this.row == null) {
15622         sb.append("null");
15623       } else {
15624         sb.append(this.row);
15625       }
15626       first = false;
15627       if (!first) sb.append(", ");
15628       sb.append("columns:");
15629       if (this.columns == null) {
15630         sb.append("null");
15631       } else {
15632         sb.append(this.columns);
15633       }
15634       first = false;
15635       if (!first) sb.append(", ");
15636       sb.append("timestamp:");
15637       sb.append(this.timestamp);
15638       first = false;
15639       sb.append(")");
15640       return sb.toString();
15641     }
15642 
15643     public void validate() throws TException {
15644       // check for required fields
15645     }
15646 
15647   }
15648 
15649   public static class getRowWithColumnsTs_result implements TBase<getRowWithColumnsTs_result._Fields>, java.io.Serializable, Cloneable   {
15650     private static final TStruct STRUCT_DESC = new TStruct("getRowWithColumnsTs_result");
15651 
15652     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
15653     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
15654 
15655     public List<TRowResult> success;
15656     public IOError io;
15657 
15658     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
15659     public enum _Fields implements TFieldIdEnum {
15660       SUCCESS((short)0, "success"),
15661       IO((short)1, "io");
15662 
15663       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
15664       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
15665 
15666       static {
15667         for (_Fields field : EnumSet.allOf(_Fields.class)) {
15668           byId.put((int)field._thriftId, field);
15669           byName.put(field.getFieldName(), field);
15670         }
15671       }
15672 
15673       /**
15674        * Find the _Fields constant that matches fieldId, or null if its not found.
15675        */
15676       public static _Fields findByThriftId(int fieldId) {
15677         return byId.get(fieldId);
15678       }
15679 
15680       /**
15681        * Find the _Fields constant that matches fieldId, throwing an exception
15682        * if it is not found.
15683        */
15684       public static _Fields findByThriftIdOrThrow(int fieldId) {
15685         _Fields fields = findByThriftId(fieldId);
15686         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
15687         return fields;
15688       }
15689 
15690       /**
15691        * Find the _Fields constant that matches name, or null if its not found.
15692        */
15693       public static _Fields findByName(String name) {
15694         return byName.get(name);
15695       }
15696 
15697       private final short _thriftId;
15698       private final String _fieldName;
15699 
15700       _Fields(short thriftId, String fieldName) {
15701         _thriftId = thriftId;
15702         _fieldName = fieldName;
15703       }
15704 
15705       public short getThriftFieldId() {
15706         return _thriftId;
15707       }
15708 
15709       public String getFieldName() {
15710         return _fieldName;
15711       }
15712     }
15713 
15714     // isset id assignments
15715 
15716     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
15717       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
15718           new ListMetaData(TType.LIST,
15719               new StructMetaData(TType.STRUCT, TRowResult.class))));
15720       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
15721           new FieldValueMetaData(TType.STRUCT)));
15722     }});
15723 
15724     static {
15725       FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_result.class, metaDataMap);
15726     }
15727 
15728     public getRowWithColumnsTs_result() {
15729     }
15730 
15731     public getRowWithColumnsTs_result(
15732       List<TRowResult> success,
15733       IOError io)
15734     {
15735       this();
15736       this.success = success;
15737       this.io = io;
15738     }
15739 
15740     /**
15741      * Performs a deep copy on <i>other</i>.
15742      */
15743     public getRowWithColumnsTs_result(getRowWithColumnsTs_result other) {
15744       if (other.isSetSuccess()) {
15745         List<TRowResult> __this__success = new ArrayList<TRowResult>();
15746         for (TRowResult other_element : other.success) {
15747           __this__success.add(new TRowResult(other_element));
15748         }
15749         this.success = __this__success;
15750       }
15751       if (other.isSetIo()) {
15752         this.io = new IOError(other.io);
15753       }
15754     }
15755 
15756     public getRowWithColumnsTs_result deepCopy() {
15757       return new getRowWithColumnsTs_result(this);
15758     }
15759 
15760     @Deprecated
15761     public getRowWithColumnsTs_result clone() {
15762       return new getRowWithColumnsTs_result(this);
15763     }
15764 
15765     public int getSuccessSize() {
15766       return (this.success == null) ? 0 : this.success.size();
15767     }
15768 
15769     public java.util.Iterator<TRowResult> getSuccessIterator() {
15770       return (this.success == null) ? null : this.success.iterator();
15771     }
15772 
15773     public void addToSuccess(TRowResult elem) {
15774       if (this.success == null) {
15775         this.success = new ArrayList<TRowResult>();
15776       }
15777       this.success.add(elem);
15778     }
15779 
15780     public List<TRowResult> getSuccess() {
15781       return this.success;
15782     }
15783 
15784     public getRowWithColumnsTs_result setSuccess(List<TRowResult> success) {
15785       this.success = success;
15786       return this;
15787     }
15788 
15789     public void unsetSuccess() {
15790       this.success = null;
15791     }
15792 
15793     /** Returns true if field success is set (has been asigned a value) and false otherwise */
15794     public boolean isSetSuccess() {
15795       return this.success != null;
15796     }
15797 
15798     public void setSuccessIsSet(boolean value) {
15799       if (!value) {
15800         this.success = null;
15801       }
15802     }
15803 
15804     public IOError getIo() {
15805       return this.io;
15806     }
15807 
15808     public getRowWithColumnsTs_result setIo(IOError io) {
15809       this.io = io;
15810       return this;
15811     }
15812 
15813     public void unsetIo() {
15814       this.io = null;
15815     }
15816 
15817     /** Returns true if field io is set (has been asigned a value) and false otherwise */
15818     public boolean isSetIo() {
15819       return this.io != null;
15820     }
15821 
15822     public void setIoIsSet(boolean value) {
15823       if (!value) {
15824         this.io = null;
15825       }
15826     }
15827 
15828     public void setFieldValue(_Fields field, Object value) {
15829       switch (field) {
15830       case SUCCESS:
15831         if (value == null) {
15832           unsetSuccess();
15833         } else {
15834           setSuccess((List<TRowResult>)value);
15835         }
15836         break;
15837 
15838       case IO:
15839         if (value == null) {
15840           unsetIo();
15841         } else {
15842           setIo((IOError)value);
15843         }
15844         break;
15845 
15846       }
15847     }
15848 
15849     public void setFieldValue(int fieldID, Object value) {
15850       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
15851     }
15852 
15853     public Object getFieldValue(_Fields field) {
15854       switch (field) {
15855       case SUCCESS:
15856         return getSuccess();
15857 
15858       case IO:
15859         return getIo();
15860 
15861       }
15862       throw new IllegalStateException();
15863     }
15864 
15865     public Object getFieldValue(int fieldId) {
15866       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
15867     }
15868 
15869     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
15870     public boolean isSet(_Fields field) {
15871       switch (field) {
15872       case SUCCESS:
15873         return isSetSuccess();
15874       case IO:
15875         return isSetIo();
15876       }
15877       throw new IllegalStateException();
15878     }
15879 
15880     public boolean isSet(int fieldID) {
15881       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
15882     }
15883 
15884     @Override
15885     public boolean equals(Object that) {
15886       if (that == null)
15887         return false;
15888       if (that instanceof getRowWithColumnsTs_result)
15889         return this.equals((getRowWithColumnsTs_result)that);
15890       return false;
15891     }
15892 
15893     public boolean equals(getRowWithColumnsTs_result that) {
15894       if (that == null)
15895         return false;
15896 
15897       boolean this_present_success = true && this.isSetSuccess();
15898       boolean that_present_success = true && that.isSetSuccess();
15899       if (this_present_success || that_present_success) {
15900         if (!(this_present_success && that_present_success))
15901           return false;
15902         if (!this.success.equals(that.success))
15903           return false;
15904       }
15905 
15906       boolean this_present_io = true && this.isSetIo();
15907       boolean that_present_io = true && that.isSetIo();
15908       if (this_present_io || that_present_io) {
15909         if (!(this_present_io && that_present_io))
15910           return false;
15911         if (!this.io.equals(that.io))
15912           return false;
15913       }
15914 
15915       return true;
15916     }
15917 
15918     @Override
15919     public int hashCode() {
15920       HashCodeBuilder builder = new HashCodeBuilder();
15921 
15922       boolean present_success = true && (isSetSuccess());
15923       builder.append(present_success);
15924       if (present_success)
15925         builder.append(success);
15926 
15927       boolean present_io = true && (isSetIo());
15928       builder.append(present_io);
15929       if (present_io)
15930         builder.append(io);
15931 
15932       return builder.toHashCode();
15933     }
15934 
15935     public void read(TProtocol iprot) throws TException {
15936       TField field;
15937       iprot.readStructBegin();
15938       while (true)
15939       {
15940         field = iprot.readFieldBegin();
15941         if (field.type == TType.STOP) {
15942           break;
15943         }
15944         _Fields fieldId = _Fields.findByThriftId(field.id);
15945         if (fieldId == null) {
15946           TProtocolUtil.skip(iprot, field.type);
15947         } else {
15948           switch (fieldId) {
15949             case SUCCESS:
15950               if (field.type == TType.LIST) {
15951                 {
15952                   TList _list58 = iprot.readListBegin();
15953                   this.success = new ArrayList<TRowResult>(_list58.size);
15954                   for (int _i59 = 0; _i59 < _list58.size; ++_i59)
15955                   {
15956                     TRowResult _elem60;
15957                     _elem60 = new TRowResult();
15958                     _elem60.read(iprot);
15959                     this.success.add(_elem60);
15960                   }
15961                   iprot.readListEnd();
15962                 }
15963               } else {
15964                 TProtocolUtil.skip(iprot, field.type);
15965               }
15966               break;
15967             case IO:
15968               if (field.type == TType.STRUCT) {
15969                 this.io = new IOError();
15970                 this.io.read(iprot);
15971               } else {
15972                 TProtocolUtil.skip(iprot, field.type);
15973               }
15974               break;
15975           }
15976           iprot.readFieldEnd();
15977         }
15978       }
15979       iprot.readStructEnd();
15980 
15981       // check for required fields of primitive type, which can't be checked in the validate method
15982       validate();
15983     }
15984 
15985     public void write(TProtocol oprot) throws TException {
15986       oprot.writeStructBegin(STRUCT_DESC);
15987 
15988       if (this.isSetSuccess()) {
15989         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
15990         {
15991           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
15992           for (TRowResult _iter61 : this.success)
15993           {
15994             _iter61.write(oprot);
15995           }
15996           oprot.writeListEnd();
15997         }
15998         oprot.writeFieldEnd();
15999       } else if (this.isSetIo()) {
16000         oprot.writeFieldBegin(IO_FIELD_DESC);
16001         this.io.write(oprot);
16002         oprot.writeFieldEnd();
16003       }
16004       oprot.writeFieldStop();
16005       oprot.writeStructEnd();
16006     }
16007 
16008     @Override
16009     public String toString() {
16010       StringBuilder sb = new StringBuilder("getRowWithColumnsTs_result(");
16011       boolean first = true;
16012 
16013       sb.append("success:");
16014       if (this.success == null) {
16015         sb.append("null");
16016       } else {
16017         sb.append(this.success);
16018       }
16019       first = false;
16020       if (!first) sb.append(", ");
16021       sb.append("io:");
16022       if (this.io == null) {
16023         sb.append("null");
16024       } else {
16025         sb.append(this.io);
16026       }
16027       first = false;
16028       sb.append(")");
16029       return sb.toString();
16030     }
16031 
16032     public void validate() throws TException {
16033       // check for required fields
16034     }
16035 
16036   }
16037 
16038   public static class mutateRow_args implements TBase<mutateRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_args>   {
16039     private static final TStruct STRUCT_DESC = new TStruct("mutateRow_args");
16040 
16041     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
16042     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
16043     private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3);
16044 
16045     /**
16046      * name of table
16047      */
16048     public byte[] tableName;
16049     /**
16050      * row key
16051      */
16052     public byte[] row;
16053     /**
16054      * list of mutation commands
16055      */
16056     public List<Mutation> mutations;
16057 
16058     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
16059     public enum _Fields implements TFieldIdEnum {
16060       /**
16061        * name of table
16062        */
16063       TABLE_NAME((short)1, "tableName"),
16064       /**
16065        * row key
16066        */
16067       ROW((short)2, "row"),
16068       /**
16069        * list of mutation commands
16070        */
16071       MUTATIONS((short)3, "mutations");
16072 
16073       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
16074       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16075 
16076       static {
16077         for (_Fields field : EnumSet.allOf(_Fields.class)) {
16078           byId.put((int)field._thriftId, field);
16079           byName.put(field.getFieldName(), field);
16080         }
16081       }
16082 
16083       /**
16084        * Find the _Fields constant that matches fieldId, or null if its not found.
16085        */
16086       public static _Fields findByThriftId(int fieldId) {
16087         return byId.get(fieldId);
16088       }
16089 
16090       /**
16091        * Find the _Fields constant that matches fieldId, throwing an exception
16092        * if it is not found.
16093        */
16094       public static _Fields findByThriftIdOrThrow(int fieldId) {
16095         _Fields fields = findByThriftId(fieldId);
16096         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16097         return fields;
16098       }
16099 
16100       /**
16101        * Find the _Fields constant that matches name, or null if its not found.
16102        */
16103       public static _Fields findByName(String name) {
16104         return byName.get(name);
16105       }
16106 
16107       private final short _thriftId;
16108       private final String _fieldName;
16109 
16110       _Fields(short thriftId, String fieldName) {
16111         _thriftId = thriftId;
16112         _fieldName = fieldName;
16113       }
16114 
16115       public short getThriftFieldId() {
16116         return _thriftId;
16117       }
16118 
16119       public String getFieldName() {
16120         return _fieldName;
16121       }
16122     }
16123 
16124     // isset id assignments
16125 
16126     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16127       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
16128           new FieldValueMetaData(TType.STRING)));
16129       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
16130           new FieldValueMetaData(TType.STRING)));
16131       put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT,
16132           new ListMetaData(TType.LIST,
16133               new StructMetaData(TType.STRUCT, Mutation.class))));
16134     }});
16135 
16136     static {
16137       FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
16138     }
16139 
16140     public mutateRow_args() {
16141     }
16142 
16143     public mutateRow_args(
16144       byte[] tableName,
16145       byte[] row,
16146       List<Mutation> mutations)
16147     {
16148       this();
16149       this.tableName = tableName;
16150       this.row = row;
16151       this.mutations = mutations;
16152     }
16153 
16154     /**
16155      * Performs a deep copy on <i>other</i>.
16156      */
16157     public mutateRow_args(mutateRow_args other) {
16158       if (other.isSetTableName()) {
16159         this.tableName = other.tableName;
16160       }
16161       if (other.isSetRow()) {
16162         this.row = other.row;
16163       }
16164       if (other.isSetMutations()) {
16165         List<Mutation> __this__mutations = new ArrayList<Mutation>();
16166         for (Mutation other_element : other.mutations) {
16167           __this__mutations.add(new Mutation(other_element));
16168         }
16169         this.mutations = __this__mutations;
16170       }
16171     }
16172 
16173     public mutateRow_args deepCopy() {
16174       return new mutateRow_args(this);
16175     }
16176 
16177     @Deprecated
16178     public mutateRow_args clone() {
16179       return new mutateRow_args(this);
16180     }
16181 
16182     /**
16183      * name of table
16184      */
16185     public byte[] getTableName() {
16186       return this.tableName;
16187     }
16188 
16189     /**
16190      * name of table
16191      */
16192     public mutateRow_args setTableName(byte[] tableName) {
16193       this.tableName = tableName;
16194       return this;
16195     }
16196 
16197     public void unsetTableName() {
16198       this.tableName = null;
16199     }
16200 
16201     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
16202     public boolean isSetTableName() {
16203       return this.tableName != null;
16204     }
16205 
16206     public void setTableNameIsSet(boolean value) {
16207       if (!value) {
16208         this.tableName = null;
16209       }
16210     }
16211 
16212     /**
16213      * row key
16214      */
16215     public byte[] getRow() {
16216       return this.row;
16217     }
16218 
16219     /**
16220      * row key
16221      */
16222     public mutateRow_args setRow(byte[] row) {
16223       this.row = row;
16224       return this;
16225     }
16226 
16227     public void unsetRow() {
16228       this.row = null;
16229     }
16230 
16231     /** Returns true if field row is set (has been asigned a value) and false otherwise */
16232     public boolean isSetRow() {
16233       return this.row != null;
16234     }
16235 
16236     public void setRowIsSet(boolean value) {
16237       if (!value) {
16238         this.row = null;
16239       }
16240     }
16241 
16242     public int getMutationsSize() {
16243       return (this.mutations == null) ? 0 : this.mutations.size();
16244     }
16245 
16246     public java.util.Iterator<Mutation> getMutationsIterator() {
16247       return (this.mutations == null) ? null : this.mutations.iterator();
16248     }
16249 
16250     public void addToMutations(Mutation elem) {
16251       if (this.mutations == null) {
16252         this.mutations = new ArrayList<Mutation>();
16253       }
16254       this.mutations.add(elem);
16255     }
16256 
16257     /**
16258      * list of mutation commands
16259      */
16260     public List<Mutation> getMutations() {
16261       return this.mutations;
16262     }
16263 
16264     /**
16265      * list of mutation commands
16266      */
16267     public mutateRow_args setMutations(List<Mutation> mutations) {
16268       this.mutations = mutations;
16269       return this;
16270     }
16271 
16272     public void unsetMutations() {
16273       this.mutations = null;
16274     }
16275 
16276     /** Returns true if field mutations is set (has been asigned a value) and false otherwise */
16277     public boolean isSetMutations() {
16278       return this.mutations != null;
16279     }
16280 
16281     public void setMutationsIsSet(boolean value) {
16282       if (!value) {
16283         this.mutations = null;
16284       }
16285     }
16286 
16287     public void setFieldValue(_Fields field, Object value) {
16288       switch (field) {
16289       case TABLE_NAME:
16290         if (value == null) {
16291           unsetTableName();
16292         } else {
16293           setTableName((byte[])value);
16294         }
16295         break;
16296 
16297       case ROW:
16298         if (value == null) {
16299           unsetRow();
16300         } else {
16301           setRow((byte[])value);
16302         }
16303         break;
16304 
16305       case MUTATIONS:
16306         if (value == null) {
16307           unsetMutations();
16308         } else {
16309           setMutations((List<Mutation>)value);
16310         }
16311         break;
16312 
16313       }
16314     }
16315 
16316     public void setFieldValue(int fieldID, Object value) {
16317       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
16318     }
16319 
16320     public Object getFieldValue(_Fields field) {
16321       switch (field) {
16322       case TABLE_NAME:
16323         return getTableName();
16324 
16325       case ROW:
16326         return getRow();
16327 
16328       case MUTATIONS:
16329         return getMutations();
16330 
16331       }
16332       throw new IllegalStateException();
16333     }
16334 
16335     public Object getFieldValue(int fieldId) {
16336       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
16337     }
16338 
16339     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
16340     public boolean isSet(_Fields field) {
16341       switch (field) {
16342       case TABLE_NAME:
16343         return isSetTableName();
16344       case ROW:
16345         return isSetRow();
16346       case MUTATIONS:
16347         return isSetMutations();
16348       }
16349       throw new IllegalStateException();
16350     }
16351 
16352     public boolean isSet(int fieldID) {
16353       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
16354     }
16355 
16356     @Override
16357     public boolean equals(Object that) {
16358       if (that == null)
16359         return false;
16360       if (that instanceof mutateRow_args)
16361         return this.equals((mutateRow_args)that);
16362       return false;
16363     }
16364 
16365     public boolean equals(mutateRow_args that) {
16366       if (that == null)
16367         return false;
16368 
16369       boolean this_present_tableName = true && this.isSetTableName();
16370       boolean that_present_tableName = true && that.isSetTableName();
16371       if (this_present_tableName || that_present_tableName) {
16372         if (!(this_present_tableName && that_present_tableName))
16373           return false;
16374         if (!java.util.Arrays.equals(this.tableName, that.tableName))
16375           return false;
16376       }
16377 
16378       boolean this_present_row = true && this.isSetRow();
16379       boolean that_present_row = true && that.isSetRow();
16380       if (this_present_row || that_present_row) {
16381         if (!(this_present_row && that_present_row))
16382           return false;
16383         if (!java.util.Arrays.equals(this.row, that.row))
16384           return false;
16385       }
16386 
16387       boolean this_present_mutations = true && this.isSetMutations();
16388       boolean that_present_mutations = true && that.isSetMutations();
16389       if (this_present_mutations || that_present_mutations) {
16390         if (!(this_present_mutations && that_present_mutations))
16391           return false;
16392         if (!this.mutations.equals(that.mutations))
16393           return false;
16394       }
16395 
16396       return true;
16397     }
16398 
16399     @Override
16400     public int hashCode() {
16401       HashCodeBuilder builder = new HashCodeBuilder();
16402 
16403       boolean present_tableName = true && (isSetTableName());
16404       builder.append(present_tableName);
16405       if (present_tableName)
16406         builder.append(tableName);
16407 
16408       boolean present_row = true && (isSetRow());
16409       builder.append(present_row);
16410       if (present_row)
16411         builder.append(row);
16412 
16413       boolean present_mutations = true && (isSetMutations());
16414       builder.append(present_mutations);
16415       if (present_mutations)
16416         builder.append(mutations);
16417 
16418       return builder.toHashCode();
16419     }
16420 
16421     public int compareTo(mutateRow_args other) {
16422       if (!getClass().equals(other.getClass())) {
16423         return getClass().getName().compareTo(other.getClass().getName());
16424       }
16425 
16426       int lastComparison = 0;
16427       mutateRow_args typedOther = (mutateRow_args)other;
16428 
16429       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
16430       if (lastComparison != 0) {
16431         return lastComparison;
16432       }
16433       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
16434       if (lastComparison != 0) {
16435         return lastComparison;
16436       }
16437       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
16438       if (lastComparison != 0) {
16439         return lastComparison;
16440       }
16441       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
16442       if (lastComparison != 0) {
16443         return lastComparison;
16444       }
16445       lastComparison = Boolean.valueOf(isSetMutations()).compareTo(isSetMutations());
16446       if (lastComparison != 0) {
16447         return lastComparison;
16448       }
16449       lastComparison = TBaseHelper.compareTo(mutations, typedOther.mutations);
16450       if (lastComparison != 0) {
16451         return lastComparison;
16452       }
16453       return 0;
16454     }
16455 
16456     public void read(TProtocol iprot) throws TException {
16457       TField field;
16458       iprot.readStructBegin();
16459       while (true)
16460       {
16461         field = iprot.readFieldBegin();
16462         if (field.type == TType.STOP) {
16463           break;
16464         }
16465         _Fields fieldId = _Fields.findByThriftId(field.id);
16466         if (fieldId == null) {
16467           TProtocolUtil.skip(iprot, field.type);
16468         } else {
16469           switch (fieldId) {
16470             case TABLE_NAME:
16471               if (field.type == TType.STRING) {
16472                 this.tableName = iprot.readBinary();
16473               } else {
16474                 TProtocolUtil.skip(iprot, field.type);
16475               }
16476               break;
16477             case ROW:
16478               if (field.type == TType.STRING) {
16479                 this.row = iprot.readBinary();
16480               } else {
16481                 TProtocolUtil.skip(iprot, field.type);
16482               }
16483               break;
16484             case MUTATIONS:
16485               if (field.type == TType.LIST) {
16486                 {
16487                   TList _list62 = iprot.readListBegin();
16488                   this.mutations = new ArrayList<Mutation>(_list62.size);
16489                   for (int _i63 = 0; _i63 < _list62.size; ++_i63)
16490                   {
16491                     Mutation _elem64;
16492                     _elem64 = new Mutation();
16493                     _elem64.read(iprot);
16494                     this.mutations.add(_elem64);
16495                   }
16496                   iprot.readListEnd();
16497                 }
16498               } else {
16499                 TProtocolUtil.skip(iprot, field.type);
16500               }
16501               break;
16502           }
16503           iprot.readFieldEnd();
16504         }
16505       }
16506       iprot.readStructEnd();
16507 
16508       // check for required fields of primitive type, which can't be checked in the validate method
16509       validate();
16510     }
16511 
16512     public void write(TProtocol oprot) throws TException {
16513       validate();
16514 
16515       oprot.writeStructBegin(STRUCT_DESC);
16516       if (this.tableName != null) {
16517         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
16518         oprot.writeBinary(this.tableName);
16519         oprot.writeFieldEnd();
16520       }
16521       if (this.row != null) {
16522         oprot.writeFieldBegin(ROW_FIELD_DESC);
16523         oprot.writeBinary(this.row);
16524         oprot.writeFieldEnd();
16525       }
16526       if (this.mutations != null) {
16527         oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
16528         {
16529           oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size()));
16530           for (Mutation _iter65 : this.mutations)
16531           {
16532             _iter65.write(oprot);
16533           }
16534           oprot.writeListEnd();
16535         }
16536         oprot.writeFieldEnd();
16537       }
16538       oprot.writeFieldStop();
16539       oprot.writeStructEnd();
16540     }
16541 
16542     @Override
16543     public String toString() {
16544       StringBuilder sb = new StringBuilder("mutateRow_args(");
16545       boolean first = true;
16546 
16547       sb.append("tableName:");
16548       if (this.tableName == null) {
16549         sb.append("null");
16550       } else {
16551         sb.append(this.tableName);
16552       }
16553       first = false;
16554       if (!first) sb.append(", ");
16555       sb.append("row:");
16556       if (this.row == null) {
16557         sb.append("null");
16558       } else {
16559         sb.append(this.row);
16560       }
16561       first = false;
16562       if (!first) sb.append(", ");
16563       sb.append("mutations:");
16564       if (this.mutations == null) {
16565         sb.append("null");
16566       } else {
16567         sb.append(this.mutations);
16568       }
16569       first = false;
16570       sb.append(")");
16571       return sb.toString();
16572     }
16573 
16574     public void validate() throws TException {
16575       // check for required fields
16576     }
16577 
16578   }
16579 
16580   public static class mutateRow_result implements TBase<mutateRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_result>   {
16581     private static final TStruct STRUCT_DESC = new TStruct("mutateRow_result");
16582 
16583     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
16584     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
16585 
16586     public IOError io;
16587     public IllegalArgument ia;
16588 
16589     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
16590     public enum _Fields implements TFieldIdEnum {
16591       IO((short)1, "io"),
16592       IA((short)2, "ia");
16593 
16594       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
16595       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
16596 
16597       static {
16598         for (_Fields field : EnumSet.allOf(_Fields.class)) {
16599           byId.put((int)field._thriftId, field);
16600           byName.put(field.getFieldName(), field);
16601         }
16602       }
16603 
16604       /**
16605        * Find the _Fields constant that matches fieldId, or null if its not found.
16606        */
16607       public static _Fields findByThriftId(int fieldId) {
16608         return byId.get(fieldId);
16609       }
16610 
16611       /**
16612        * Find the _Fields constant that matches fieldId, throwing an exception
16613        * if it is not found.
16614        */
16615       public static _Fields findByThriftIdOrThrow(int fieldId) {
16616         _Fields fields = findByThriftId(fieldId);
16617         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
16618         return fields;
16619       }
16620 
16621       /**
16622        * Find the _Fields constant that matches name, or null if its not found.
16623        */
16624       public static _Fields findByName(String name) {
16625         return byName.get(name);
16626       }
16627 
16628       private final short _thriftId;
16629       private final String _fieldName;
16630 
16631       _Fields(short thriftId, String fieldName) {
16632         _thriftId = thriftId;
16633         _fieldName = fieldName;
16634       }
16635 
16636       public short getThriftFieldId() {
16637         return _thriftId;
16638       }
16639 
16640       public String getFieldName() {
16641         return _fieldName;
16642       }
16643     }
16644 
16645     // isset id assignments
16646 
16647     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
16648       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
16649           new FieldValueMetaData(TType.STRUCT)));
16650       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
16651           new FieldValueMetaData(TType.STRUCT)));
16652     }});
16653 
16654     static {
16655       FieldMetaData.addStructMetaDataMap(mutateRow_result.class, metaDataMap);
16656     }
16657 
16658     public mutateRow_result() {
16659     }
16660 
16661     public mutateRow_result(
16662       IOError io,
16663       IllegalArgument ia)
16664     {
16665       this();
16666       this.io = io;
16667       this.ia = ia;
16668     }
16669 
16670     /**
16671      * Performs a deep copy on <i>other</i>.
16672      */
16673     public mutateRow_result(mutateRow_result other) {
16674       if (other.isSetIo()) {
16675         this.io = new IOError(other.io);
16676       }
16677       if (other.isSetIa()) {
16678         this.ia = new IllegalArgument(other.ia);
16679       }
16680     }
16681 
16682     public mutateRow_result deepCopy() {
16683       return new mutateRow_result(this);
16684     }
16685 
16686     @Deprecated
16687     public mutateRow_result clone() {
16688       return new mutateRow_result(this);
16689     }
16690 
16691     public IOError getIo() {
16692       return this.io;
16693     }
16694 
16695     public mutateRow_result setIo(IOError io) {
16696       this.io = io;
16697       return this;
16698     }
16699 
16700     public void unsetIo() {
16701       this.io = null;
16702     }
16703 
16704     /** Returns true if field io is set (has been asigned a value) and false otherwise */
16705     public boolean isSetIo() {
16706       return this.io != null;
16707     }
16708 
16709     public void setIoIsSet(boolean value) {
16710       if (!value) {
16711         this.io = null;
16712       }
16713     }
16714 
16715     public IllegalArgument getIa() {
16716       return this.ia;
16717     }
16718 
16719     public mutateRow_result setIa(IllegalArgument ia) {
16720       this.ia = ia;
16721       return this;
16722     }
16723 
16724     public void unsetIa() {
16725       this.ia = null;
16726     }
16727 
16728     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
16729     public boolean isSetIa() {
16730       return this.ia != null;
16731     }
16732 
16733     public void setIaIsSet(boolean value) {
16734       if (!value) {
16735         this.ia = null;
16736       }
16737     }
16738 
16739     public void setFieldValue(_Fields field, Object value) {
16740       switch (field) {
16741       case IO:
16742         if (value == null) {
16743           unsetIo();
16744         } else {
16745           setIo((IOError)value);
16746         }
16747         break;
16748 
16749       case IA:
16750         if (value == null) {
16751           unsetIa();
16752         } else {
16753           setIa((IllegalArgument)value);
16754         }
16755         break;
16756 
16757       }
16758     }
16759 
16760     public void setFieldValue(int fieldID, Object value) {
16761       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
16762     }
16763 
16764     public Object getFieldValue(_Fields field) {
16765       switch (field) {
16766       case IO:
16767         return getIo();
16768 
16769       case IA:
16770         return getIa();
16771 
16772       }
16773       throw new IllegalStateException();
16774     }
16775 
16776     public Object getFieldValue(int fieldId) {
16777       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
16778     }
16779 
16780     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
16781     public boolean isSet(_Fields field) {
16782       switch (field) {
16783       case IO:
16784         return isSetIo();
16785       case IA:
16786         return isSetIa();
16787       }
16788       throw new IllegalStateException();
16789     }
16790 
16791     public boolean isSet(int fieldID) {
16792       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
16793     }
16794 
16795     @Override
16796     public boolean equals(Object that) {
16797       if (that == null)
16798         return false;
16799       if (that instanceof mutateRow_result)
16800         return this.equals((mutateRow_result)that);
16801       return false;
16802     }
16803 
16804     public boolean equals(mutateRow_result that) {
16805       if (that == null)
16806         return false;
16807 
16808       boolean this_present_io = true && this.isSetIo();
16809       boolean that_present_io = true && that.isSetIo();
16810       if (this_present_io || that_present_io) {
16811         if (!(this_present_io && that_present_io))
16812           return false;
16813         if (!this.io.equals(that.io))
16814           return false;
16815       }
16816 
16817       boolean this_present_ia = true && this.isSetIa();
16818       boolean that_present_ia = true && that.isSetIa();
16819       if (this_present_ia || that_present_ia) {
16820         if (!(this_present_ia && that_present_ia))
16821           return false;
16822         if (!this.ia.equals(that.ia))
16823           return false;
16824       }
16825 
16826       return true;
16827     }
16828 
16829     @Override
16830     public int hashCode() {
16831       HashCodeBuilder builder = new HashCodeBuilder();
16832 
16833       boolean present_io = true && (isSetIo());
16834       builder.append(present_io);
16835       if (present_io)
16836         builder.append(io);
16837 
16838       boolean present_ia = true && (isSetIa());
16839       builder.append(present_ia);
16840       if (present_ia)
16841         builder.append(ia);
16842 
16843       return builder.toHashCode();
16844     }
16845 
16846     public int compareTo(mutateRow_result other) {
16847       if (!getClass().equals(other.getClass())) {
16848         return getClass().getName().compareTo(other.getClass().getName());
16849       }
16850 
16851       int lastComparison = 0;
16852       mutateRow_result typedOther = (mutateRow_result)other;
16853 
16854       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
16855       if (lastComparison != 0) {
16856         return lastComparison;
16857       }
16858       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
16859       if (lastComparison != 0) {
16860         return lastComparison;
16861       }
16862       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
16863       if (lastComparison != 0) {
16864         return lastComparison;
16865       }
16866       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
16867       if (lastComparison != 0) {
16868         return lastComparison;
16869       }
16870       return 0;
16871     }
16872 
16873     public void read(TProtocol iprot) throws TException {
16874       TField field;
16875       iprot.readStructBegin();
16876       while (true)
16877       {
16878         field = iprot.readFieldBegin();
16879         if (field.type == TType.STOP) {
16880           break;
16881         }
16882         _Fields fieldId = _Fields.findByThriftId(field.id);
16883         if (fieldId == null) {
16884           TProtocolUtil.skip(iprot, field.type);
16885         } else {
16886           switch (fieldId) {
16887             case IO:
16888               if (field.type == TType.STRUCT) {
16889                 this.io = new IOError();
16890                 this.io.read(iprot);
16891               } else {
16892                 TProtocolUtil.skip(iprot, field.type);
16893               }
16894               break;
16895             case IA:
16896               if (field.type == TType.STRUCT) {
16897                 this.ia = new IllegalArgument();
16898                 this.ia.read(iprot);
16899               } else {
16900                 TProtocolUtil.skip(iprot, field.type);
16901               }
16902               break;
16903           }
16904           iprot.readFieldEnd();
16905         }
16906       }
16907       iprot.readStructEnd();
16908 
16909       // check for required fields of primitive type, which can't be checked in the validate method
16910       validate();
16911     }
16912 
16913     public void write(TProtocol oprot) throws TException {
16914       oprot.writeStructBegin(STRUCT_DESC);
16915 
16916       if (this.isSetIo()) {
16917         oprot.writeFieldBegin(IO_FIELD_DESC);
16918         this.io.write(oprot);
16919         oprot.writeFieldEnd();
16920       } else if (this.isSetIa()) {
16921         oprot.writeFieldBegin(IA_FIELD_DESC);
16922         this.ia.write(oprot);
16923         oprot.writeFieldEnd();
16924       }
16925       oprot.writeFieldStop();
16926       oprot.writeStructEnd();
16927     }
16928 
16929     @Override
16930     public String toString() {
16931       StringBuilder sb = new StringBuilder("mutateRow_result(");
16932       boolean first = true;
16933 
16934       sb.append("io:");
16935       if (this.io == null) {
16936         sb.append("null");
16937       } else {
16938         sb.append(this.io);
16939       }
16940       first = false;
16941       if (!first) sb.append(", ");
16942       sb.append("ia:");
16943       if (this.ia == null) {
16944         sb.append("null");
16945       } else {
16946         sb.append(this.ia);
16947       }
16948       first = false;
16949       sb.append(")");
16950       return sb.toString();
16951     }
16952 
16953     public void validate() throws TException {
16954       // check for required fields
16955     }
16956 
16957   }
16958 
16959   public static class mutateRowTs_args implements TBase<mutateRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_args>   {
16960     private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_args");
16961 
16962     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
16963     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
16964     private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3);
16965     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
16966 
16967     /**
16968      * name of table
16969      */
16970     public byte[] tableName;
16971     /**
16972      * row key
16973      */
16974     public byte[] row;
16975     /**
16976      * list of mutation commands
16977      */
16978     public List<Mutation> mutations;
16979     /**
16980      * timestamp
16981      */
16982     public long timestamp;
16983 
16984     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
16985     public enum _Fields implements TFieldIdEnum {
16986       /**
16987        * name of table
16988        */
16989       TABLE_NAME((short)1, "tableName"),
16990       /**
16991        * row key
16992        */
16993       ROW((short)2, "row"),
16994       /**
16995        * list of mutation commands
16996        */
16997       MUTATIONS((short)3, "mutations"),
16998       /**
16999        * timestamp
17000        */
17001       TIMESTAMP((short)4, "timestamp");
17002 
17003       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
17004       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
17005 
17006       static {
17007         for (_Fields field : EnumSet.allOf(_Fields.class)) {
17008           byId.put((int)field._thriftId, field);
17009           byName.put(field.getFieldName(), field);
17010         }
17011       }
17012 
17013       /**
17014        * Find the _Fields constant that matches fieldId, or null if its not found.
17015        */
17016       public static _Fields findByThriftId(int fieldId) {
17017         return byId.get(fieldId);
17018       }
17019 
17020       /**
17021        * Find the _Fields constant that matches fieldId, throwing an exception
17022        * if it is not found.
17023        */
17024       public static _Fields findByThriftIdOrThrow(int fieldId) {
17025         _Fields fields = findByThriftId(fieldId);
17026         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
17027         return fields;
17028       }
17029 
17030       /**
17031        * Find the _Fields constant that matches name, or null if its not found.
17032        */
17033       public static _Fields findByName(String name) {
17034         return byName.get(name);
17035       }
17036 
17037       private final short _thriftId;
17038       private final String _fieldName;
17039 
17040       _Fields(short thriftId, String fieldName) {
17041         _thriftId = thriftId;
17042         _fieldName = fieldName;
17043       }
17044 
17045       public short getThriftFieldId() {
17046         return _thriftId;
17047       }
17048 
17049       public String getFieldName() {
17050         return _fieldName;
17051       }
17052     }
17053 
17054     // isset id assignments
17055     private static final int __TIMESTAMP_ISSET_ID = 0;
17056     private BitSet __isset_bit_vector = new BitSet(1);
17057 
17058     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
17059       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
17060           new FieldValueMetaData(TType.STRING)));
17061       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
17062           new FieldValueMetaData(TType.STRING)));
17063       put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT,
17064           new ListMetaData(TType.LIST,
17065               new StructMetaData(TType.STRUCT, Mutation.class))));
17066       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
17067           new FieldValueMetaData(TType.I64)));
17068     }});
17069 
17070     static {
17071       FieldMetaData.addStructMetaDataMap(mutateRowTs_args.class, metaDataMap);
17072     }
17073 
17074     public mutateRowTs_args() {
17075     }
17076 
17077     public mutateRowTs_args(
17078       byte[] tableName,
17079       byte[] row,
17080       List<Mutation> mutations,
17081       long timestamp)
17082     {
17083       this();
17084       this.tableName = tableName;
17085       this.row = row;
17086       this.mutations = mutations;
17087       this.timestamp = timestamp;
17088       setTimestampIsSet(true);
17089     }
17090 
17091     /**
17092      * Performs a deep copy on <i>other</i>.
17093      */
17094     public mutateRowTs_args(mutateRowTs_args other) {
17095       __isset_bit_vector.clear();
17096       __isset_bit_vector.or(other.__isset_bit_vector);
17097       if (other.isSetTableName()) {
17098         this.tableName = other.tableName;
17099       }
17100       if (other.isSetRow()) {
17101         this.row = other.row;
17102       }
17103       if (other.isSetMutations()) {
17104         List<Mutation> __this__mutations = new ArrayList<Mutation>();
17105         for (Mutation other_element : other.mutations) {
17106           __this__mutations.add(new Mutation(other_element));
17107         }
17108         this.mutations = __this__mutations;
17109       }
17110       this.timestamp = other.timestamp;
17111     }
17112 
17113     public mutateRowTs_args deepCopy() {
17114       return new mutateRowTs_args(this);
17115     }
17116 
17117     @Deprecated
17118     public mutateRowTs_args clone() {
17119       return new mutateRowTs_args(this);
17120     }
17121 
17122     /**
17123      * name of table
17124      */
17125     public byte[] getTableName() {
17126       return this.tableName;
17127     }
17128 
17129     /**
17130      * name of table
17131      */
17132     public mutateRowTs_args setTableName(byte[] tableName) {
17133       this.tableName = tableName;
17134       return this;
17135     }
17136 
17137     public void unsetTableName() {
17138       this.tableName = null;
17139     }
17140 
17141     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
17142     public boolean isSetTableName() {
17143       return this.tableName != null;
17144     }
17145 
17146     public void setTableNameIsSet(boolean value) {
17147       if (!value) {
17148         this.tableName = null;
17149       }
17150     }
17151 
17152     /**
17153      * row key
17154      */
17155     public byte[] getRow() {
17156       return this.row;
17157     }
17158 
17159     /**
17160      * row key
17161      */
17162     public mutateRowTs_args setRow(byte[] row) {
17163       this.row = row;
17164       return this;
17165     }
17166 
17167     public void unsetRow() {
17168       this.row = null;
17169     }
17170 
17171     /** Returns true if field row is set (has been asigned a value) and false otherwise */
17172     public boolean isSetRow() {
17173       return this.row != null;
17174     }
17175 
17176     public void setRowIsSet(boolean value) {
17177       if (!value) {
17178         this.row = null;
17179       }
17180     }
17181 
17182     public int getMutationsSize() {
17183       return (this.mutations == null) ? 0 : this.mutations.size();
17184     }
17185 
17186     public java.util.Iterator<Mutation> getMutationsIterator() {
17187       return (this.mutations == null) ? null : this.mutations.iterator();
17188     }
17189 
17190     public void addToMutations(Mutation elem) {
17191       if (this.mutations == null) {
17192         this.mutations = new ArrayList<Mutation>();
17193       }
17194       this.mutations.add(elem);
17195     }
17196 
17197     /**
17198      * list of mutation commands
17199      */
17200     public List<Mutation> getMutations() {
17201       return this.mutations;
17202     }
17203 
17204     /**
17205      * list of mutation commands
17206      */
17207     public mutateRowTs_args setMutations(List<Mutation> mutations) {
17208       this.mutations = mutations;
17209       return this;
17210     }
17211 
17212     public void unsetMutations() {
17213       this.mutations = null;
17214     }
17215 
17216     /** Returns true if field mutations is set (has been asigned a value) and false otherwise */
17217     public boolean isSetMutations() {
17218       return this.mutations != null;
17219     }
17220 
17221     public void setMutationsIsSet(boolean value) {
17222       if (!value) {
17223         this.mutations = null;
17224       }
17225     }
17226 
17227     /**
17228      * timestamp
17229      */
17230     public long getTimestamp() {
17231       return this.timestamp;
17232     }
17233 
17234     /**
17235      * timestamp
17236      */
17237     public mutateRowTs_args setTimestamp(long timestamp) {
17238       this.timestamp = timestamp;
17239       setTimestampIsSet(true);
17240       return this;
17241     }
17242 
17243     public void unsetTimestamp() {
17244       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
17245     }
17246 
17247     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
17248     public boolean isSetTimestamp() {
17249       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
17250     }
17251 
17252     public void setTimestampIsSet(boolean value) {
17253       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
17254     }
17255 
17256     public void setFieldValue(_Fields field, Object value) {
17257       switch (field) {
17258       case TABLE_NAME:
17259         if (value == null) {
17260           unsetTableName();
17261         } else {
17262           setTableName((byte[])value);
17263         }
17264         break;
17265 
17266       case ROW:
17267         if (value == null) {
17268           unsetRow();
17269         } else {
17270           setRow((byte[])value);
17271         }
17272         break;
17273 
17274       case MUTATIONS:
17275         if (value == null) {
17276           unsetMutations();
17277         } else {
17278           setMutations((List<Mutation>)value);
17279         }
17280         break;
17281 
17282       case TIMESTAMP:
17283         if (value == null) {
17284           unsetTimestamp();
17285         } else {
17286           setTimestamp((Long)value);
17287         }
17288         break;
17289 
17290       }
17291     }
17292 
17293     public void setFieldValue(int fieldID, Object value) {
17294       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17295     }
17296 
17297     public Object getFieldValue(_Fields field) {
17298       switch (field) {
17299       case TABLE_NAME:
17300         return getTableName();
17301 
17302       case ROW:
17303         return getRow();
17304 
17305       case MUTATIONS:
17306         return getMutations();
17307 
17308       case TIMESTAMP:
17309         return new Long(getTimestamp());
17310 
17311       }
17312       throw new IllegalStateException();
17313     }
17314 
17315     public Object getFieldValue(int fieldId) {
17316       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17317     }
17318 
17319     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
17320     public boolean isSet(_Fields field) {
17321       switch (field) {
17322       case TABLE_NAME:
17323         return isSetTableName();
17324       case ROW:
17325         return isSetRow();
17326       case MUTATIONS:
17327         return isSetMutations();
17328       case TIMESTAMP:
17329         return isSetTimestamp();
17330       }
17331       throw new IllegalStateException();
17332     }
17333 
17334     public boolean isSet(int fieldID) {
17335       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
17336     }
17337 
17338     @Override
17339     public boolean equals(Object that) {
17340       if (that == null)
17341         return false;
17342       if (that instanceof mutateRowTs_args)
17343         return this.equals((mutateRowTs_args)that);
17344       return false;
17345     }
17346 
17347     public boolean equals(mutateRowTs_args that) {
17348       if (that == null)
17349         return false;
17350 
17351       boolean this_present_tableName = true && this.isSetTableName();
17352       boolean that_present_tableName = true && that.isSetTableName();
17353       if (this_present_tableName || that_present_tableName) {
17354         if (!(this_present_tableName && that_present_tableName))
17355           return false;
17356         if (!java.util.Arrays.equals(this.tableName, that.tableName))
17357           return false;
17358       }
17359 
17360       boolean this_present_row = true && this.isSetRow();
17361       boolean that_present_row = true && that.isSetRow();
17362       if (this_present_row || that_present_row) {
17363         if (!(this_present_row && that_present_row))
17364           return false;
17365         if (!java.util.Arrays.equals(this.row, that.row))
17366           return false;
17367       }
17368 
17369       boolean this_present_mutations = true && this.isSetMutations();
17370       boolean that_present_mutations = true && that.isSetMutations();
17371       if (this_present_mutations || that_present_mutations) {
17372         if (!(this_present_mutations && that_present_mutations))
17373           return false;
17374         if (!this.mutations.equals(that.mutations))
17375           return false;
17376       }
17377 
17378       boolean this_present_timestamp = true;
17379       boolean that_present_timestamp = true;
17380       if (this_present_timestamp || that_present_timestamp) {
17381         if (!(this_present_timestamp && that_present_timestamp))
17382           return false;
17383         if (this.timestamp != that.timestamp)
17384           return false;
17385       }
17386 
17387       return true;
17388     }
17389 
17390     @Override
17391     public int hashCode() {
17392       HashCodeBuilder builder = new HashCodeBuilder();
17393 
17394       boolean present_tableName = true && (isSetTableName());
17395       builder.append(present_tableName);
17396       if (present_tableName)
17397         builder.append(tableName);
17398 
17399       boolean present_row = true && (isSetRow());
17400       builder.append(present_row);
17401       if (present_row)
17402         builder.append(row);
17403 
17404       boolean present_mutations = true && (isSetMutations());
17405       builder.append(present_mutations);
17406       if (present_mutations)
17407         builder.append(mutations);
17408 
17409       boolean present_timestamp = true;
17410       builder.append(present_timestamp);
17411       if (present_timestamp)
17412         builder.append(timestamp);
17413 
17414       return builder.toHashCode();
17415     }
17416 
17417     public int compareTo(mutateRowTs_args other) {
17418       if (!getClass().equals(other.getClass())) {
17419         return getClass().getName().compareTo(other.getClass().getName());
17420       }
17421 
17422       int lastComparison = 0;
17423       mutateRowTs_args typedOther = (mutateRowTs_args)other;
17424 
17425       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
17426       if (lastComparison != 0) {
17427         return lastComparison;
17428       }
17429       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
17430       if (lastComparison != 0) {
17431         return lastComparison;
17432       }
17433       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
17434       if (lastComparison != 0) {
17435         return lastComparison;
17436       }
17437       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
17438       if (lastComparison != 0) {
17439         return lastComparison;
17440       }
17441       lastComparison = Boolean.valueOf(isSetMutations()).compareTo(isSetMutations());
17442       if (lastComparison != 0) {
17443         return lastComparison;
17444       }
17445       lastComparison = TBaseHelper.compareTo(mutations, typedOther.mutations);
17446       if (lastComparison != 0) {
17447         return lastComparison;
17448       }
17449       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
17450       if (lastComparison != 0) {
17451         return lastComparison;
17452       }
17453       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
17454       if (lastComparison != 0) {
17455         return lastComparison;
17456       }
17457       return 0;
17458     }
17459 
17460     public void read(TProtocol iprot) throws TException {
17461       TField field;
17462       iprot.readStructBegin();
17463       while (true)
17464       {
17465         field = iprot.readFieldBegin();
17466         if (field.type == TType.STOP) {
17467           break;
17468         }
17469         _Fields fieldId = _Fields.findByThriftId(field.id);
17470         if (fieldId == null) {
17471           TProtocolUtil.skip(iprot, field.type);
17472         } else {
17473           switch (fieldId) {
17474             case TABLE_NAME:
17475               if (field.type == TType.STRING) {
17476                 this.tableName = iprot.readBinary();
17477               } else {
17478                 TProtocolUtil.skip(iprot, field.type);
17479               }
17480               break;
17481             case ROW:
17482               if (field.type == TType.STRING) {
17483                 this.row = iprot.readBinary();
17484               } else {
17485                 TProtocolUtil.skip(iprot, field.type);
17486               }
17487               break;
17488             case MUTATIONS:
17489               if (field.type == TType.LIST) {
17490                 {
17491                   TList _list66 = iprot.readListBegin();
17492                   this.mutations = new ArrayList<Mutation>(_list66.size);
17493                   for (int _i67 = 0; _i67 < _list66.size; ++_i67)
17494                   {
17495                     Mutation _elem68;
17496                     _elem68 = new Mutation();
17497                     _elem68.read(iprot);
17498                     this.mutations.add(_elem68);
17499                   }
17500                   iprot.readListEnd();
17501                 }
17502               } else {
17503                 TProtocolUtil.skip(iprot, field.type);
17504               }
17505               break;
17506             case TIMESTAMP:
17507               if (field.type == TType.I64) {
17508                 this.timestamp = iprot.readI64();
17509                 setTimestampIsSet(true);
17510               } else {
17511                 TProtocolUtil.skip(iprot, field.type);
17512               }
17513               break;
17514           }
17515           iprot.readFieldEnd();
17516         }
17517       }
17518       iprot.readStructEnd();
17519 
17520       // check for required fields of primitive type, which can't be checked in the validate method
17521       validate();
17522     }
17523 
17524     public void write(TProtocol oprot) throws TException {
17525       validate();
17526 
17527       oprot.writeStructBegin(STRUCT_DESC);
17528       if (this.tableName != null) {
17529         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
17530         oprot.writeBinary(this.tableName);
17531         oprot.writeFieldEnd();
17532       }
17533       if (this.row != null) {
17534         oprot.writeFieldBegin(ROW_FIELD_DESC);
17535         oprot.writeBinary(this.row);
17536         oprot.writeFieldEnd();
17537       }
17538       if (this.mutations != null) {
17539         oprot.writeFieldBegin(MUTATIONS_FIELD_DESC);
17540         {
17541           oprot.writeListBegin(new TList(TType.STRUCT, this.mutations.size()));
17542           for (Mutation _iter69 : this.mutations)
17543           {
17544             _iter69.write(oprot);
17545           }
17546           oprot.writeListEnd();
17547         }
17548         oprot.writeFieldEnd();
17549       }
17550       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
17551       oprot.writeI64(this.timestamp);
17552       oprot.writeFieldEnd();
17553       oprot.writeFieldStop();
17554       oprot.writeStructEnd();
17555     }
17556 
17557     @Override
17558     public String toString() {
17559       StringBuilder sb = new StringBuilder("mutateRowTs_args(");
17560       boolean first = true;
17561 
17562       sb.append("tableName:");
17563       if (this.tableName == null) {
17564         sb.append("null");
17565       } else {
17566         sb.append(this.tableName);
17567       }
17568       first = false;
17569       if (!first) sb.append(", ");
17570       sb.append("row:");
17571       if (this.row == null) {
17572         sb.append("null");
17573       } else {
17574         sb.append(this.row);
17575       }
17576       first = false;
17577       if (!first) sb.append(", ");
17578       sb.append("mutations:");
17579       if (this.mutations == null) {
17580         sb.append("null");
17581       } else {
17582         sb.append(this.mutations);
17583       }
17584       first = false;
17585       if (!first) sb.append(", ");
17586       sb.append("timestamp:");
17587       sb.append(this.timestamp);
17588       first = false;
17589       sb.append(")");
17590       return sb.toString();
17591     }
17592 
17593     public void validate() throws TException {
17594       // check for required fields
17595     }
17596 
17597   }
17598 
17599   public static class mutateRowTs_result implements TBase<mutateRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowTs_result>   {
17600     private static final TStruct STRUCT_DESC = new TStruct("mutateRowTs_result");
17601 
17602     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
17603     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
17604 
17605     public IOError io;
17606     public IllegalArgument ia;
17607 
17608     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
17609     public enum _Fields implements TFieldIdEnum {
17610       IO((short)1, "io"),
17611       IA((short)2, "ia");
17612 
17613       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
17614       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
17615 
17616       static {
17617         for (_Fields field : EnumSet.allOf(_Fields.class)) {
17618           byId.put((int)field._thriftId, field);
17619           byName.put(field.getFieldName(), field);
17620         }
17621       }
17622 
17623       /**
17624        * Find the _Fields constant that matches fieldId, or null if its not found.
17625        */
17626       public static _Fields findByThriftId(int fieldId) {
17627         return byId.get(fieldId);
17628       }
17629 
17630       /**
17631        * Find the _Fields constant that matches fieldId, throwing an exception
17632        * if it is not found.
17633        */
17634       public static _Fields findByThriftIdOrThrow(int fieldId) {
17635         _Fields fields = findByThriftId(fieldId);
17636         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
17637         return fields;
17638       }
17639 
17640       /**
17641        * Find the _Fields constant that matches name, or null if its not found.
17642        */
17643       public static _Fields findByName(String name) {
17644         return byName.get(name);
17645       }
17646 
17647       private final short _thriftId;
17648       private final String _fieldName;
17649 
17650       _Fields(short thriftId, String fieldName) {
17651         _thriftId = thriftId;
17652         _fieldName = fieldName;
17653       }
17654 
17655       public short getThriftFieldId() {
17656         return _thriftId;
17657       }
17658 
17659       public String getFieldName() {
17660         return _fieldName;
17661       }
17662     }
17663 
17664     // isset id assignments
17665 
17666     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
17667       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
17668           new FieldValueMetaData(TType.STRUCT)));
17669       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
17670           new FieldValueMetaData(TType.STRUCT)));
17671     }});
17672 
17673     static {
17674       FieldMetaData.addStructMetaDataMap(mutateRowTs_result.class, metaDataMap);
17675     }
17676 
17677     public mutateRowTs_result() {
17678     }
17679 
17680     public mutateRowTs_result(
17681       IOError io,
17682       IllegalArgument ia)
17683     {
17684       this();
17685       this.io = io;
17686       this.ia = ia;
17687     }
17688 
17689     /**
17690      * Performs a deep copy on <i>other</i>.
17691      */
17692     public mutateRowTs_result(mutateRowTs_result other) {
17693       if (other.isSetIo()) {
17694         this.io = new IOError(other.io);
17695       }
17696       if (other.isSetIa()) {
17697         this.ia = new IllegalArgument(other.ia);
17698       }
17699     }
17700 
17701     public mutateRowTs_result deepCopy() {
17702       return new mutateRowTs_result(this);
17703     }
17704 
17705     @Deprecated
17706     public mutateRowTs_result clone() {
17707       return new mutateRowTs_result(this);
17708     }
17709 
17710     public IOError getIo() {
17711       return this.io;
17712     }
17713 
17714     public mutateRowTs_result setIo(IOError io) {
17715       this.io = io;
17716       return this;
17717     }
17718 
17719     public void unsetIo() {
17720       this.io = null;
17721     }
17722 
17723     /** Returns true if field io is set (has been asigned a value) and false otherwise */
17724     public boolean isSetIo() {
17725       return this.io != null;
17726     }
17727 
17728     public void setIoIsSet(boolean value) {
17729       if (!value) {
17730         this.io = null;
17731       }
17732     }
17733 
17734     public IllegalArgument getIa() {
17735       return this.ia;
17736     }
17737 
17738     public mutateRowTs_result setIa(IllegalArgument ia) {
17739       this.ia = ia;
17740       return this;
17741     }
17742 
17743     public void unsetIa() {
17744       this.ia = null;
17745     }
17746 
17747     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
17748     public boolean isSetIa() {
17749       return this.ia != null;
17750     }
17751 
17752     public void setIaIsSet(boolean value) {
17753       if (!value) {
17754         this.ia = null;
17755       }
17756     }
17757 
17758     public void setFieldValue(_Fields field, Object value) {
17759       switch (field) {
17760       case IO:
17761         if (value == null) {
17762           unsetIo();
17763         } else {
17764           setIo((IOError)value);
17765         }
17766         break;
17767 
17768       case IA:
17769         if (value == null) {
17770           unsetIa();
17771         } else {
17772           setIa((IllegalArgument)value);
17773         }
17774         break;
17775 
17776       }
17777     }
17778 
17779     public void setFieldValue(int fieldID, Object value) {
17780       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
17781     }
17782 
17783     public Object getFieldValue(_Fields field) {
17784       switch (field) {
17785       case IO:
17786         return getIo();
17787 
17788       case IA:
17789         return getIa();
17790 
17791       }
17792       throw new IllegalStateException();
17793     }
17794 
17795     public Object getFieldValue(int fieldId) {
17796       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
17797     }
17798 
17799     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
17800     public boolean isSet(_Fields field) {
17801       switch (field) {
17802       case IO:
17803         return isSetIo();
17804       case IA:
17805         return isSetIa();
17806       }
17807       throw new IllegalStateException();
17808     }
17809 
17810     public boolean isSet(int fieldID) {
17811       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
17812     }
17813 
17814     @Override
17815     public boolean equals(Object that) {
17816       if (that == null)
17817         return false;
17818       if (that instanceof mutateRowTs_result)
17819         return this.equals((mutateRowTs_result)that);
17820       return false;
17821     }
17822 
17823     public boolean equals(mutateRowTs_result that) {
17824       if (that == null)
17825         return false;
17826 
17827       boolean this_present_io = true && this.isSetIo();
17828       boolean that_present_io = true && that.isSetIo();
17829       if (this_present_io || that_present_io) {
17830         if (!(this_present_io && that_present_io))
17831           return false;
17832         if (!this.io.equals(that.io))
17833           return false;
17834       }
17835 
17836       boolean this_present_ia = true && this.isSetIa();
17837       boolean that_present_ia = true && that.isSetIa();
17838       if (this_present_ia || that_present_ia) {
17839         if (!(this_present_ia && that_present_ia))
17840           return false;
17841         if (!this.ia.equals(that.ia))
17842           return false;
17843       }
17844 
17845       return true;
17846     }
17847 
17848     @Override
17849     public int hashCode() {
17850       HashCodeBuilder builder = new HashCodeBuilder();
17851 
17852       boolean present_io = true && (isSetIo());
17853       builder.append(present_io);
17854       if (present_io)
17855         builder.append(io);
17856 
17857       boolean present_ia = true && (isSetIa());
17858       builder.append(present_ia);
17859       if (present_ia)
17860         builder.append(ia);
17861 
17862       return builder.toHashCode();
17863     }
17864 
17865     public int compareTo(mutateRowTs_result other) {
17866       if (!getClass().equals(other.getClass())) {
17867         return getClass().getName().compareTo(other.getClass().getName());
17868       }
17869 
17870       int lastComparison = 0;
17871       mutateRowTs_result typedOther = (mutateRowTs_result)other;
17872 
17873       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
17874       if (lastComparison != 0) {
17875         return lastComparison;
17876       }
17877       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
17878       if (lastComparison != 0) {
17879         return lastComparison;
17880       }
17881       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
17882       if (lastComparison != 0) {
17883         return lastComparison;
17884       }
17885       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
17886       if (lastComparison != 0) {
17887         return lastComparison;
17888       }
17889       return 0;
17890     }
17891 
17892     public void read(TProtocol iprot) throws TException {
17893       TField field;
17894       iprot.readStructBegin();
17895       while (true)
17896       {
17897         field = iprot.readFieldBegin();
17898         if (field.type == TType.STOP) {
17899           break;
17900         }
17901         _Fields fieldId = _Fields.findByThriftId(field.id);
17902         if (fieldId == null) {
17903           TProtocolUtil.skip(iprot, field.type);
17904         } else {
17905           switch (fieldId) {
17906             case IO:
17907               if (field.type == TType.STRUCT) {
17908                 this.io = new IOError();
17909                 this.io.read(iprot);
17910               } else {
17911                 TProtocolUtil.skip(iprot, field.type);
17912               }
17913               break;
17914             case IA:
17915               if (field.type == TType.STRUCT) {
17916                 this.ia = new IllegalArgument();
17917                 this.ia.read(iprot);
17918               } else {
17919                 TProtocolUtil.skip(iprot, field.type);
17920               }
17921               break;
17922           }
17923           iprot.readFieldEnd();
17924         }
17925       }
17926       iprot.readStructEnd();
17927 
17928       // check for required fields of primitive type, which can't be checked in the validate method
17929       validate();
17930     }
17931 
17932     public void write(TProtocol oprot) throws TException {
17933       oprot.writeStructBegin(STRUCT_DESC);
17934 
17935       if (this.isSetIo()) {
17936         oprot.writeFieldBegin(IO_FIELD_DESC);
17937         this.io.write(oprot);
17938         oprot.writeFieldEnd();
17939       } else if (this.isSetIa()) {
17940         oprot.writeFieldBegin(IA_FIELD_DESC);
17941         this.ia.write(oprot);
17942         oprot.writeFieldEnd();
17943       }
17944       oprot.writeFieldStop();
17945       oprot.writeStructEnd();
17946     }
17947 
17948     @Override
17949     public String toString() {
17950       StringBuilder sb = new StringBuilder("mutateRowTs_result(");
17951       boolean first = true;
17952 
17953       sb.append("io:");
17954       if (this.io == null) {
17955         sb.append("null");
17956       } else {
17957         sb.append(this.io);
17958       }
17959       first = false;
17960       if (!first) sb.append(", ");
17961       sb.append("ia:");
17962       if (this.ia == null) {
17963         sb.append("null");
17964       } else {
17965         sb.append(this.ia);
17966       }
17967       first = false;
17968       sb.append(")");
17969       return sb.toString();
17970     }
17971 
17972     public void validate() throws TException {
17973       // check for required fields
17974     }
17975 
17976   }
17977 
17978   public static class mutateRows_args implements TBase<mutateRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_args>   {
17979     private static final TStruct STRUCT_DESC = new TStruct("mutateRows_args");
17980 
17981     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
17982     private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2);
17983 
17984     /**
17985      * name of table
17986      */
17987     public byte[] tableName;
17988     /**
17989      * list of row batches
17990      */
17991     public List<BatchMutation> rowBatches;
17992 
17993     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
17994     public enum _Fields implements TFieldIdEnum {
17995       /**
17996        * name of table
17997        */
17998       TABLE_NAME((short)1, "tableName"),
17999       /**
18000        * list of row batches
18001        */
18002       ROW_BATCHES((short)2, "rowBatches");
18003 
18004       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18005       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18006 
18007       static {
18008         for (_Fields field : EnumSet.allOf(_Fields.class)) {
18009           byId.put((int)field._thriftId, field);
18010           byName.put(field.getFieldName(), field);
18011         }
18012       }
18013 
18014       /**
18015        * Find the _Fields constant that matches fieldId, or null if its not found.
18016        */
18017       public static _Fields findByThriftId(int fieldId) {
18018         return byId.get(fieldId);
18019       }
18020 
18021       /**
18022        * Find the _Fields constant that matches fieldId, throwing an exception
18023        * if it is not found.
18024        */
18025       public static _Fields findByThriftIdOrThrow(int fieldId) {
18026         _Fields fields = findByThriftId(fieldId);
18027         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18028         return fields;
18029       }
18030 
18031       /**
18032        * Find the _Fields constant that matches name, or null if its not found.
18033        */
18034       public static _Fields findByName(String name) {
18035         return byName.get(name);
18036       }
18037 
18038       private final short _thriftId;
18039       private final String _fieldName;
18040 
18041       _Fields(short thriftId, String fieldName) {
18042         _thriftId = thriftId;
18043         _fieldName = fieldName;
18044       }
18045 
18046       public short getThriftFieldId() {
18047         return _thriftId;
18048       }
18049 
18050       public String getFieldName() {
18051         return _fieldName;
18052       }
18053     }
18054 
18055     // isset id assignments
18056 
18057     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18058       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
18059           new FieldValueMetaData(TType.STRING)));
18060       put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT,
18061           new ListMetaData(TType.LIST,
18062               new StructMetaData(TType.STRUCT, BatchMutation.class))));
18063     }});
18064 
18065     static {
18066       FieldMetaData.addStructMetaDataMap(mutateRows_args.class, metaDataMap);
18067     }
18068 
18069     public mutateRows_args() {
18070     }
18071 
18072     public mutateRows_args(
18073       byte[] tableName,
18074       List<BatchMutation> rowBatches)
18075     {
18076       this();
18077       this.tableName = tableName;
18078       this.rowBatches = rowBatches;
18079     }
18080 
18081     /**
18082      * Performs a deep copy on <i>other</i>.
18083      */
18084     public mutateRows_args(mutateRows_args other) {
18085       if (other.isSetTableName()) {
18086         this.tableName = other.tableName;
18087       }
18088       if (other.isSetRowBatches()) {
18089         List<BatchMutation> __this__rowBatches = new ArrayList<BatchMutation>();
18090         for (BatchMutation other_element : other.rowBatches) {
18091           __this__rowBatches.add(new BatchMutation(other_element));
18092         }
18093         this.rowBatches = __this__rowBatches;
18094       }
18095     }
18096 
18097     public mutateRows_args deepCopy() {
18098       return new mutateRows_args(this);
18099     }
18100 
18101     @Deprecated
18102     public mutateRows_args clone() {
18103       return new mutateRows_args(this);
18104     }
18105 
18106     /**
18107      * name of table
18108      */
18109     public byte[] getTableName() {
18110       return this.tableName;
18111     }
18112 
18113     /**
18114      * name of table
18115      */
18116     public mutateRows_args setTableName(byte[] tableName) {
18117       this.tableName = tableName;
18118       return this;
18119     }
18120 
18121     public void unsetTableName() {
18122       this.tableName = null;
18123     }
18124 
18125     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
18126     public boolean isSetTableName() {
18127       return this.tableName != null;
18128     }
18129 
18130     public void setTableNameIsSet(boolean value) {
18131       if (!value) {
18132         this.tableName = null;
18133       }
18134     }
18135 
18136     public int getRowBatchesSize() {
18137       return (this.rowBatches == null) ? 0 : this.rowBatches.size();
18138     }
18139 
18140     public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
18141       return (this.rowBatches == null) ? null : this.rowBatches.iterator();
18142     }
18143 
18144     public void addToRowBatches(BatchMutation elem) {
18145       if (this.rowBatches == null) {
18146         this.rowBatches = new ArrayList<BatchMutation>();
18147       }
18148       this.rowBatches.add(elem);
18149     }
18150 
18151     /**
18152      * list of row batches
18153      */
18154     public List<BatchMutation> getRowBatches() {
18155       return this.rowBatches;
18156     }
18157 
18158     /**
18159      * list of row batches
18160      */
18161     public mutateRows_args setRowBatches(List<BatchMutation> rowBatches) {
18162       this.rowBatches = rowBatches;
18163       return this;
18164     }
18165 
18166     public void unsetRowBatches() {
18167       this.rowBatches = null;
18168     }
18169 
18170     /** Returns true if field rowBatches is set (has been asigned a value) and false otherwise */
18171     public boolean isSetRowBatches() {
18172       return this.rowBatches != null;
18173     }
18174 
18175     public void setRowBatchesIsSet(boolean value) {
18176       if (!value) {
18177         this.rowBatches = null;
18178       }
18179     }
18180 
18181     public void setFieldValue(_Fields field, Object value) {
18182       switch (field) {
18183       case TABLE_NAME:
18184         if (value == null) {
18185           unsetTableName();
18186         } else {
18187           setTableName((byte[])value);
18188         }
18189         break;
18190 
18191       case ROW_BATCHES:
18192         if (value == null) {
18193           unsetRowBatches();
18194         } else {
18195           setRowBatches((List<BatchMutation>)value);
18196         }
18197         break;
18198 
18199       }
18200     }
18201 
18202     public void setFieldValue(int fieldID, Object value) {
18203       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
18204     }
18205 
18206     public Object getFieldValue(_Fields field) {
18207       switch (field) {
18208       case TABLE_NAME:
18209         return getTableName();
18210 
18211       case ROW_BATCHES:
18212         return getRowBatches();
18213 
18214       }
18215       throw new IllegalStateException();
18216     }
18217 
18218     public Object getFieldValue(int fieldId) {
18219       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
18220     }
18221 
18222     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
18223     public boolean isSet(_Fields field) {
18224       switch (field) {
18225       case TABLE_NAME:
18226         return isSetTableName();
18227       case ROW_BATCHES:
18228         return isSetRowBatches();
18229       }
18230       throw new IllegalStateException();
18231     }
18232 
18233     public boolean isSet(int fieldID) {
18234       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18235     }
18236 
18237     @Override
18238     public boolean equals(Object that) {
18239       if (that == null)
18240         return false;
18241       if (that instanceof mutateRows_args)
18242         return this.equals((mutateRows_args)that);
18243       return false;
18244     }
18245 
18246     public boolean equals(mutateRows_args that) {
18247       if (that == null)
18248         return false;
18249 
18250       boolean this_present_tableName = true && this.isSetTableName();
18251       boolean that_present_tableName = true && that.isSetTableName();
18252       if (this_present_tableName || that_present_tableName) {
18253         if (!(this_present_tableName && that_present_tableName))
18254           return false;
18255         if (!java.util.Arrays.equals(this.tableName, that.tableName))
18256           return false;
18257       }
18258 
18259       boolean this_present_rowBatches = true && this.isSetRowBatches();
18260       boolean that_present_rowBatches = true && that.isSetRowBatches();
18261       if (this_present_rowBatches || that_present_rowBatches) {
18262         if (!(this_present_rowBatches && that_present_rowBatches))
18263           return false;
18264         if (!this.rowBatches.equals(that.rowBatches))
18265           return false;
18266       }
18267 
18268       return true;
18269     }
18270 
18271     @Override
18272     public int hashCode() {
18273       HashCodeBuilder builder = new HashCodeBuilder();
18274 
18275       boolean present_tableName = true && (isSetTableName());
18276       builder.append(present_tableName);
18277       if (present_tableName)
18278         builder.append(tableName);
18279 
18280       boolean present_rowBatches = true && (isSetRowBatches());
18281       builder.append(present_rowBatches);
18282       if (present_rowBatches)
18283         builder.append(rowBatches);
18284 
18285       return builder.toHashCode();
18286     }
18287 
18288     public int compareTo(mutateRows_args other) {
18289       if (!getClass().equals(other.getClass())) {
18290         return getClass().getName().compareTo(other.getClass().getName());
18291       }
18292 
18293       int lastComparison = 0;
18294       mutateRows_args typedOther = (mutateRows_args)other;
18295 
18296       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
18297       if (lastComparison != 0) {
18298         return lastComparison;
18299       }
18300       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
18301       if (lastComparison != 0) {
18302         return lastComparison;
18303       }
18304       lastComparison = Boolean.valueOf(isSetRowBatches()).compareTo(isSetRowBatches());
18305       if (lastComparison != 0) {
18306         return lastComparison;
18307       }
18308       lastComparison = TBaseHelper.compareTo(rowBatches, typedOther.rowBatches);
18309       if (lastComparison != 0) {
18310         return lastComparison;
18311       }
18312       return 0;
18313     }
18314 
18315     public void read(TProtocol iprot) throws TException {
18316       TField field;
18317       iprot.readStructBegin();
18318       while (true)
18319       {
18320         field = iprot.readFieldBegin();
18321         if (field.type == TType.STOP) {
18322           break;
18323         }
18324         _Fields fieldId = _Fields.findByThriftId(field.id);
18325         if (fieldId == null) {
18326           TProtocolUtil.skip(iprot, field.type);
18327         } else {
18328           switch (fieldId) {
18329             case TABLE_NAME:
18330               if (field.type == TType.STRING) {
18331                 this.tableName = iprot.readBinary();
18332               } else {
18333                 TProtocolUtil.skip(iprot, field.type);
18334               }
18335               break;
18336             case ROW_BATCHES:
18337               if (field.type == TType.LIST) {
18338                 {
18339                   TList _list70 = iprot.readListBegin();
18340                   this.rowBatches = new ArrayList<BatchMutation>(_list70.size);
18341                   for (int _i71 = 0; _i71 < _list70.size; ++_i71)
18342                   {
18343                     BatchMutation _elem72;
18344                     _elem72 = new BatchMutation();
18345                     _elem72.read(iprot);
18346                     this.rowBatches.add(_elem72);
18347                   }
18348                   iprot.readListEnd();
18349                 }
18350               } else {
18351                 TProtocolUtil.skip(iprot, field.type);
18352               }
18353               break;
18354           }
18355           iprot.readFieldEnd();
18356         }
18357       }
18358       iprot.readStructEnd();
18359 
18360       // check for required fields of primitive type, which can't be checked in the validate method
18361       validate();
18362     }
18363 
18364     public void write(TProtocol oprot) throws TException {
18365       validate();
18366 
18367       oprot.writeStructBegin(STRUCT_DESC);
18368       if (this.tableName != null) {
18369         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
18370         oprot.writeBinary(this.tableName);
18371         oprot.writeFieldEnd();
18372       }
18373       if (this.rowBatches != null) {
18374         oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
18375         {
18376           oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size()));
18377           for (BatchMutation _iter73 : this.rowBatches)
18378           {
18379             _iter73.write(oprot);
18380           }
18381           oprot.writeListEnd();
18382         }
18383         oprot.writeFieldEnd();
18384       }
18385       oprot.writeFieldStop();
18386       oprot.writeStructEnd();
18387     }
18388 
18389     @Override
18390     public String toString() {
18391       StringBuilder sb = new StringBuilder("mutateRows_args(");
18392       boolean first = true;
18393 
18394       sb.append("tableName:");
18395       if (this.tableName == null) {
18396         sb.append("null");
18397       } else {
18398         sb.append(this.tableName);
18399       }
18400       first = false;
18401       if (!first) sb.append(", ");
18402       sb.append("rowBatches:");
18403       if (this.rowBatches == null) {
18404         sb.append("null");
18405       } else {
18406         sb.append(this.rowBatches);
18407       }
18408       first = false;
18409       sb.append(")");
18410       return sb.toString();
18411     }
18412 
18413     public void validate() throws TException {
18414       // check for required fields
18415     }
18416 
18417   }
18418 
18419   public static class mutateRows_result implements TBase<mutateRows_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRows_result>   {
18420     private static final TStruct STRUCT_DESC = new TStruct("mutateRows_result");
18421 
18422     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
18423     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
18424 
18425     public IOError io;
18426     public IllegalArgument ia;
18427 
18428     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
18429     public enum _Fields implements TFieldIdEnum {
18430       IO((short)1, "io"),
18431       IA((short)2, "ia");
18432 
18433       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18434       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18435 
18436       static {
18437         for (_Fields field : EnumSet.allOf(_Fields.class)) {
18438           byId.put((int)field._thriftId, field);
18439           byName.put(field.getFieldName(), field);
18440         }
18441       }
18442 
18443       /**
18444        * Find the _Fields constant that matches fieldId, or null if its not found.
18445        */
18446       public static _Fields findByThriftId(int fieldId) {
18447         return byId.get(fieldId);
18448       }
18449 
18450       /**
18451        * Find the _Fields constant that matches fieldId, throwing an exception
18452        * if it is not found.
18453        */
18454       public static _Fields findByThriftIdOrThrow(int fieldId) {
18455         _Fields fields = findByThriftId(fieldId);
18456         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18457         return fields;
18458       }
18459 
18460       /**
18461        * Find the _Fields constant that matches name, or null if its not found.
18462        */
18463       public static _Fields findByName(String name) {
18464         return byName.get(name);
18465       }
18466 
18467       private final short _thriftId;
18468       private final String _fieldName;
18469 
18470       _Fields(short thriftId, String fieldName) {
18471         _thriftId = thriftId;
18472         _fieldName = fieldName;
18473       }
18474 
18475       public short getThriftFieldId() {
18476         return _thriftId;
18477       }
18478 
18479       public String getFieldName() {
18480         return _fieldName;
18481       }
18482     }
18483 
18484     // isset id assignments
18485 
18486     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18487       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
18488           new FieldValueMetaData(TType.STRUCT)));
18489       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
18490           new FieldValueMetaData(TType.STRUCT)));
18491     }});
18492 
18493     static {
18494       FieldMetaData.addStructMetaDataMap(mutateRows_result.class, metaDataMap);
18495     }
18496 
18497     public mutateRows_result() {
18498     }
18499 
18500     public mutateRows_result(
18501       IOError io,
18502       IllegalArgument ia)
18503     {
18504       this();
18505       this.io = io;
18506       this.ia = ia;
18507     }
18508 
18509     /**
18510      * Performs a deep copy on <i>other</i>.
18511      */
18512     public mutateRows_result(mutateRows_result other) {
18513       if (other.isSetIo()) {
18514         this.io = new IOError(other.io);
18515       }
18516       if (other.isSetIa()) {
18517         this.ia = new IllegalArgument(other.ia);
18518       }
18519     }
18520 
18521     public mutateRows_result deepCopy() {
18522       return new mutateRows_result(this);
18523     }
18524 
18525     @Deprecated
18526     public mutateRows_result clone() {
18527       return new mutateRows_result(this);
18528     }
18529 
18530     public IOError getIo() {
18531       return this.io;
18532     }
18533 
18534     public mutateRows_result setIo(IOError io) {
18535       this.io = io;
18536       return this;
18537     }
18538 
18539     public void unsetIo() {
18540       this.io = null;
18541     }
18542 
18543     /** Returns true if field io is set (has been asigned a value) and false otherwise */
18544     public boolean isSetIo() {
18545       return this.io != null;
18546     }
18547 
18548     public void setIoIsSet(boolean value) {
18549       if (!value) {
18550         this.io = null;
18551       }
18552     }
18553 
18554     public IllegalArgument getIa() {
18555       return this.ia;
18556     }
18557 
18558     public mutateRows_result setIa(IllegalArgument ia) {
18559       this.ia = ia;
18560       return this;
18561     }
18562 
18563     public void unsetIa() {
18564       this.ia = null;
18565     }
18566 
18567     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
18568     public boolean isSetIa() {
18569       return this.ia != null;
18570     }
18571 
18572     public void setIaIsSet(boolean value) {
18573       if (!value) {
18574         this.ia = null;
18575       }
18576     }
18577 
18578     public void setFieldValue(_Fields field, Object value) {
18579       switch (field) {
18580       case IO:
18581         if (value == null) {
18582           unsetIo();
18583         } else {
18584           setIo((IOError)value);
18585         }
18586         break;
18587 
18588       case IA:
18589         if (value == null) {
18590           unsetIa();
18591         } else {
18592           setIa((IllegalArgument)value);
18593         }
18594         break;
18595 
18596       }
18597     }
18598 
18599     public void setFieldValue(int fieldID, Object value) {
18600       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
18601     }
18602 
18603     public Object getFieldValue(_Fields field) {
18604       switch (field) {
18605       case IO:
18606         return getIo();
18607 
18608       case IA:
18609         return getIa();
18610 
18611       }
18612       throw new IllegalStateException();
18613     }
18614 
18615     public Object getFieldValue(int fieldId) {
18616       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
18617     }
18618 
18619     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
18620     public boolean isSet(_Fields field) {
18621       switch (field) {
18622       case IO:
18623         return isSetIo();
18624       case IA:
18625         return isSetIa();
18626       }
18627       throw new IllegalStateException();
18628     }
18629 
18630     public boolean isSet(int fieldID) {
18631       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
18632     }
18633 
18634     @Override
18635     public boolean equals(Object that) {
18636       if (that == null)
18637         return false;
18638       if (that instanceof mutateRows_result)
18639         return this.equals((mutateRows_result)that);
18640       return false;
18641     }
18642 
18643     public boolean equals(mutateRows_result that) {
18644       if (that == null)
18645         return false;
18646 
18647       boolean this_present_io = true && this.isSetIo();
18648       boolean that_present_io = true && that.isSetIo();
18649       if (this_present_io || that_present_io) {
18650         if (!(this_present_io && that_present_io))
18651           return false;
18652         if (!this.io.equals(that.io))
18653           return false;
18654       }
18655 
18656       boolean this_present_ia = true && this.isSetIa();
18657       boolean that_present_ia = true && that.isSetIa();
18658       if (this_present_ia || that_present_ia) {
18659         if (!(this_present_ia && that_present_ia))
18660           return false;
18661         if (!this.ia.equals(that.ia))
18662           return false;
18663       }
18664 
18665       return true;
18666     }
18667 
18668     @Override
18669     public int hashCode() {
18670       HashCodeBuilder builder = new HashCodeBuilder();
18671 
18672       boolean present_io = true && (isSetIo());
18673       builder.append(present_io);
18674       if (present_io)
18675         builder.append(io);
18676 
18677       boolean present_ia = true && (isSetIa());
18678       builder.append(present_ia);
18679       if (present_ia)
18680         builder.append(ia);
18681 
18682       return builder.toHashCode();
18683     }
18684 
18685     public int compareTo(mutateRows_result other) {
18686       if (!getClass().equals(other.getClass())) {
18687         return getClass().getName().compareTo(other.getClass().getName());
18688       }
18689 
18690       int lastComparison = 0;
18691       mutateRows_result typedOther = (mutateRows_result)other;
18692 
18693       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
18694       if (lastComparison != 0) {
18695         return lastComparison;
18696       }
18697       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
18698       if (lastComparison != 0) {
18699         return lastComparison;
18700       }
18701       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
18702       if (lastComparison != 0) {
18703         return lastComparison;
18704       }
18705       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
18706       if (lastComparison != 0) {
18707         return lastComparison;
18708       }
18709       return 0;
18710     }
18711 
18712     public void read(TProtocol iprot) throws TException {
18713       TField field;
18714       iprot.readStructBegin();
18715       while (true)
18716       {
18717         field = iprot.readFieldBegin();
18718         if (field.type == TType.STOP) {
18719           break;
18720         }
18721         _Fields fieldId = _Fields.findByThriftId(field.id);
18722         if (fieldId == null) {
18723           TProtocolUtil.skip(iprot, field.type);
18724         } else {
18725           switch (fieldId) {
18726             case IO:
18727               if (field.type == TType.STRUCT) {
18728                 this.io = new IOError();
18729                 this.io.read(iprot);
18730               } else {
18731                 TProtocolUtil.skip(iprot, field.type);
18732               }
18733               break;
18734             case IA:
18735               if (field.type == TType.STRUCT) {
18736                 this.ia = new IllegalArgument();
18737                 this.ia.read(iprot);
18738               } else {
18739                 TProtocolUtil.skip(iprot, field.type);
18740               }
18741               break;
18742           }
18743           iprot.readFieldEnd();
18744         }
18745       }
18746       iprot.readStructEnd();
18747 
18748       // check for required fields of primitive type, which can't be checked in the validate method
18749       validate();
18750     }
18751 
18752     public void write(TProtocol oprot) throws TException {
18753       oprot.writeStructBegin(STRUCT_DESC);
18754 
18755       if (this.isSetIo()) {
18756         oprot.writeFieldBegin(IO_FIELD_DESC);
18757         this.io.write(oprot);
18758         oprot.writeFieldEnd();
18759       } else if (this.isSetIa()) {
18760         oprot.writeFieldBegin(IA_FIELD_DESC);
18761         this.ia.write(oprot);
18762         oprot.writeFieldEnd();
18763       }
18764       oprot.writeFieldStop();
18765       oprot.writeStructEnd();
18766     }
18767 
18768     @Override
18769     public String toString() {
18770       StringBuilder sb = new StringBuilder("mutateRows_result(");
18771       boolean first = true;
18772 
18773       sb.append("io:");
18774       if (this.io == null) {
18775         sb.append("null");
18776       } else {
18777         sb.append(this.io);
18778       }
18779       first = false;
18780       if (!first) sb.append(", ");
18781       sb.append("ia:");
18782       if (this.ia == null) {
18783         sb.append("null");
18784       } else {
18785         sb.append(this.ia);
18786       }
18787       first = false;
18788       sb.append(")");
18789       return sb.toString();
18790     }
18791 
18792     public void validate() throws TException {
18793       // check for required fields
18794     }
18795 
18796   }
18797 
18798   public static class mutateRowsTs_args implements TBase<mutateRowsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_args>   {
18799     private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_args");
18800 
18801     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
18802     private static final TField ROW_BATCHES_FIELD_DESC = new TField("rowBatches", TType.LIST, (short)2);
18803     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
18804 
18805     /**
18806      * name of table
18807      */
18808     public byte[] tableName;
18809     /**
18810      * list of row batches
18811      */
18812     public List<BatchMutation> rowBatches;
18813     /**
18814      * timestamp
18815      */
18816     public long timestamp;
18817 
18818     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
18819     public enum _Fields implements TFieldIdEnum {
18820       /**
18821        * name of table
18822        */
18823       TABLE_NAME((short)1, "tableName"),
18824       /**
18825        * list of row batches
18826        */
18827       ROW_BATCHES((short)2, "rowBatches"),
18828       /**
18829        * timestamp
18830        */
18831       TIMESTAMP((short)3, "timestamp");
18832 
18833       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
18834       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
18835 
18836       static {
18837         for (_Fields field : EnumSet.allOf(_Fields.class)) {
18838           byId.put((int)field._thriftId, field);
18839           byName.put(field.getFieldName(), field);
18840         }
18841       }
18842 
18843       /**
18844        * Find the _Fields constant that matches fieldId, or null if its not found.
18845        */
18846       public static _Fields findByThriftId(int fieldId) {
18847         return byId.get(fieldId);
18848       }
18849 
18850       /**
18851        * Find the _Fields constant that matches fieldId, throwing an exception
18852        * if it is not found.
18853        */
18854       public static _Fields findByThriftIdOrThrow(int fieldId) {
18855         _Fields fields = findByThriftId(fieldId);
18856         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
18857         return fields;
18858       }
18859 
18860       /**
18861        * Find the _Fields constant that matches name, or null if its not found.
18862        */
18863       public static _Fields findByName(String name) {
18864         return byName.get(name);
18865       }
18866 
18867       private final short _thriftId;
18868       private final String _fieldName;
18869 
18870       _Fields(short thriftId, String fieldName) {
18871         _thriftId = thriftId;
18872         _fieldName = fieldName;
18873       }
18874 
18875       public short getThriftFieldId() {
18876         return _thriftId;
18877       }
18878 
18879       public String getFieldName() {
18880         return _fieldName;
18881       }
18882     }
18883 
18884     // isset id assignments
18885     private static final int __TIMESTAMP_ISSET_ID = 0;
18886     private BitSet __isset_bit_vector = new BitSet(1);
18887 
18888     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
18889       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
18890           new FieldValueMetaData(TType.STRING)));
18891       put(_Fields.ROW_BATCHES, new FieldMetaData("rowBatches", TFieldRequirementType.DEFAULT,
18892           new ListMetaData(TType.LIST,
18893               new StructMetaData(TType.STRUCT, BatchMutation.class))));
18894       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
18895           new FieldValueMetaData(TType.I64)));
18896     }});
18897 
18898     static {
18899       FieldMetaData.addStructMetaDataMap(mutateRowsTs_args.class, metaDataMap);
18900     }
18901 
18902     public mutateRowsTs_args() {
18903     }
18904 
18905     public mutateRowsTs_args(
18906       byte[] tableName,
18907       List<BatchMutation> rowBatches,
18908       long timestamp)
18909     {
18910       this();
18911       this.tableName = tableName;
18912       this.rowBatches = rowBatches;
18913       this.timestamp = timestamp;
18914       setTimestampIsSet(true);
18915     }
18916 
18917     /**
18918      * Performs a deep copy on <i>other</i>.
18919      */
18920     public mutateRowsTs_args(mutateRowsTs_args other) {
18921       __isset_bit_vector.clear();
18922       __isset_bit_vector.or(other.__isset_bit_vector);
18923       if (other.isSetTableName()) {
18924         this.tableName = other.tableName;
18925       }
18926       if (other.isSetRowBatches()) {
18927         List<BatchMutation> __this__rowBatches = new ArrayList<BatchMutation>();
18928         for (BatchMutation other_element : other.rowBatches) {
18929           __this__rowBatches.add(new BatchMutation(other_element));
18930         }
18931         this.rowBatches = __this__rowBatches;
18932       }
18933       this.timestamp = other.timestamp;
18934     }
18935 
18936     public mutateRowsTs_args deepCopy() {
18937       return new mutateRowsTs_args(this);
18938     }
18939 
18940     @Deprecated
18941     public mutateRowsTs_args clone() {
18942       return new mutateRowsTs_args(this);
18943     }
18944 
18945     /**
18946      * name of table
18947      */
18948     public byte[] getTableName() {
18949       return this.tableName;
18950     }
18951 
18952     /**
18953      * name of table
18954      */
18955     public mutateRowsTs_args setTableName(byte[] tableName) {
18956       this.tableName = tableName;
18957       return this;
18958     }
18959 
18960     public void unsetTableName() {
18961       this.tableName = null;
18962     }
18963 
18964     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
18965     public boolean isSetTableName() {
18966       return this.tableName != null;
18967     }
18968 
18969     public void setTableNameIsSet(boolean value) {
18970       if (!value) {
18971         this.tableName = null;
18972       }
18973     }
18974 
18975     public int getRowBatchesSize() {
18976       return (this.rowBatches == null) ? 0 : this.rowBatches.size();
18977     }
18978 
18979     public java.util.Iterator<BatchMutation> getRowBatchesIterator() {
18980       return (this.rowBatches == null) ? null : this.rowBatches.iterator();
18981     }
18982 
18983     public void addToRowBatches(BatchMutation elem) {
18984       if (this.rowBatches == null) {
18985         this.rowBatches = new ArrayList<BatchMutation>();
18986       }
18987       this.rowBatches.add(elem);
18988     }
18989 
18990     /**
18991      * list of row batches
18992      */
18993     public List<BatchMutation> getRowBatches() {
18994       return this.rowBatches;
18995     }
18996 
18997     /**
18998      * list of row batches
18999      */
19000     public mutateRowsTs_args setRowBatches(List<BatchMutation> rowBatches) {
19001       this.rowBatches = rowBatches;
19002       return this;
19003     }
19004 
19005     public void unsetRowBatches() {
19006       this.rowBatches = null;
19007     }
19008 
19009     /** Returns true if field rowBatches is set (has been asigned a value) and false otherwise */
19010     public boolean isSetRowBatches() {
19011       return this.rowBatches != null;
19012     }
19013 
19014     public void setRowBatchesIsSet(boolean value) {
19015       if (!value) {
19016         this.rowBatches = null;
19017       }
19018     }
19019 
19020     /**
19021      * timestamp
19022      */
19023     public long getTimestamp() {
19024       return this.timestamp;
19025     }
19026 
19027     /**
19028      * timestamp
19029      */
19030     public mutateRowsTs_args setTimestamp(long timestamp) {
19031       this.timestamp = timestamp;
19032       setTimestampIsSet(true);
19033       return this;
19034     }
19035 
19036     public void unsetTimestamp() {
19037       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
19038     }
19039 
19040     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
19041     public boolean isSetTimestamp() {
19042       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
19043     }
19044 
19045     public void setTimestampIsSet(boolean value) {
19046       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
19047     }
19048 
19049     public void setFieldValue(_Fields field, Object value) {
19050       switch (field) {
19051       case TABLE_NAME:
19052         if (value == null) {
19053           unsetTableName();
19054         } else {
19055           setTableName((byte[])value);
19056         }
19057         break;
19058 
19059       case ROW_BATCHES:
19060         if (value == null) {
19061           unsetRowBatches();
19062         } else {
19063           setRowBatches((List<BatchMutation>)value);
19064         }
19065         break;
19066 
19067       case TIMESTAMP:
19068         if (value == null) {
19069           unsetTimestamp();
19070         } else {
19071           setTimestamp((Long)value);
19072         }
19073         break;
19074 
19075       }
19076     }
19077 
19078     public void setFieldValue(int fieldID, Object value) {
19079       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
19080     }
19081 
19082     public Object getFieldValue(_Fields field) {
19083       switch (field) {
19084       case TABLE_NAME:
19085         return getTableName();
19086 
19087       case ROW_BATCHES:
19088         return getRowBatches();
19089 
19090       case TIMESTAMP:
19091         return new Long(getTimestamp());
19092 
19093       }
19094       throw new IllegalStateException();
19095     }
19096 
19097     public Object getFieldValue(int fieldId) {
19098       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
19099     }
19100 
19101     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
19102     public boolean isSet(_Fields field) {
19103       switch (field) {
19104       case TABLE_NAME:
19105         return isSetTableName();
19106       case ROW_BATCHES:
19107         return isSetRowBatches();
19108       case TIMESTAMP:
19109         return isSetTimestamp();
19110       }
19111       throw new IllegalStateException();
19112     }
19113 
19114     public boolean isSet(int fieldID) {
19115       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
19116     }
19117 
19118     @Override
19119     public boolean equals(Object that) {
19120       if (that == null)
19121         return false;
19122       if (that instanceof mutateRowsTs_args)
19123         return this.equals((mutateRowsTs_args)that);
19124       return false;
19125     }
19126 
19127     public boolean equals(mutateRowsTs_args that) {
19128       if (that == null)
19129         return false;
19130 
19131       boolean this_present_tableName = true && this.isSetTableName();
19132       boolean that_present_tableName = true && that.isSetTableName();
19133       if (this_present_tableName || that_present_tableName) {
19134         if (!(this_present_tableName && that_present_tableName))
19135           return false;
19136         if (!java.util.Arrays.equals(this.tableName, that.tableName))
19137           return false;
19138       }
19139 
19140       boolean this_present_rowBatches = true && this.isSetRowBatches();
19141       boolean that_present_rowBatches = true && that.isSetRowBatches();
19142       if (this_present_rowBatches || that_present_rowBatches) {
19143         if (!(this_present_rowBatches && that_present_rowBatches))
19144           return false;
19145         if (!this.rowBatches.equals(that.rowBatches))
19146           return false;
19147       }
19148 
19149       boolean this_present_timestamp = true;
19150       boolean that_present_timestamp = true;
19151       if (this_present_timestamp || that_present_timestamp) {
19152         if (!(this_present_timestamp && that_present_timestamp))
19153           return false;
19154         if (this.timestamp != that.timestamp)
19155           return false;
19156       }
19157 
19158       return true;
19159     }
19160 
19161     @Override
19162     public int hashCode() {
19163       HashCodeBuilder builder = new HashCodeBuilder();
19164 
19165       boolean present_tableName = true && (isSetTableName());
19166       builder.append(present_tableName);
19167       if (present_tableName)
19168         builder.append(tableName);
19169 
19170       boolean present_rowBatches = true && (isSetRowBatches());
19171       builder.append(present_rowBatches);
19172       if (present_rowBatches)
19173         builder.append(rowBatches);
19174 
19175       boolean present_timestamp = true;
19176       builder.append(present_timestamp);
19177       if (present_timestamp)
19178         builder.append(timestamp);
19179 
19180       return builder.toHashCode();
19181     }
19182 
19183     public int compareTo(mutateRowsTs_args other) {
19184       if (!getClass().equals(other.getClass())) {
19185         return getClass().getName().compareTo(other.getClass().getName());
19186       }
19187 
19188       int lastComparison = 0;
19189       mutateRowsTs_args typedOther = (mutateRowsTs_args)other;
19190 
19191       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
19192       if (lastComparison != 0) {
19193         return lastComparison;
19194       }
19195       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
19196       if (lastComparison != 0) {
19197         return lastComparison;
19198       }
19199       lastComparison = Boolean.valueOf(isSetRowBatches()).compareTo(isSetRowBatches());
19200       if (lastComparison != 0) {
19201         return lastComparison;
19202       }
19203       lastComparison = TBaseHelper.compareTo(rowBatches, typedOther.rowBatches);
19204       if (lastComparison != 0) {
19205         return lastComparison;
19206       }
19207       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
19208       if (lastComparison != 0) {
19209         return lastComparison;
19210       }
19211       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
19212       if (lastComparison != 0) {
19213         return lastComparison;
19214       }
19215       return 0;
19216     }
19217 
19218     public void read(TProtocol iprot) throws TException {
19219       TField field;
19220       iprot.readStructBegin();
19221       while (true)
19222       {
19223         field = iprot.readFieldBegin();
19224         if (field.type == TType.STOP) {
19225           break;
19226         }
19227         _Fields fieldId = _Fields.findByThriftId(field.id);
19228         if (fieldId == null) {
19229           TProtocolUtil.skip(iprot, field.type);
19230         } else {
19231           switch (fieldId) {
19232             case TABLE_NAME:
19233               if (field.type == TType.STRING) {
19234                 this.tableName = iprot.readBinary();
19235               } else {
19236                 TProtocolUtil.skip(iprot, field.type);
19237               }
19238               break;
19239             case ROW_BATCHES:
19240               if (field.type == TType.LIST) {
19241                 {
19242                   TList _list74 = iprot.readListBegin();
19243                   this.rowBatches = new ArrayList<BatchMutation>(_list74.size);
19244                   for (int _i75 = 0; _i75 < _list74.size; ++_i75)
19245                   {
19246                     BatchMutation _elem76;
19247                     _elem76 = new BatchMutation();
19248                     _elem76.read(iprot);
19249                     this.rowBatches.add(_elem76);
19250                   }
19251                   iprot.readListEnd();
19252                 }
19253               } else {
19254                 TProtocolUtil.skip(iprot, field.type);
19255               }
19256               break;
19257             case TIMESTAMP:
19258               if (field.type == TType.I64) {
19259                 this.timestamp = iprot.readI64();
19260                 setTimestampIsSet(true);
19261               } else {
19262                 TProtocolUtil.skip(iprot, field.type);
19263               }
19264               break;
19265           }
19266           iprot.readFieldEnd();
19267         }
19268       }
19269       iprot.readStructEnd();
19270 
19271       // check for required fields of primitive type, which can't be checked in the validate method
19272       validate();
19273     }
19274 
19275     public void write(TProtocol oprot) throws TException {
19276       validate();
19277 
19278       oprot.writeStructBegin(STRUCT_DESC);
19279       if (this.tableName != null) {
19280         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
19281         oprot.writeBinary(this.tableName);
19282         oprot.writeFieldEnd();
19283       }
19284       if (this.rowBatches != null) {
19285         oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC);
19286         {
19287           oprot.writeListBegin(new TList(TType.STRUCT, this.rowBatches.size()));
19288           for (BatchMutation _iter77 : this.rowBatches)
19289           {
19290             _iter77.write(oprot);
19291           }
19292           oprot.writeListEnd();
19293         }
19294         oprot.writeFieldEnd();
19295       }
19296       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
19297       oprot.writeI64(this.timestamp);
19298       oprot.writeFieldEnd();
19299       oprot.writeFieldStop();
19300       oprot.writeStructEnd();
19301     }
19302 
19303     @Override
19304     public String toString() {
19305       StringBuilder sb = new StringBuilder("mutateRowsTs_args(");
19306       boolean first = true;
19307 
19308       sb.append("tableName:");
19309       if (this.tableName == null) {
19310         sb.append("null");
19311       } else {
19312         sb.append(this.tableName);
19313       }
19314       first = false;
19315       if (!first) sb.append(", ");
19316       sb.append("rowBatches:");
19317       if (this.rowBatches == null) {
19318         sb.append("null");
19319       } else {
19320         sb.append(this.rowBatches);
19321       }
19322       first = false;
19323       if (!first) sb.append(", ");
19324       sb.append("timestamp:");
19325       sb.append(this.timestamp);
19326       first = false;
19327       sb.append(")");
19328       return sb.toString();
19329     }
19330 
19331     public void validate() throws TException {
19332       // check for required fields
19333     }
19334 
19335   }
19336 
19337   public static class mutateRowsTs_result implements TBase<mutateRowsTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRowsTs_result>   {
19338     private static final TStruct STRUCT_DESC = new TStruct("mutateRowsTs_result");
19339 
19340     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
19341     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
19342 
19343     public IOError io;
19344     public IllegalArgument ia;
19345 
19346     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
19347     public enum _Fields implements TFieldIdEnum {
19348       IO((short)1, "io"),
19349       IA((short)2, "ia");
19350 
19351       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
19352       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
19353 
19354       static {
19355         for (_Fields field : EnumSet.allOf(_Fields.class)) {
19356           byId.put((int)field._thriftId, field);
19357           byName.put(field.getFieldName(), field);
19358         }
19359       }
19360 
19361       /**
19362        * Find the _Fields constant that matches fieldId, or null if its not found.
19363        */
19364       public static _Fields findByThriftId(int fieldId) {
19365         return byId.get(fieldId);
19366       }
19367 
19368       /**
19369        * Find the _Fields constant that matches fieldId, throwing an exception
19370        * if it is not found.
19371        */
19372       public static _Fields findByThriftIdOrThrow(int fieldId) {
19373         _Fields fields = findByThriftId(fieldId);
19374         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
19375         return fields;
19376       }
19377 
19378       /**
19379        * Find the _Fields constant that matches name, or null if its not found.
19380        */
19381       public static _Fields findByName(String name) {
19382         return byName.get(name);
19383       }
19384 
19385       private final short _thriftId;
19386       private final String _fieldName;
19387 
19388       _Fields(short thriftId, String fieldName) {
19389         _thriftId = thriftId;
19390         _fieldName = fieldName;
19391       }
19392 
19393       public short getThriftFieldId() {
19394         return _thriftId;
19395       }
19396 
19397       public String getFieldName() {
19398         return _fieldName;
19399       }
19400     }
19401 
19402     // isset id assignments
19403 
19404     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
19405       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
19406           new FieldValueMetaData(TType.STRUCT)));
19407       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
19408           new FieldValueMetaData(TType.STRUCT)));
19409     }});
19410 
19411     static {
19412       FieldMetaData.addStructMetaDataMap(mutateRowsTs_result.class, metaDataMap);
19413     }
19414 
19415     public mutateRowsTs_result() {
19416     }
19417 
19418     public mutateRowsTs_result(
19419       IOError io,
19420       IllegalArgument ia)
19421     {
19422       this();
19423       this.io = io;
19424       this.ia = ia;
19425     }
19426 
19427     /**
19428      * Performs a deep copy on <i>other</i>.
19429      */
19430     public mutateRowsTs_result(mutateRowsTs_result other) {
19431       if (other.isSetIo()) {
19432         this.io = new IOError(other.io);
19433       }
19434       if (other.isSetIa()) {
19435         this.ia = new IllegalArgument(other.ia);
19436       }
19437     }
19438 
19439     public mutateRowsTs_result deepCopy() {
19440       return new mutateRowsTs_result(this);
19441     }
19442 
19443     @Deprecated
19444     public mutateRowsTs_result clone() {
19445       return new mutateRowsTs_result(this);
19446     }
19447 
19448     public IOError getIo() {
19449       return this.io;
19450     }
19451 
19452     public mutateRowsTs_result setIo(IOError io) {
19453       this.io = io;
19454       return this;
19455     }
19456 
19457     public void unsetIo() {
19458       this.io = null;
19459     }
19460 
19461     /** Returns true if field io is set (has been asigned a value) and false otherwise */
19462     public boolean isSetIo() {
19463       return this.io != null;
19464     }
19465 
19466     public void setIoIsSet(boolean value) {
19467       if (!value) {
19468         this.io = null;
19469       }
19470     }
19471 
19472     public IllegalArgument getIa() {
19473       return this.ia;
19474     }
19475 
19476     public mutateRowsTs_result setIa(IllegalArgument ia) {
19477       this.ia = ia;
19478       return this;
19479     }
19480 
19481     public void unsetIa() {
19482       this.ia = null;
19483     }
19484 
19485     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
19486     public boolean isSetIa() {
19487       return this.ia != null;
19488     }
19489 
19490     public void setIaIsSet(boolean value) {
19491       if (!value) {
19492         this.ia = null;
19493       }
19494     }
19495 
19496     public void setFieldValue(_Fields field, Object value) {
19497       switch (field) {
19498       case IO:
19499         if (value == null) {
19500           unsetIo();
19501         } else {
19502           setIo((IOError)value);
19503         }
19504         break;
19505 
19506       case IA:
19507         if (value == null) {
19508           unsetIa();
19509         } else {
19510           setIa((IllegalArgument)value);
19511         }
19512         break;
19513 
19514       }
19515     }
19516 
19517     public void setFieldValue(int fieldID, Object value) {
19518       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
19519     }
19520 
19521     public Object getFieldValue(_Fields field) {
19522       switch (field) {
19523       case IO:
19524         return getIo();
19525 
19526       case IA:
19527         return getIa();
19528 
19529       }
19530       throw new IllegalStateException();
19531     }
19532 
19533     public Object getFieldValue(int fieldId) {
19534       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
19535     }
19536 
19537     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
19538     public boolean isSet(_Fields field) {
19539       switch (field) {
19540       case IO:
19541         return isSetIo();
19542       case IA:
19543         return isSetIa();
19544       }
19545       throw new IllegalStateException();
19546     }
19547 
19548     public boolean isSet(int fieldID) {
19549       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
19550     }
19551 
19552     @Override
19553     public boolean equals(Object that) {
19554       if (that == null)
19555         return false;
19556       if (that instanceof mutateRowsTs_result)
19557         return this.equals((mutateRowsTs_result)that);
19558       return false;
19559     }
19560 
19561     public boolean equals(mutateRowsTs_result that) {
19562       if (that == null)
19563         return false;
19564 
19565       boolean this_present_io = true && this.isSetIo();
19566       boolean that_present_io = true && that.isSetIo();
19567       if (this_present_io || that_present_io) {
19568         if (!(this_present_io && that_present_io))
19569           return false;
19570         if (!this.io.equals(that.io))
19571           return false;
19572       }
19573 
19574       boolean this_present_ia = true && this.isSetIa();
19575       boolean that_present_ia = true && that.isSetIa();
19576       if (this_present_ia || that_present_ia) {
19577         if (!(this_present_ia && that_present_ia))
19578           return false;
19579         if (!this.ia.equals(that.ia))
19580           return false;
19581       }
19582 
19583       return true;
19584     }
19585 
19586     @Override
19587     public int hashCode() {
19588       HashCodeBuilder builder = new HashCodeBuilder();
19589 
19590       boolean present_io = true && (isSetIo());
19591       builder.append(present_io);
19592       if (present_io)
19593         builder.append(io);
19594 
19595       boolean present_ia = true && (isSetIa());
19596       builder.append(present_ia);
19597       if (present_ia)
19598         builder.append(ia);
19599 
19600       return builder.toHashCode();
19601     }
19602 
19603     public int compareTo(mutateRowsTs_result other) {
19604       if (!getClass().equals(other.getClass())) {
19605         return getClass().getName().compareTo(other.getClass().getName());
19606       }
19607 
19608       int lastComparison = 0;
19609       mutateRowsTs_result typedOther = (mutateRowsTs_result)other;
19610 
19611       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
19612       if (lastComparison != 0) {
19613         return lastComparison;
19614       }
19615       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
19616       if (lastComparison != 0) {
19617         return lastComparison;
19618       }
19619       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
19620       if (lastComparison != 0) {
19621         return lastComparison;
19622       }
19623       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
19624       if (lastComparison != 0) {
19625         return lastComparison;
19626       }
19627       return 0;
19628     }
19629 
19630     public void read(TProtocol iprot) throws TException {
19631       TField field;
19632       iprot.readStructBegin();
19633       while (true)
19634       {
19635         field = iprot.readFieldBegin();
19636         if (field.type == TType.STOP) {
19637           break;
19638         }
19639         _Fields fieldId = _Fields.findByThriftId(field.id);
19640         if (fieldId == null) {
19641           TProtocolUtil.skip(iprot, field.type);
19642         } else {
19643           switch (fieldId) {
19644             case IO:
19645               if (field.type == TType.STRUCT) {
19646                 this.io = new IOError();
19647                 this.io.read(iprot);
19648               } else {
19649                 TProtocolUtil.skip(iprot, field.type);
19650               }
19651               break;
19652             case IA:
19653               if (field.type == TType.STRUCT) {
19654                 this.ia = new IllegalArgument();
19655                 this.ia.read(iprot);
19656               } else {
19657                 TProtocolUtil.skip(iprot, field.type);
19658               }
19659               break;
19660           }
19661           iprot.readFieldEnd();
19662         }
19663       }
19664       iprot.readStructEnd();
19665 
19666       // check for required fields of primitive type, which can't be checked in the validate method
19667       validate();
19668     }
19669 
19670     public void write(TProtocol oprot) throws TException {
19671       oprot.writeStructBegin(STRUCT_DESC);
19672 
19673       if (this.isSetIo()) {
19674         oprot.writeFieldBegin(IO_FIELD_DESC);
19675         this.io.write(oprot);
19676         oprot.writeFieldEnd();
19677       } else if (this.isSetIa()) {
19678         oprot.writeFieldBegin(IA_FIELD_DESC);
19679         this.ia.write(oprot);
19680         oprot.writeFieldEnd();
19681       }
19682       oprot.writeFieldStop();
19683       oprot.writeStructEnd();
19684     }
19685 
19686     @Override
19687     public String toString() {
19688       StringBuilder sb = new StringBuilder("mutateRowsTs_result(");
19689       boolean first = true;
19690 
19691       sb.append("io:");
19692       if (this.io == null) {
19693         sb.append("null");
19694       } else {
19695         sb.append(this.io);
19696       }
19697       first = false;
19698       if (!first) sb.append(", ");
19699       sb.append("ia:");
19700       if (this.ia == null) {
19701         sb.append("null");
19702       } else {
19703         sb.append(this.ia);
19704       }
19705       first = false;
19706       sb.append(")");
19707       return sb.toString();
19708     }
19709 
19710     public void validate() throws TException {
19711       // check for required fields
19712     }
19713 
19714   }
19715 
19716   public static class atomicIncrement_args implements TBase<atomicIncrement_args._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_args>   {
19717     private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_args");
19718 
19719     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
19720     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
19721     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
19722     private static final TField VALUE_FIELD_DESC = new TField("value", TType.I64, (short)4);
19723 
19724     /**
19725      * name of table
19726      */
19727     public byte[] tableName;
19728     /**
19729      * row to increment
19730      */
19731     public byte[] row;
19732     /**
19733      * name of column
19734      */
19735     public byte[] column;
19736     /**
19737      * amount to increment by
19738      */
19739     public long value;
19740 
19741     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
19742     public enum _Fields implements TFieldIdEnum {
19743       /**
19744        * name of table
19745        */
19746       TABLE_NAME((short)1, "tableName"),
19747       /**
19748        * row to increment
19749        */
19750       ROW((short)2, "row"),
19751       /**
19752        * name of column
19753        */
19754       COLUMN((short)3, "column"),
19755       /**
19756        * amount to increment by
19757        */
19758       VALUE((short)4, "value");
19759 
19760       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
19761       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
19762 
19763       static {
19764         for (_Fields field : EnumSet.allOf(_Fields.class)) {
19765           byId.put((int)field._thriftId, field);
19766           byName.put(field.getFieldName(), field);
19767         }
19768       }
19769 
19770       /**
19771        * Find the _Fields constant that matches fieldId, or null if its not found.
19772        */
19773       public static _Fields findByThriftId(int fieldId) {
19774         return byId.get(fieldId);
19775       }
19776 
19777       /**
19778        * Find the _Fields constant that matches fieldId, throwing an exception
19779        * if it is not found.
19780        */
19781       public static _Fields findByThriftIdOrThrow(int fieldId) {
19782         _Fields fields = findByThriftId(fieldId);
19783         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
19784         return fields;
19785       }
19786 
19787       /**
19788        * Find the _Fields constant that matches name, or null if its not found.
19789        */
19790       public static _Fields findByName(String name) {
19791         return byName.get(name);
19792       }
19793 
19794       private final short _thriftId;
19795       private final String _fieldName;
19796 
19797       _Fields(short thriftId, String fieldName) {
19798         _thriftId = thriftId;
19799         _fieldName = fieldName;
19800       }
19801 
19802       public short getThriftFieldId() {
19803         return _thriftId;
19804       }
19805 
19806       public String getFieldName() {
19807         return _fieldName;
19808       }
19809     }
19810 
19811     // isset id assignments
19812     private static final int __VALUE_ISSET_ID = 0;
19813     private BitSet __isset_bit_vector = new BitSet(1);
19814 
19815     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
19816       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
19817           new FieldValueMetaData(TType.STRING)));
19818       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
19819           new FieldValueMetaData(TType.STRING)));
19820       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
19821           new FieldValueMetaData(TType.STRING)));
19822       put(_Fields.VALUE, new FieldMetaData("value", TFieldRequirementType.DEFAULT,
19823           new FieldValueMetaData(TType.I64)));
19824     }});
19825 
19826     static {
19827       FieldMetaData.addStructMetaDataMap(atomicIncrement_args.class, metaDataMap);
19828     }
19829 
19830     public atomicIncrement_args() {
19831     }
19832 
19833     public atomicIncrement_args(
19834       byte[] tableName,
19835       byte[] row,
19836       byte[] column,
19837       long value)
19838     {
19839       this();
19840       this.tableName = tableName;
19841       this.row = row;
19842       this.column = column;
19843       this.value = value;
19844       setValueIsSet(true);
19845     }
19846 
19847     /**
19848      * Performs a deep copy on <i>other</i>.
19849      */
19850     public atomicIncrement_args(atomicIncrement_args other) {
19851       __isset_bit_vector.clear();
19852       __isset_bit_vector.or(other.__isset_bit_vector);
19853       if (other.isSetTableName()) {
19854         this.tableName = other.tableName;
19855       }
19856       if (other.isSetRow()) {
19857         this.row = other.row;
19858       }
19859       if (other.isSetColumn()) {
19860         this.column = other.column;
19861       }
19862       this.value = other.value;
19863     }
19864 
19865     public atomicIncrement_args deepCopy() {
19866       return new atomicIncrement_args(this);
19867     }
19868 
19869     @Deprecated
19870     public atomicIncrement_args clone() {
19871       return new atomicIncrement_args(this);
19872     }
19873 
19874     /**
19875      * name of table
19876      */
19877     public byte[] getTableName() {
19878       return this.tableName;
19879     }
19880 
19881     /**
19882      * name of table
19883      */
19884     public atomicIncrement_args setTableName(byte[] tableName) {
19885       this.tableName = tableName;
19886       return this;
19887     }
19888 
19889     public void unsetTableName() {
19890       this.tableName = null;
19891     }
19892 
19893     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
19894     public boolean isSetTableName() {
19895       return this.tableName != null;
19896     }
19897 
19898     public void setTableNameIsSet(boolean value) {
19899       if (!value) {
19900         this.tableName = null;
19901       }
19902     }
19903 
19904     /**
19905      * row to increment
19906      */
19907     public byte[] getRow() {
19908       return this.row;
19909     }
19910 
19911     /**
19912      * row to increment
19913      */
19914     public atomicIncrement_args setRow(byte[] row) {
19915       this.row = row;
19916       return this;
19917     }
19918 
19919     public void unsetRow() {
19920       this.row = null;
19921     }
19922 
19923     /** Returns true if field row is set (has been asigned a value) and false otherwise */
19924     public boolean isSetRow() {
19925       return this.row != null;
19926     }
19927 
19928     public void setRowIsSet(boolean value) {
19929       if (!value) {
19930         this.row = null;
19931       }
19932     }
19933 
19934     /**
19935      * name of column
19936      */
19937     public byte[] getColumn() {
19938       return this.column;
19939     }
19940 
19941     /**
19942      * name of column
19943      */
19944     public atomicIncrement_args setColumn(byte[] column) {
19945       this.column = column;
19946       return this;
19947     }
19948 
19949     public void unsetColumn() {
19950       this.column = null;
19951     }
19952 
19953     /** Returns true if field column is set (has been asigned a value) and false otherwise */
19954     public boolean isSetColumn() {
19955       return this.column != null;
19956     }
19957 
19958     public void setColumnIsSet(boolean value) {
19959       if (!value) {
19960         this.column = null;
19961       }
19962     }
19963 
19964     /**
19965      * amount to increment by
19966      */
19967     public long getValue() {
19968       return this.value;
19969     }
19970 
19971     /**
19972      * amount to increment by
19973      */
19974     public atomicIncrement_args setValue(long value) {
19975       this.value = value;
19976       setValueIsSet(true);
19977       return this;
19978     }
19979 
19980     public void unsetValue() {
19981       __isset_bit_vector.clear(__VALUE_ISSET_ID);
19982     }
19983 
19984     /** Returns true if field value is set (has been asigned a value) and false otherwise */
19985     public boolean isSetValue() {
19986       return __isset_bit_vector.get(__VALUE_ISSET_ID);
19987     }
19988 
19989     public void setValueIsSet(boolean value) {
19990       __isset_bit_vector.set(__VALUE_ISSET_ID, value);
19991     }
19992 
19993     public void setFieldValue(_Fields field, Object value) {
19994       switch (field) {
19995       case TABLE_NAME:
19996         if (value == null) {
19997           unsetTableName();
19998         } else {
19999           setTableName((byte[])value);
20000         }
20001         break;
20002 
20003       case ROW:
20004         if (value == null) {
20005           unsetRow();
20006         } else {
20007           setRow((byte[])value);
20008         }
20009         break;
20010 
20011       case COLUMN:
20012         if (value == null) {
20013           unsetColumn();
20014         } else {
20015           setColumn((byte[])value);
20016         }
20017         break;
20018 
20019       case VALUE:
20020         if (value == null) {
20021           unsetValue();
20022         } else {
20023           setValue((Long)value);
20024         }
20025         break;
20026 
20027       }
20028     }
20029 
20030     public void setFieldValue(int fieldID, Object value) {
20031       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
20032     }
20033 
20034     public Object getFieldValue(_Fields field) {
20035       switch (field) {
20036       case TABLE_NAME:
20037         return getTableName();
20038 
20039       case ROW:
20040         return getRow();
20041 
20042       case COLUMN:
20043         return getColumn();
20044 
20045       case VALUE:
20046         return new Long(getValue());
20047 
20048       }
20049       throw new IllegalStateException();
20050     }
20051 
20052     public Object getFieldValue(int fieldId) {
20053       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
20054     }
20055 
20056     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
20057     public boolean isSet(_Fields field) {
20058       switch (field) {
20059       case TABLE_NAME:
20060         return isSetTableName();
20061       case ROW:
20062         return isSetRow();
20063       case COLUMN:
20064         return isSetColumn();
20065       case VALUE:
20066         return isSetValue();
20067       }
20068       throw new IllegalStateException();
20069     }
20070 
20071     public boolean isSet(int fieldID) {
20072       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
20073     }
20074 
20075     @Override
20076     public boolean equals(Object that) {
20077       if (that == null)
20078         return false;
20079       if (that instanceof atomicIncrement_args)
20080         return this.equals((atomicIncrement_args)that);
20081       return false;
20082     }
20083 
20084     public boolean equals(atomicIncrement_args that) {
20085       if (that == null)
20086         return false;
20087 
20088       boolean this_present_tableName = true && this.isSetTableName();
20089       boolean that_present_tableName = true && that.isSetTableName();
20090       if (this_present_tableName || that_present_tableName) {
20091         if (!(this_present_tableName && that_present_tableName))
20092           return false;
20093         if (!java.util.Arrays.equals(this.tableName, that.tableName))
20094           return false;
20095       }
20096 
20097       boolean this_present_row = true && this.isSetRow();
20098       boolean that_present_row = true && that.isSetRow();
20099       if (this_present_row || that_present_row) {
20100         if (!(this_present_row && that_present_row))
20101           return false;
20102         if (!java.util.Arrays.equals(this.row, that.row))
20103           return false;
20104       }
20105 
20106       boolean this_present_column = true && this.isSetColumn();
20107       boolean that_present_column = true && that.isSetColumn();
20108       if (this_present_column || that_present_column) {
20109         if (!(this_present_column && that_present_column))
20110           return false;
20111         if (!java.util.Arrays.equals(this.column, that.column))
20112           return false;
20113       }
20114 
20115       boolean this_present_value = true;
20116       boolean that_present_value = true;
20117       if (this_present_value || that_present_value) {
20118         if (!(this_present_value && that_present_value))
20119           return false;
20120         if (this.value != that.value)
20121           return false;
20122       }
20123 
20124       return true;
20125     }
20126 
20127     @Override
20128     public int hashCode() {
20129       HashCodeBuilder builder = new HashCodeBuilder();
20130 
20131       boolean present_tableName = true && (isSetTableName());
20132       builder.append(present_tableName);
20133       if (present_tableName)
20134         builder.append(tableName);
20135 
20136       boolean present_row = true && (isSetRow());
20137       builder.append(present_row);
20138       if (present_row)
20139         builder.append(row);
20140 
20141       boolean present_column = true && (isSetColumn());
20142       builder.append(present_column);
20143       if (present_column)
20144         builder.append(column);
20145 
20146       boolean present_value = true;
20147       builder.append(present_value);
20148       if (present_value)
20149         builder.append(value);
20150 
20151       return builder.toHashCode();
20152     }
20153 
20154     public int compareTo(atomicIncrement_args other) {
20155       if (!getClass().equals(other.getClass())) {
20156         return getClass().getName().compareTo(other.getClass().getName());
20157       }
20158 
20159       int lastComparison = 0;
20160       atomicIncrement_args typedOther = (atomicIncrement_args)other;
20161 
20162       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
20163       if (lastComparison != 0) {
20164         return lastComparison;
20165       }
20166       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
20167       if (lastComparison != 0) {
20168         return lastComparison;
20169       }
20170       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
20171       if (lastComparison != 0) {
20172         return lastComparison;
20173       }
20174       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
20175       if (lastComparison != 0) {
20176         return lastComparison;
20177       }
20178       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
20179       if (lastComparison != 0) {
20180         return lastComparison;
20181       }
20182       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
20183       if (lastComparison != 0) {
20184         return lastComparison;
20185       }
20186       lastComparison = Boolean.valueOf(isSetValue()).compareTo(isSetValue());
20187       if (lastComparison != 0) {
20188         return lastComparison;
20189       }
20190       lastComparison = TBaseHelper.compareTo(value, typedOther.value);
20191       if (lastComparison != 0) {
20192         return lastComparison;
20193       }
20194       return 0;
20195     }
20196 
20197     public void read(TProtocol iprot) throws TException {
20198       TField field;
20199       iprot.readStructBegin();
20200       while (true)
20201       {
20202         field = iprot.readFieldBegin();
20203         if (field.type == TType.STOP) {
20204           break;
20205         }
20206         _Fields fieldId = _Fields.findByThriftId(field.id);
20207         if (fieldId == null) {
20208           TProtocolUtil.skip(iprot, field.type);
20209         } else {
20210           switch (fieldId) {
20211             case TABLE_NAME:
20212               if (field.type == TType.STRING) {
20213                 this.tableName = iprot.readBinary();
20214               } else {
20215                 TProtocolUtil.skip(iprot, field.type);
20216               }
20217               break;
20218             case ROW:
20219               if (field.type == TType.STRING) {
20220                 this.row = iprot.readBinary();
20221               } else {
20222                 TProtocolUtil.skip(iprot, field.type);
20223               }
20224               break;
20225             case COLUMN:
20226               if (field.type == TType.STRING) {
20227                 this.column = iprot.readBinary();
20228               } else {
20229                 TProtocolUtil.skip(iprot, field.type);
20230               }
20231               break;
20232             case VALUE:
20233               if (field.type == TType.I64) {
20234                 this.value = iprot.readI64();
20235                 setValueIsSet(true);
20236               } else {
20237                 TProtocolUtil.skip(iprot, field.type);
20238               }
20239               break;
20240           }
20241           iprot.readFieldEnd();
20242         }
20243       }
20244       iprot.readStructEnd();
20245 
20246       // check for required fields of primitive type, which can't be checked in the validate method
20247       validate();
20248     }
20249 
20250     public void write(TProtocol oprot) throws TException {
20251       validate();
20252 
20253       oprot.writeStructBegin(STRUCT_DESC);
20254       if (this.tableName != null) {
20255         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
20256         oprot.writeBinary(this.tableName);
20257         oprot.writeFieldEnd();
20258       }
20259       if (this.row != null) {
20260         oprot.writeFieldBegin(ROW_FIELD_DESC);
20261         oprot.writeBinary(this.row);
20262         oprot.writeFieldEnd();
20263       }
20264       if (this.column != null) {
20265         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
20266         oprot.writeBinary(this.column);
20267         oprot.writeFieldEnd();
20268       }
20269       oprot.writeFieldBegin(VALUE_FIELD_DESC);
20270       oprot.writeI64(this.value);
20271       oprot.writeFieldEnd();
20272       oprot.writeFieldStop();
20273       oprot.writeStructEnd();
20274     }
20275 
20276     @Override
20277     public String toString() {
20278       StringBuilder sb = new StringBuilder("atomicIncrement_args(");
20279       boolean first = true;
20280 
20281       sb.append("tableName:");
20282       if (this.tableName == null) {
20283         sb.append("null");
20284       } else {
20285         sb.append(this.tableName);
20286       }
20287       first = false;
20288       if (!first) sb.append(", ");
20289       sb.append("row:");
20290       if (this.row == null) {
20291         sb.append("null");
20292       } else {
20293         sb.append(this.row);
20294       }
20295       first = false;
20296       if (!first) sb.append(", ");
20297       sb.append("column:");
20298       if (this.column == null) {
20299         sb.append("null");
20300       } else {
20301         sb.append(this.column);
20302       }
20303       first = false;
20304       if (!first) sb.append(", ");
20305       sb.append("value:");
20306       sb.append(this.value);
20307       first = false;
20308       sb.append(")");
20309       return sb.toString();
20310     }
20311 
20312     public void validate() throws TException {
20313       // check for required fields
20314     }
20315 
20316   }
20317 
20318   public static class atomicIncrement_result implements TBase<atomicIncrement_result._Fields>, java.io.Serializable, Cloneable, Comparable<atomicIncrement_result>   {
20319     private static final TStruct STRUCT_DESC = new TStruct("atomicIncrement_result");
20320 
20321     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short)0);
20322     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
20323     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
20324 
20325     public long success;
20326     public IOError io;
20327     public IllegalArgument ia;
20328 
20329     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
20330     public enum _Fields implements TFieldIdEnum {
20331       SUCCESS((short)0, "success"),
20332       IO((short)1, "io"),
20333       IA((short)2, "ia");
20334 
20335       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
20336       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
20337 
20338       static {
20339         for (_Fields field : EnumSet.allOf(_Fields.class)) {
20340           byId.put((int)field._thriftId, field);
20341           byName.put(field.getFieldName(), field);
20342         }
20343       }
20344 
20345       /**
20346        * Find the _Fields constant that matches fieldId, or null if its not found.
20347        */
20348       public static _Fields findByThriftId(int fieldId) {
20349         return byId.get(fieldId);
20350       }
20351 
20352       /**
20353        * Find the _Fields constant that matches fieldId, throwing an exception
20354        * if it is not found.
20355        */
20356       public static _Fields findByThriftIdOrThrow(int fieldId) {
20357         _Fields fields = findByThriftId(fieldId);
20358         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
20359         return fields;
20360       }
20361 
20362       /**
20363        * Find the _Fields constant that matches name, or null if its not found.
20364        */
20365       public static _Fields findByName(String name) {
20366         return byName.get(name);
20367       }
20368 
20369       private final short _thriftId;
20370       private final String _fieldName;
20371 
20372       _Fields(short thriftId, String fieldName) {
20373         _thriftId = thriftId;
20374         _fieldName = fieldName;
20375       }
20376 
20377       public short getThriftFieldId() {
20378         return _thriftId;
20379       }
20380 
20381       public String getFieldName() {
20382         return _fieldName;
20383       }
20384     }
20385 
20386     // isset id assignments
20387     private static final int __SUCCESS_ISSET_ID = 0;
20388     private BitSet __isset_bit_vector = new BitSet(1);
20389 
20390     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
20391       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
20392           new FieldValueMetaData(TType.I64)));
20393       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
20394           new FieldValueMetaData(TType.STRUCT)));
20395       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
20396           new FieldValueMetaData(TType.STRUCT)));
20397     }});
20398 
20399     static {
20400       FieldMetaData.addStructMetaDataMap(atomicIncrement_result.class, metaDataMap);
20401     }
20402 
20403     public atomicIncrement_result() {
20404     }
20405 
20406     public atomicIncrement_result(
20407       long success,
20408       IOError io,
20409       IllegalArgument ia)
20410     {
20411       this();
20412       this.success = success;
20413       setSuccessIsSet(true);
20414       this.io = io;
20415       this.ia = ia;
20416     }
20417 
20418     /**
20419      * Performs a deep copy on <i>other</i>.
20420      */
20421     public atomicIncrement_result(atomicIncrement_result other) {
20422       __isset_bit_vector.clear();
20423       __isset_bit_vector.or(other.__isset_bit_vector);
20424       this.success = other.success;
20425       if (other.isSetIo()) {
20426         this.io = new IOError(other.io);
20427       }
20428       if (other.isSetIa()) {
20429         this.ia = new IllegalArgument(other.ia);
20430       }
20431     }
20432 
20433     public atomicIncrement_result deepCopy() {
20434       return new atomicIncrement_result(this);
20435     }
20436 
20437     @Deprecated
20438     public atomicIncrement_result clone() {
20439       return new atomicIncrement_result(this);
20440     }
20441 
20442     public long getSuccess() {
20443       return this.success;
20444     }
20445 
20446     public atomicIncrement_result setSuccess(long success) {
20447       this.success = success;
20448       setSuccessIsSet(true);
20449       return this;
20450     }
20451 
20452     public void unsetSuccess() {
20453       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
20454     }
20455 
20456     /** Returns true if field success is set (has been asigned a value) and false otherwise */
20457     public boolean isSetSuccess() {
20458       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
20459     }
20460 
20461     public void setSuccessIsSet(boolean value) {
20462       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
20463     }
20464 
20465     public IOError getIo() {
20466       return this.io;
20467     }
20468 
20469     public atomicIncrement_result setIo(IOError io) {
20470       this.io = io;
20471       return this;
20472     }
20473 
20474     public void unsetIo() {
20475       this.io = null;
20476     }
20477 
20478     /** Returns true if field io is set (has been asigned a value) and false otherwise */
20479     public boolean isSetIo() {
20480       return this.io != null;
20481     }
20482 
20483     public void setIoIsSet(boolean value) {
20484       if (!value) {
20485         this.io = null;
20486       }
20487     }
20488 
20489     public IllegalArgument getIa() {
20490       return this.ia;
20491     }
20492 
20493     public atomicIncrement_result setIa(IllegalArgument ia) {
20494       this.ia = ia;
20495       return this;
20496     }
20497 
20498     public void unsetIa() {
20499       this.ia = null;
20500     }
20501 
20502     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
20503     public boolean isSetIa() {
20504       return this.ia != null;
20505     }
20506 
20507     public void setIaIsSet(boolean value) {
20508       if (!value) {
20509         this.ia = null;
20510       }
20511     }
20512 
20513     public void setFieldValue(_Fields field, Object value) {
20514       switch (field) {
20515       case SUCCESS:
20516         if (value == null) {
20517           unsetSuccess();
20518         } else {
20519           setSuccess((Long)value);
20520         }
20521         break;
20522 
20523       case IO:
20524         if (value == null) {
20525           unsetIo();
20526         } else {
20527           setIo((IOError)value);
20528         }
20529         break;
20530 
20531       case IA:
20532         if (value == null) {
20533           unsetIa();
20534         } else {
20535           setIa((IllegalArgument)value);
20536         }
20537         break;
20538 
20539       }
20540     }
20541 
20542     public void setFieldValue(int fieldID, Object value) {
20543       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
20544     }
20545 
20546     public Object getFieldValue(_Fields field) {
20547       switch (field) {
20548       case SUCCESS:
20549         return new Long(getSuccess());
20550 
20551       case IO:
20552         return getIo();
20553 
20554       case IA:
20555         return getIa();
20556 
20557       }
20558       throw new IllegalStateException();
20559     }
20560 
20561     public Object getFieldValue(int fieldId) {
20562       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
20563     }
20564 
20565     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
20566     public boolean isSet(_Fields field) {
20567       switch (field) {
20568       case SUCCESS:
20569         return isSetSuccess();
20570       case IO:
20571         return isSetIo();
20572       case IA:
20573         return isSetIa();
20574       }
20575       throw new IllegalStateException();
20576     }
20577 
20578     public boolean isSet(int fieldID) {
20579       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
20580     }
20581 
20582     @Override
20583     public boolean equals(Object that) {
20584       if (that == null)
20585         return false;
20586       if (that instanceof atomicIncrement_result)
20587         return this.equals((atomicIncrement_result)that);
20588       return false;
20589     }
20590 
20591     public boolean equals(atomicIncrement_result that) {
20592       if (that == null)
20593         return false;
20594 
20595       boolean this_present_success = true;
20596       boolean that_present_success = true;
20597       if (this_present_success || that_present_success) {
20598         if (!(this_present_success && that_present_success))
20599           return false;
20600         if (this.success != that.success)
20601           return false;
20602       }
20603 
20604       boolean this_present_io = true && this.isSetIo();
20605       boolean that_present_io = true && that.isSetIo();
20606       if (this_present_io || that_present_io) {
20607         if (!(this_present_io && that_present_io))
20608           return false;
20609         if (!this.io.equals(that.io))
20610           return false;
20611       }
20612 
20613       boolean this_present_ia = true && this.isSetIa();
20614       boolean that_present_ia = true && that.isSetIa();
20615       if (this_present_ia || that_present_ia) {
20616         if (!(this_present_ia && that_present_ia))
20617           return false;
20618         if (!this.ia.equals(that.ia))
20619           return false;
20620       }
20621 
20622       return true;
20623     }
20624 
20625     @Override
20626     public int hashCode() {
20627       HashCodeBuilder builder = new HashCodeBuilder();
20628 
20629       boolean present_success = true;
20630       builder.append(present_success);
20631       if (present_success)
20632         builder.append(success);
20633 
20634       boolean present_io = true && (isSetIo());
20635       builder.append(present_io);
20636       if (present_io)
20637         builder.append(io);
20638 
20639       boolean present_ia = true && (isSetIa());
20640       builder.append(present_ia);
20641       if (present_ia)
20642         builder.append(ia);
20643 
20644       return builder.toHashCode();
20645     }
20646 
20647     public int compareTo(atomicIncrement_result other) {
20648       if (!getClass().equals(other.getClass())) {
20649         return getClass().getName().compareTo(other.getClass().getName());
20650       }
20651 
20652       int lastComparison = 0;
20653       atomicIncrement_result typedOther = (atomicIncrement_result)other;
20654 
20655       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
20656       if (lastComparison != 0) {
20657         return lastComparison;
20658       }
20659       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
20660       if (lastComparison != 0) {
20661         return lastComparison;
20662       }
20663       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
20664       if (lastComparison != 0) {
20665         return lastComparison;
20666       }
20667       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
20668       if (lastComparison != 0) {
20669         return lastComparison;
20670       }
20671       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
20672       if (lastComparison != 0) {
20673         return lastComparison;
20674       }
20675       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
20676       if (lastComparison != 0) {
20677         return lastComparison;
20678       }
20679       return 0;
20680     }
20681 
20682     public void read(TProtocol iprot) throws TException {
20683       TField field;
20684       iprot.readStructBegin();
20685       while (true)
20686       {
20687         field = iprot.readFieldBegin();
20688         if (field.type == TType.STOP) {
20689           break;
20690         }
20691         _Fields fieldId = _Fields.findByThriftId(field.id);
20692         if (fieldId == null) {
20693           TProtocolUtil.skip(iprot, field.type);
20694         } else {
20695           switch (fieldId) {
20696             case SUCCESS:
20697               if (field.type == TType.I64) {
20698                 this.success = iprot.readI64();
20699                 setSuccessIsSet(true);
20700               } else {
20701                 TProtocolUtil.skip(iprot, field.type);
20702               }
20703               break;
20704             case IO:
20705               if (field.type == TType.STRUCT) {
20706                 this.io = new IOError();
20707                 this.io.read(iprot);
20708               } else {
20709                 TProtocolUtil.skip(iprot, field.type);
20710               }
20711               break;
20712             case IA:
20713               if (field.type == TType.STRUCT) {
20714                 this.ia = new IllegalArgument();
20715                 this.ia.read(iprot);
20716               } else {
20717                 TProtocolUtil.skip(iprot, field.type);
20718               }
20719               break;
20720           }
20721           iprot.readFieldEnd();
20722         }
20723       }
20724       iprot.readStructEnd();
20725 
20726       // check for required fields of primitive type, which can't be checked in the validate method
20727       validate();
20728     }
20729 
20730     public void write(TProtocol oprot) throws TException {
20731       oprot.writeStructBegin(STRUCT_DESC);
20732 
20733       if (this.isSetSuccess()) {
20734         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20735         oprot.writeI64(this.success);
20736         oprot.writeFieldEnd();
20737       } else if (this.isSetIo()) {
20738         oprot.writeFieldBegin(IO_FIELD_DESC);
20739         this.io.write(oprot);
20740         oprot.writeFieldEnd();
20741       } else if (this.isSetIa()) {
20742         oprot.writeFieldBegin(IA_FIELD_DESC);
20743         this.ia.write(oprot);
20744         oprot.writeFieldEnd();
20745       }
20746       oprot.writeFieldStop();
20747       oprot.writeStructEnd();
20748     }
20749 
20750     @Override
20751     public String toString() {
20752       StringBuilder sb = new StringBuilder("atomicIncrement_result(");
20753       boolean first = true;
20754 
20755       sb.append("success:");
20756       sb.append(this.success);
20757       first = false;
20758       if (!first) sb.append(", ");
20759       sb.append("io:");
20760       if (this.io == null) {
20761         sb.append("null");
20762       } else {
20763         sb.append(this.io);
20764       }
20765       first = false;
20766       if (!first) sb.append(", ");
20767       sb.append("ia:");
20768       if (this.ia == null) {
20769         sb.append("null");
20770       } else {
20771         sb.append(this.ia);
20772       }
20773       first = false;
20774       sb.append(")");
20775       return sb.toString();
20776     }
20777 
20778     public void validate() throws TException {
20779       // check for required fields
20780     }
20781 
20782   }
20783 
20784   public static class deleteAll_args implements TBase<deleteAll_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_args>   {
20785     private static final TStruct STRUCT_DESC = new TStruct("deleteAll_args");
20786 
20787     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
20788     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
20789     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
20790 
20791     /**
20792      * name of table
20793      */
20794     public byte[] tableName;
20795     /**
20796      * Row to update
20797      */
20798     public byte[] row;
20799     /**
20800      * name of column whose value is to be deleted
20801      */
20802     public byte[] column;
20803 
20804     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
20805     public enum _Fields implements TFieldIdEnum {
20806       /**
20807        * name of table
20808        */
20809       TABLE_NAME((short)1, "tableName"),
20810       /**
20811        * Row to update
20812        */
20813       ROW((short)2, "row"),
20814       /**
20815        * name of column whose value is to be deleted
20816        */
20817       COLUMN((short)3, "column");
20818 
20819       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
20820       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
20821 
20822       static {
20823         for (_Fields field : EnumSet.allOf(_Fields.class)) {
20824           byId.put((int)field._thriftId, field);
20825           byName.put(field.getFieldName(), field);
20826         }
20827       }
20828 
20829       /**
20830        * Find the _Fields constant that matches fieldId, or null if its not found.
20831        */
20832       public static _Fields findByThriftId(int fieldId) {
20833         return byId.get(fieldId);
20834       }
20835 
20836       /**
20837        * Find the _Fields constant that matches fieldId, throwing an exception
20838        * if it is not found.
20839        */
20840       public static _Fields findByThriftIdOrThrow(int fieldId) {
20841         _Fields fields = findByThriftId(fieldId);
20842         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
20843         return fields;
20844       }
20845 
20846       /**
20847        * Find the _Fields constant that matches name, or null if its not found.
20848        */
20849       public static _Fields findByName(String name) {
20850         return byName.get(name);
20851       }
20852 
20853       private final short _thriftId;
20854       private final String _fieldName;
20855 
20856       _Fields(short thriftId, String fieldName) {
20857         _thriftId = thriftId;
20858         _fieldName = fieldName;
20859       }
20860 
20861       public short getThriftFieldId() {
20862         return _thriftId;
20863       }
20864 
20865       public String getFieldName() {
20866         return _fieldName;
20867       }
20868     }
20869 
20870     // isset id assignments
20871 
20872     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
20873       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
20874           new FieldValueMetaData(TType.STRING)));
20875       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
20876           new FieldValueMetaData(TType.STRING)));
20877       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
20878           new FieldValueMetaData(TType.STRING)));
20879     }});
20880 
20881     static {
20882       FieldMetaData.addStructMetaDataMap(deleteAll_args.class, metaDataMap);
20883     }
20884 
20885     public deleteAll_args() {
20886     }
20887 
20888     public deleteAll_args(
20889       byte[] tableName,
20890       byte[] row,
20891       byte[] column)
20892     {
20893       this();
20894       this.tableName = tableName;
20895       this.row = row;
20896       this.column = column;
20897     }
20898 
20899     /**
20900      * Performs a deep copy on <i>other</i>.
20901      */
20902     public deleteAll_args(deleteAll_args other) {
20903       if (other.isSetTableName()) {
20904         this.tableName = other.tableName;
20905       }
20906       if (other.isSetRow()) {
20907         this.row = other.row;
20908       }
20909       if (other.isSetColumn()) {
20910         this.column = other.column;
20911       }
20912     }
20913 
20914     public deleteAll_args deepCopy() {
20915       return new deleteAll_args(this);
20916     }
20917 
20918     @Deprecated
20919     public deleteAll_args clone() {
20920       return new deleteAll_args(this);
20921     }
20922 
20923     /**
20924      * name of table
20925      */
20926     public byte[] getTableName() {
20927       return this.tableName;
20928     }
20929 
20930     /**
20931      * name of table
20932      */
20933     public deleteAll_args setTableName(byte[] tableName) {
20934       this.tableName = tableName;
20935       return this;
20936     }
20937 
20938     public void unsetTableName() {
20939       this.tableName = null;
20940     }
20941 
20942     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
20943     public boolean isSetTableName() {
20944       return this.tableName != null;
20945     }
20946 
20947     public void setTableNameIsSet(boolean value) {
20948       if (!value) {
20949         this.tableName = null;
20950       }
20951     }
20952 
20953     /**
20954      * Row to update
20955      */
20956     public byte[] getRow() {
20957       return this.row;
20958     }
20959 
20960     /**
20961      * Row to update
20962      */
20963     public deleteAll_args setRow(byte[] row) {
20964       this.row = row;
20965       return this;
20966     }
20967 
20968     public void unsetRow() {
20969       this.row = null;
20970     }
20971 
20972     /** Returns true if field row is set (has been asigned a value) and false otherwise */
20973     public boolean isSetRow() {
20974       return this.row != null;
20975     }
20976 
20977     public void setRowIsSet(boolean value) {
20978       if (!value) {
20979         this.row = null;
20980       }
20981     }
20982 
20983     /**
20984      * name of column whose value is to be deleted
20985      */
20986     public byte[] getColumn() {
20987       return this.column;
20988     }
20989 
20990     /**
20991      * name of column whose value is to be deleted
20992      */
20993     public deleteAll_args setColumn(byte[] column) {
20994       this.column = column;
20995       return this;
20996     }
20997 
20998     public void unsetColumn() {
20999       this.column = null;
21000     }
21001 
21002     /** Returns true if field column is set (has been asigned a value) and false otherwise */
21003     public boolean isSetColumn() {
21004       return this.column != null;
21005     }
21006 
21007     public void setColumnIsSet(boolean value) {
21008       if (!value) {
21009         this.column = null;
21010       }
21011     }
21012 
21013     public void setFieldValue(_Fields field, Object value) {
21014       switch (field) {
21015       case TABLE_NAME:
21016         if (value == null) {
21017           unsetTableName();
21018         } else {
21019           setTableName((byte[])value);
21020         }
21021         break;
21022 
21023       case ROW:
21024         if (value == null) {
21025           unsetRow();
21026         } else {
21027           setRow((byte[])value);
21028         }
21029         break;
21030 
21031       case COLUMN:
21032         if (value == null) {
21033           unsetColumn();
21034         } else {
21035           setColumn((byte[])value);
21036         }
21037         break;
21038 
21039       }
21040     }
21041 
21042     public void setFieldValue(int fieldID, Object value) {
21043       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21044     }
21045 
21046     public Object getFieldValue(_Fields field) {
21047       switch (field) {
21048       case TABLE_NAME:
21049         return getTableName();
21050 
21051       case ROW:
21052         return getRow();
21053 
21054       case COLUMN:
21055         return getColumn();
21056 
21057       }
21058       throw new IllegalStateException();
21059     }
21060 
21061     public Object getFieldValue(int fieldId) {
21062       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21063     }
21064 
21065     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
21066     public boolean isSet(_Fields field) {
21067       switch (field) {
21068       case TABLE_NAME:
21069         return isSetTableName();
21070       case ROW:
21071         return isSetRow();
21072       case COLUMN:
21073         return isSetColumn();
21074       }
21075       throw new IllegalStateException();
21076     }
21077 
21078     public boolean isSet(int fieldID) {
21079       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21080     }
21081 
21082     @Override
21083     public boolean equals(Object that) {
21084       if (that == null)
21085         return false;
21086       if (that instanceof deleteAll_args)
21087         return this.equals((deleteAll_args)that);
21088       return false;
21089     }
21090 
21091     public boolean equals(deleteAll_args that) {
21092       if (that == null)
21093         return false;
21094 
21095       boolean this_present_tableName = true && this.isSetTableName();
21096       boolean that_present_tableName = true && that.isSetTableName();
21097       if (this_present_tableName || that_present_tableName) {
21098         if (!(this_present_tableName && that_present_tableName))
21099           return false;
21100         if (!java.util.Arrays.equals(this.tableName, that.tableName))
21101           return false;
21102       }
21103 
21104       boolean this_present_row = true && this.isSetRow();
21105       boolean that_present_row = true && that.isSetRow();
21106       if (this_present_row || that_present_row) {
21107         if (!(this_present_row && that_present_row))
21108           return false;
21109         if (!java.util.Arrays.equals(this.row, that.row))
21110           return false;
21111       }
21112 
21113       boolean this_present_column = true && this.isSetColumn();
21114       boolean that_present_column = true && that.isSetColumn();
21115       if (this_present_column || that_present_column) {
21116         if (!(this_present_column && that_present_column))
21117           return false;
21118         if (!java.util.Arrays.equals(this.column, that.column))
21119           return false;
21120       }
21121 
21122       return true;
21123     }
21124 
21125     @Override
21126     public int hashCode() {
21127       HashCodeBuilder builder = new HashCodeBuilder();
21128 
21129       boolean present_tableName = true && (isSetTableName());
21130       builder.append(present_tableName);
21131       if (present_tableName)
21132         builder.append(tableName);
21133 
21134       boolean present_row = true && (isSetRow());
21135       builder.append(present_row);
21136       if (present_row)
21137         builder.append(row);
21138 
21139       boolean present_column = true && (isSetColumn());
21140       builder.append(present_column);
21141       if (present_column)
21142         builder.append(column);
21143 
21144       return builder.toHashCode();
21145     }
21146 
21147     public int compareTo(deleteAll_args other) {
21148       if (!getClass().equals(other.getClass())) {
21149         return getClass().getName().compareTo(other.getClass().getName());
21150       }
21151 
21152       int lastComparison = 0;
21153       deleteAll_args typedOther = (deleteAll_args)other;
21154 
21155       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
21156       if (lastComparison != 0) {
21157         return lastComparison;
21158       }
21159       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
21160       if (lastComparison != 0) {
21161         return lastComparison;
21162       }
21163       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
21164       if (lastComparison != 0) {
21165         return lastComparison;
21166       }
21167       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
21168       if (lastComparison != 0) {
21169         return lastComparison;
21170       }
21171       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
21172       if (lastComparison != 0) {
21173         return lastComparison;
21174       }
21175       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
21176       if (lastComparison != 0) {
21177         return lastComparison;
21178       }
21179       return 0;
21180     }
21181 
21182     public void read(TProtocol iprot) throws TException {
21183       TField field;
21184       iprot.readStructBegin();
21185       while (true)
21186       {
21187         field = iprot.readFieldBegin();
21188         if (field.type == TType.STOP) {
21189           break;
21190         }
21191         _Fields fieldId = _Fields.findByThriftId(field.id);
21192         if (fieldId == null) {
21193           TProtocolUtil.skip(iprot, field.type);
21194         } else {
21195           switch (fieldId) {
21196             case TABLE_NAME:
21197               if (field.type == TType.STRING) {
21198                 this.tableName = iprot.readBinary();
21199               } else {
21200                 TProtocolUtil.skip(iprot, field.type);
21201               }
21202               break;
21203             case ROW:
21204               if (field.type == TType.STRING) {
21205                 this.row = iprot.readBinary();
21206               } else {
21207                 TProtocolUtil.skip(iprot, field.type);
21208               }
21209               break;
21210             case COLUMN:
21211               if (field.type == TType.STRING) {
21212                 this.column = iprot.readBinary();
21213               } else {
21214                 TProtocolUtil.skip(iprot, field.type);
21215               }
21216               break;
21217           }
21218           iprot.readFieldEnd();
21219         }
21220       }
21221       iprot.readStructEnd();
21222 
21223       // check for required fields of primitive type, which can't be checked in the validate method
21224       validate();
21225     }
21226 
21227     public void write(TProtocol oprot) throws TException {
21228       validate();
21229 
21230       oprot.writeStructBegin(STRUCT_DESC);
21231       if (this.tableName != null) {
21232         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
21233         oprot.writeBinary(this.tableName);
21234         oprot.writeFieldEnd();
21235       }
21236       if (this.row != null) {
21237         oprot.writeFieldBegin(ROW_FIELD_DESC);
21238         oprot.writeBinary(this.row);
21239         oprot.writeFieldEnd();
21240       }
21241       if (this.column != null) {
21242         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
21243         oprot.writeBinary(this.column);
21244         oprot.writeFieldEnd();
21245       }
21246       oprot.writeFieldStop();
21247       oprot.writeStructEnd();
21248     }
21249 
21250     @Override
21251     public String toString() {
21252       StringBuilder sb = new StringBuilder("deleteAll_args(");
21253       boolean first = true;
21254 
21255       sb.append("tableName:");
21256       if (this.tableName == null) {
21257         sb.append("null");
21258       } else {
21259         sb.append(this.tableName);
21260       }
21261       first = false;
21262       if (!first) sb.append(", ");
21263       sb.append("row:");
21264       if (this.row == null) {
21265         sb.append("null");
21266       } else {
21267         sb.append(this.row);
21268       }
21269       first = false;
21270       if (!first) sb.append(", ");
21271       sb.append("column:");
21272       if (this.column == null) {
21273         sb.append("null");
21274       } else {
21275         sb.append(this.column);
21276       }
21277       first = false;
21278       sb.append(")");
21279       return sb.toString();
21280     }
21281 
21282     public void validate() throws TException {
21283       // check for required fields
21284     }
21285 
21286   }
21287 
21288   public static class deleteAll_result implements TBase<deleteAll_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAll_result>   {
21289     private static final TStruct STRUCT_DESC = new TStruct("deleteAll_result");
21290 
21291     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
21292 
21293     public IOError io;
21294 
21295     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
21296     public enum _Fields implements TFieldIdEnum {
21297       IO((short)1, "io");
21298 
21299       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
21300       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
21301 
21302       static {
21303         for (_Fields field : EnumSet.allOf(_Fields.class)) {
21304           byId.put((int)field._thriftId, field);
21305           byName.put(field.getFieldName(), field);
21306         }
21307       }
21308 
21309       /**
21310        * Find the _Fields constant that matches fieldId, or null if its not found.
21311        */
21312       public static _Fields findByThriftId(int fieldId) {
21313         return byId.get(fieldId);
21314       }
21315 
21316       /**
21317        * Find the _Fields constant that matches fieldId, throwing an exception
21318        * if it is not found.
21319        */
21320       public static _Fields findByThriftIdOrThrow(int fieldId) {
21321         _Fields fields = findByThriftId(fieldId);
21322         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
21323         return fields;
21324       }
21325 
21326       /**
21327        * Find the _Fields constant that matches name, or null if its not found.
21328        */
21329       public static _Fields findByName(String name) {
21330         return byName.get(name);
21331       }
21332 
21333       private final short _thriftId;
21334       private final String _fieldName;
21335 
21336       _Fields(short thriftId, String fieldName) {
21337         _thriftId = thriftId;
21338         _fieldName = fieldName;
21339       }
21340 
21341       public short getThriftFieldId() {
21342         return _thriftId;
21343       }
21344 
21345       public String getFieldName() {
21346         return _fieldName;
21347       }
21348     }
21349 
21350     // isset id assignments
21351 
21352     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
21353       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
21354           new FieldValueMetaData(TType.STRUCT)));
21355     }});
21356 
21357     static {
21358       FieldMetaData.addStructMetaDataMap(deleteAll_result.class, metaDataMap);
21359     }
21360 
21361     public deleteAll_result() {
21362     }
21363 
21364     public deleteAll_result(
21365       IOError io)
21366     {
21367       this();
21368       this.io = io;
21369     }
21370 
21371     /**
21372      * Performs a deep copy on <i>other</i>.
21373      */
21374     public deleteAll_result(deleteAll_result other) {
21375       if (other.isSetIo()) {
21376         this.io = new IOError(other.io);
21377       }
21378     }
21379 
21380     public deleteAll_result deepCopy() {
21381       return new deleteAll_result(this);
21382     }
21383 
21384     @Deprecated
21385     public deleteAll_result clone() {
21386       return new deleteAll_result(this);
21387     }
21388 
21389     public IOError getIo() {
21390       return this.io;
21391     }
21392 
21393     public deleteAll_result setIo(IOError io) {
21394       this.io = io;
21395       return this;
21396     }
21397 
21398     public void unsetIo() {
21399       this.io = null;
21400     }
21401 
21402     /** Returns true if field io is set (has been asigned a value) and false otherwise */
21403     public boolean isSetIo() {
21404       return this.io != null;
21405     }
21406 
21407     public void setIoIsSet(boolean value) {
21408       if (!value) {
21409         this.io = null;
21410       }
21411     }
21412 
21413     public void setFieldValue(_Fields field, Object value) {
21414       switch (field) {
21415       case IO:
21416         if (value == null) {
21417           unsetIo();
21418         } else {
21419           setIo((IOError)value);
21420         }
21421         break;
21422 
21423       }
21424     }
21425 
21426     public void setFieldValue(int fieldID, Object value) {
21427       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21428     }
21429 
21430     public Object getFieldValue(_Fields field) {
21431       switch (field) {
21432       case IO:
21433         return getIo();
21434 
21435       }
21436       throw new IllegalStateException();
21437     }
21438 
21439     public Object getFieldValue(int fieldId) {
21440       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21441     }
21442 
21443     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
21444     public boolean isSet(_Fields field) {
21445       switch (field) {
21446       case IO:
21447         return isSetIo();
21448       }
21449       throw new IllegalStateException();
21450     }
21451 
21452     public boolean isSet(int fieldID) {
21453       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21454     }
21455 
21456     @Override
21457     public boolean equals(Object that) {
21458       if (that == null)
21459         return false;
21460       if (that instanceof deleteAll_result)
21461         return this.equals((deleteAll_result)that);
21462       return false;
21463     }
21464 
21465     public boolean equals(deleteAll_result that) {
21466       if (that == null)
21467         return false;
21468 
21469       boolean this_present_io = true && this.isSetIo();
21470       boolean that_present_io = true && that.isSetIo();
21471       if (this_present_io || that_present_io) {
21472         if (!(this_present_io && that_present_io))
21473           return false;
21474         if (!this.io.equals(that.io))
21475           return false;
21476       }
21477 
21478       return true;
21479     }
21480 
21481     @Override
21482     public int hashCode() {
21483       HashCodeBuilder builder = new HashCodeBuilder();
21484 
21485       boolean present_io = true && (isSetIo());
21486       builder.append(present_io);
21487       if (present_io)
21488         builder.append(io);
21489 
21490       return builder.toHashCode();
21491     }
21492 
21493     public int compareTo(deleteAll_result other) {
21494       if (!getClass().equals(other.getClass())) {
21495         return getClass().getName().compareTo(other.getClass().getName());
21496       }
21497 
21498       int lastComparison = 0;
21499       deleteAll_result typedOther = (deleteAll_result)other;
21500 
21501       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
21502       if (lastComparison != 0) {
21503         return lastComparison;
21504       }
21505       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
21506       if (lastComparison != 0) {
21507         return lastComparison;
21508       }
21509       return 0;
21510     }
21511 
21512     public void read(TProtocol iprot) throws TException {
21513       TField field;
21514       iprot.readStructBegin();
21515       while (true)
21516       {
21517         field = iprot.readFieldBegin();
21518         if (field.type == TType.STOP) {
21519           break;
21520         }
21521         _Fields fieldId = _Fields.findByThriftId(field.id);
21522         if (fieldId == null) {
21523           TProtocolUtil.skip(iprot, field.type);
21524         } else {
21525           switch (fieldId) {
21526             case IO:
21527               if (field.type == TType.STRUCT) {
21528                 this.io = new IOError();
21529                 this.io.read(iprot);
21530               } else {
21531                 TProtocolUtil.skip(iprot, field.type);
21532               }
21533               break;
21534           }
21535           iprot.readFieldEnd();
21536         }
21537       }
21538       iprot.readStructEnd();
21539 
21540       // check for required fields of primitive type, which can't be checked in the validate method
21541       validate();
21542     }
21543 
21544     public void write(TProtocol oprot) throws TException {
21545       oprot.writeStructBegin(STRUCT_DESC);
21546 
21547       if (this.isSetIo()) {
21548         oprot.writeFieldBegin(IO_FIELD_DESC);
21549         this.io.write(oprot);
21550         oprot.writeFieldEnd();
21551       }
21552       oprot.writeFieldStop();
21553       oprot.writeStructEnd();
21554     }
21555 
21556     @Override
21557     public String toString() {
21558       StringBuilder sb = new StringBuilder("deleteAll_result(");
21559       boolean first = true;
21560 
21561       sb.append("io:");
21562       if (this.io == null) {
21563         sb.append("null");
21564       } else {
21565         sb.append(this.io);
21566       }
21567       first = false;
21568       sb.append(")");
21569       return sb.toString();
21570     }
21571 
21572     public void validate() throws TException {
21573       // check for required fields
21574     }
21575 
21576   }
21577 
21578   public static class deleteAllTs_args implements TBase<deleteAllTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_args>   {
21579     private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_args");
21580 
21581     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
21582     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
21583     private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRING, (short)3);
21584     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
21585 
21586     /**
21587      * name of table
21588      */
21589     public byte[] tableName;
21590     /**
21591      * Row to update
21592      */
21593     public byte[] row;
21594     /**
21595      * name of column whose value is to be deleted
21596      */
21597     public byte[] column;
21598     /**
21599      * timestamp
21600      */
21601     public long timestamp;
21602 
21603     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
21604     public enum _Fields implements TFieldIdEnum {
21605       /**
21606        * name of table
21607        */
21608       TABLE_NAME((short)1, "tableName"),
21609       /**
21610        * Row to update
21611        */
21612       ROW((short)2, "row"),
21613       /**
21614        * name of column whose value is to be deleted
21615        */
21616       COLUMN((short)3, "column"),
21617       /**
21618        * timestamp
21619        */
21620       TIMESTAMP((short)4, "timestamp");
21621 
21622       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
21623       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
21624 
21625       static {
21626         for (_Fields field : EnumSet.allOf(_Fields.class)) {
21627           byId.put((int)field._thriftId, field);
21628           byName.put(field.getFieldName(), field);
21629         }
21630       }
21631 
21632       /**
21633        * Find the _Fields constant that matches fieldId, or null if its not found.
21634        */
21635       public static _Fields findByThriftId(int fieldId) {
21636         return byId.get(fieldId);
21637       }
21638 
21639       /**
21640        * Find the _Fields constant that matches fieldId, throwing an exception
21641        * if it is not found.
21642        */
21643       public static _Fields findByThriftIdOrThrow(int fieldId) {
21644         _Fields fields = findByThriftId(fieldId);
21645         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
21646         return fields;
21647       }
21648 
21649       /**
21650        * Find the _Fields constant that matches name, or null if its not found.
21651        */
21652       public static _Fields findByName(String name) {
21653         return byName.get(name);
21654       }
21655 
21656       private final short _thriftId;
21657       private final String _fieldName;
21658 
21659       _Fields(short thriftId, String fieldName) {
21660         _thriftId = thriftId;
21661         _fieldName = fieldName;
21662       }
21663 
21664       public short getThriftFieldId() {
21665         return _thriftId;
21666       }
21667 
21668       public String getFieldName() {
21669         return _fieldName;
21670       }
21671     }
21672 
21673     // isset id assignments
21674     private static final int __TIMESTAMP_ISSET_ID = 0;
21675     private BitSet __isset_bit_vector = new BitSet(1);
21676 
21677     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
21678       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
21679           new FieldValueMetaData(TType.STRING)));
21680       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
21681           new FieldValueMetaData(TType.STRING)));
21682       put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.DEFAULT,
21683           new FieldValueMetaData(TType.STRING)));
21684       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
21685           new FieldValueMetaData(TType.I64)));
21686     }});
21687 
21688     static {
21689       FieldMetaData.addStructMetaDataMap(deleteAllTs_args.class, metaDataMap);
21690     }
21691 
21692     public deleteAllTs_args() {
21693     }
21694 
21695     public deleteAllTs_args(
21696       byte[] tableName,
21697       byte[] row,
21698       byte[] column,
21699       long timestamp)
21700     {
21701       this();
21702       this.tableName = tableName;
21703       this.row = row;
21704       this.column = column;
21705       this.timestamp = timestamp;
21706       setTimestampIsSet(true);
21707     }
21708 
21709     /**
21710      * Performs a deep copy on <i>other</i>.
21711      */
21712     public deleteAllTs_args(deleteAllTs_args other) {
21713       __isset_bit_vector.clear();
21714       __isset_bit_vector.or(other.__isset_bit_vector);
21715       if (other.isSetTableName()) {
21716         this.tableName = other.tableName;
21717       }
21718       if (other.isSetRow()) {
21719         this.row = other.row;
21720       }
21721       if (other.isSetColumn()) {
21722         this.column = other.column;
21723       }
21724       this.timestamp = other.timestamp;
21725     }
21726 
21727     public deleteAllTs_args deepCopy() {
21728       return new deleteAllTs_args(this);
21729     }
21730 
21731     @Deprecated
21732     public deleteAllTs_args clone() {
21733       return new deleteAllTs_args(this);
21734     }
21735 
21736     /**
21737      * name of table
21738      */
21739     public byte[] getTableName() {
21740       return this.tableName;
21741     }
21742 
21743     /**
21744      * name of table
21745      */
21746     public deleteAllTs_args setTableName(byte[] tableName) {
21747       this.tableName = tableName;
21748       return this;
21749     }
21750 
21751     public void unsetTableName() {
21752       this.tableName = null;
21753     }
21754 
21755     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
21756     public boolean isSetTableName() {
21757       return this.tableName != null;
21758     }
21759 
21760     public void setTableNameIsSet(boolean value) {
21761       if (!value) {
21762         this.tableName = null;
21763       }
21764     }
21765 
21766     /**
21767      * Row to update
21768      */
21769     public byte[] getRow() {
21770       return this.row;
21771     }
21772 
21773     /**
21774      * Row to update
21775      */
21776     public deleteAllTs_args setRow(byte[] row) {
21777       this.row = row;
21778       return this;
21779     }
21780 
21781     public void unsetRow() {
21782       this.row = null;
21783     }
21784 
21785     /** Returns true if field row is set (has been asigned a value) and false otherwise */
21786     public boolean isSetRow() {
21787       return this.row != null;
21788     }
21789 
21790     public void setRowIsSet(boolean value) {
21791       if (!value) {
21792         this.row = null;
21793       }
21794     }
21795 
21796     /**
21797      * name of column whose value is to be deleted
21798      */
21799     public byte[] getColumn() {
21800       return this.column;
21801     }
21802 
21803     /**
21804      * name of column whose value is to be deleted
21805      */
21806     public deleteAllTs_args setColumn(byte[] column) {
21807       this.column = column;
21808       return this;
21809     }
21810 
21811     public void unsetColumn() {
21812       this.column = null;
21813     }
21814 
21815     /** Returns true if field column is set (has been asigned a value) and false otherwise */
21816     public boolean isSetColumn() {
21817       return this.column != null;
21818     }
21819 
21820     public void setColumnIsSet(boolean value) {
21821       if (!value) {
21822         this.column = null;
21823       }
21824     }
21825 
21826     /**
21827      * timestamp
21828      */
21829     public long getTimestamp() {
21830       return this.timestamp;
21831     }
21832 
21833     /**
21834      * timestamp
21835      */
21836     public deleteAllTs_args setTimestamp(long timestamp) {
21837       this.timestamp = timestamp;
21838       setTimestampIsSet(true);
21839       return this;
21840     }
21841 
21842     public void unsetTimestamp() {
21843       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
21844     }
21845 
21846     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
21847     public boolean isSetTimestamp() {
21848       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
21849     }
21850 
21851     public void setTimestampIsSet(boolean value) {
21852       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
21853     }
21854 
21855     public void setFieldValue(_Fields field, Object value) {
21856       switch (field) {
21857       case TABLE_NAME:
21858         if (value == null) {
21859           unsetTableName();
21860         } else {
21861           setTableName((byte[])value);
21862         }
21863         break;
21864 
21865       case ROW:
21866         if (value == null) {
21867           unsetRow();
21868         } else {
21869           setRow((byte[])value);
21870         }
21871         break;
21872 
21873       case COLUMN:
21874         if (value == null) {
21875           unsetColumn();
21876         } else {
21877           setColumn((byte[])value);
21878         }
21879         break;
21880 
21881       case TIMESTAMP:
21882         if (value == null) {
21883           unsetTimestamp();
21884         } else {
21885           setTimestamp((Long)value);
21886         }
21887         break;
21888 
21889       }
21890     }
21891 
21892     public void setFieldValue(int fieldID, Object value) {
21893       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
21894     }
21895 
21896     public Object getFieldValue(_Fields field) {
21897       switch (field) {
21898       case TABLE_NAME:
21899         return getTableName();
21900 
21901       case ROW:
21902         return getRow();
21903 
21904       case COLUMN:
21905         return getColumn();
21906 
21907       case TIMESTAMP:
21908         return new Long(getTimestamp());
21909 
21910       }
21911       throw new IllegalStateException();
21912     }
21913 
21914     public Object getFieldValue(int fieldId) {
21915       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
21916     }
21917 
21918     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
21919     public boolean isSet(_Fields field) {
21920       switch (field) {
21921       case TABLE_NAME:
21922         return isSetTableName();
21923       case ROW:
21924         return isSetRow();
21925       case COLUMN:
21926         return isSetColumn();
21927       case TIMESTAMP:
21928         return isSetTimestamp();
21929       }
21930       throw new IllegalStateException();
21931     }
21932 
21933     public boolean isSet(int fieldID) {
21934       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
21935     }
21936 
21937     @Override
21938     public boolean equals(Object that) {
21939       if (that == null)
21940         return false;
21941       if (that instanceof deleteAllTs_args)
21942         return this.equals((deleteAllTs_args)that);
21943       return false;
21944     }
21945 
21946     public boolean equals(deleteAllTs_args that) {
21947       if (that == null)
21948         return false;
21949 
21950       boolean this_present_tableName = true && this.isSetTableName();
21951       boolean that_present_tableName = true && that.isSetTableName();
21952       if (this_present_tableName || that_present_tableName) {
21953         if (!(this_present_tableName && that_present_tableName))
21954           return false;
21955         if (!java.util.Arrays.equals(this.tableName, that.tableName))
21956           return false;
21957       }
21958 
21959       boolean this_present_row = true && this.isSetRow();
21960       boolean that_present_row = true && that.isSetRow();
21961       if (this_present_row || that_present_row) {
21962         if (!(this_present_row && that_present_row))
21963           return false;
21964         if (!java.util.Arrays.equals(this.row, that.row))
21965           return false;
21966       }
21967 
21968       boolean this_present_column = true && this.isSetColumn();
21969       boolean that_present_column = true && that.isSetColumn();
21970       if (this_present_column || that_present_column) {
21971         if (!(this_present_column && that_present_column))
21972           return false;
21973         if (!java.util.Arrays.equals(this.column, that.column))
21974           return false;
21975       }
21976 
21977       boolean this_present_timestamp = true;
21978       boolean that_present_timestamp = true;
21979       if (this_present_timestamp || that_present_timestamp) {
21980         if (!(this_present_timestamp && that_present_timestamp))
21981           return false;
21982         if (this.timestamp != that.timestamp)
21983           return false;
21984       }
21985 
21986       return true;
21987     }
21988 
21989     @Override
21990     public int hashCode() {
21991       HashCodeBuilder builder = new HashCodeBuilder();
21992 
21993       boolean present_tableName = true && (isSetTableName());
21994       builder.append(present_tableName);
21995       if (present_tableName)
21996         builder.append(tableName);
21997 
21998       boolean present_row = true && (isSetRow());
21999       builder.append(present_row);
22000       if (present_row)
22001         builder.append(row);
22002 
22003       boolean present_column = true && (isSetColumn());
22004       builder.append(present_column);
22005       if (present_column)
22006         builder.append(column);
22007 
22008       boolean present_timestamp = true;
22009       builder.append(present_timestamp);
22010       if (present_timestamp)
22011         builder.append(timestamp);
22012 
22013       return builder.toHashCode();
22014     }
22015 
22016     public int compareTo(deleteAllTs_args other) {
22017       if (!getClass().equals(other.getClass())) {
22018         return getClass().getName().compareTo(other.getClass().getName());
22019       }
22020 
22021       int lastComparison = 0;
22022       deleteAllTs_args typedOther = (deleteAllTs_args)other;
22023 
22024       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
22025       if (lastComparison != 0) {
22026         return lastComparison;
22027       }
22028       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
22029       if (lastComparison != 0) {
22030         return lastComparison;
22031       }
22032       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
22033       if (lastComparison != 0) {
22034         return lastComparison;
22035       }
22036       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
22037       if (lastComparison != 0) {
22038         return lastComparison;
22039       }
22040       lastComparison = Boolean.valueOf(isSetColumn()).compareTo(isSetColumn());
22041       if (lastComparison != 0) {
22042         return lastComparison;
22043       }
22044       lastComparison = TBaseHelper.compareTo(column, typedOther.column);
22045       if (lastComparison != 0) {
22046         return lastComparison;
22047       }
22048       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
22049       if (lastComparison != 0) {
22050         return lastComparison;
22051       }
22052       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
22053       if (lastComparison != 0) {
22054         return lastComparison;
22055       }
22056       return 0;
22057     }
22058 
22059     public void read(TProtocol iprot) throws TException {
22060       TField field;
22061       iprot.readStructBegin();
22062       while (true)
22063       {
22064         field = iprot.readFieldBegin();
22065         if (field.type == TType.STOP) {
22066           break;
22067         }
22068         _Fields fieldId = _Fields.findByThriftId(field.id);
22069         if (fieldId == null) {
22070           TProtocolUtil.skip(iprot, field.type);
22071         } else {
22072           switch (fieldId) {
22073             case TABLE_NAME:
22074               if (field.type == TType.STRING) {
22075                 this.tableName = iprot.readBinary();
22076               } else {
22077                 TProtocolUtil.skip(iprot, field.type);
22078               }
22079               break;
22080             case ROW:
22081               if (field.type == TType.STRING) {
22082                 this.row = iprot.readBinary();
22083               } else {
22084                 TProtocolUtil.skip(iprot, field.type);
22085               }
22086               break;
22087             case COLUMN:
22088               if (field.type == TType.STRING) {
22089                 this.column = iprot.readBinary();
22090               } else {
22091                 TProtocolUtil.skip(iprot, field.type);
22092               }
22093               break;
22094             case TIMESTAMP:
22095               if (field.type == TType.I64) {
22096                 this.timestamp = iprot.readI64();
22097                 setTimestampIsSet(true);
22098               } else {
22099                 TProtocolUtil.skip(iprot, field.type);
22100               }
22101               break;
22102           }
22103           iprot.readFieldEnd();
22104         }
22105       }
22106       iprot.readStructEnd();
22107 
22108       // check for required fields of primitive type, which can't be checked in the validate method
22109       validate();
22110     }
22111 
22112     public void write(TProtocol oprot) throws TException {
22113       validate();
22114 
22115       oprot.writeStructBegin(STRUCT_DESC);
22116       if (this.tableName != null) {
22117         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
22118         oprot.writeBinary(this.tableName);
22119         oprot.writeFieldEnd();
22120       }
22121       if (this.row != null) {
22122         oprot.writeFieldBegin(ROW_FIELD_DESC);
22123         oprot.writeBinary(this.row);
22124         oprot.writeFieldEnd();
22125       }
22126       if (this.column != null) {
22127         oprot.writeFieldBegin(COLUMN_FIELD_DESC);
22128         oprot.writeBinary(this.column);
22129         oprot.writeFieldEnd();
22130       }
22131       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
22132       oprot.writeI64(this.timestamp);
22133       oprot.writeFieldEnd();
22134       oprot.writeFieldStop();
22135       oprot.writeStructEnd();
22136     }
22137 
22138     @Override
22139     public String toString() {
22140       StringBuilder sb = new StringBuilder("deleteAllTs_args(");
22141       boolean first = true;
22142 
22143       sb.append("tableName:");
22144       if (this.tableName == null) {
22145         sb.append("null");
22146       } else {
22147         sb.append(this.tableName);
22148       }
22149       first = false;
22150       if (!first) sb.append(", ");
22151       sb.append("row:");
22152       if (this.row == null) {
22153         sb.append("null");
22154       } else {
22155         sb.append(this.row);
22156       }
22157       first = false;
22158       if (!first) sb.append(", ");
22159       sb.append("column:");
22160       if (this.column == null) {
22161         sb.append("null");
22162       } else {
22163         sb.append(this.column);
22164       }
22165       first = false;
22166       if (!first) sb.append(", ");
22167       sb.append("timestamp:");
22168       sb.append(this.timestamp);
22169       first = false;
22170       sb.append(")");
22171       return sb.toString();
22172     }
22173 
22174     public void validate() throws TException {
22175       // check for required fields
22176     }
22177 
22178   }
22179 
22180   public static class deleteAllTs_result implements TBase<deleteAllTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllTs_result>   {
22181     private static final TStruct STRUCT_DESC = new TStruct("deleteAllTs_result");
22182 
22183     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
22184 
22185     public IOError io;
22186 
22187     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
22188     public enum _Fields implements TFieldIdEnum {
22189       IO((short)1, "io");
22190 
22191       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22192       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22193 
22194       static {
22195         for (_Fields field : EnumSet.allOf(_Fields.class)) {
22196           byId.put((int)field._thriftId, field);
22197           byName.put(field.getFieldName(), field);
22198         }
22199       }
22200 
22201       /**
22202        * Find the _Fields constant that matches fieldId, or null if its not found.
22203        */
22204       public static _Fields findByThriftId(int fieldId) {
22205         return byId.get(fieldId);
22206       }
22207 
22208       /**
22209        * Find the _Fields constant that matches fieldId, throwing an exception
22210        * if it is not found.
22211        */
22212       public static _Fields findByThriftIdOrThrow(int fieldId) {
22213         _Fields fields = findByThriftId(fieldId);
22214         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22215         return fields;
22216       }
22217 
22218       /**
22219        * Find the _Fields constant that matches name, or null if its not found.
22220        */
22221       public static _Fields findByName(String name) {
22222         return byName.get(name);
22223       }
22224 
22225       private final short _thriftId;
22226       private final String _fieldName;
22227 
22228       _Fields(short thriftId, String fieldName) {
22229         _thriftId = thriftId;
22230         _fieldName = fieldName;
22231       }
22232 
22233       public short getThriftFieldId() {
22234         return _thriftId;
22235       }
22236 
22237       public String getFieldName() {
22238         return _fieldName;
22239       }
22240     }
22241 
22242     // isset id assignments
22243 
22244     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22245       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
22246           new FieldValueMetaData(TType.STRUCT)));
22247     }});
22248 
22249     static {
22250       FieldMetaData.addStructMetaDataMap(deleteAllTs_result.class, metaDataMap);
22251     }
22252 
22253     public deleteAllTs_result() {
22254     }
22255 
22256     public deleteAllTs_result(
22257       IOError io)
22258     {
22259       this();
22260       this.io = io;
22261     }
22262 
22263     /**
22264      * Performs a deep copy on <i>other</i>.
22265      */
22266     public deleteAllTs_result(deleteAllTs_result other) {
22267       if (other.isSetIo()) {
22268         this.io = new IOError(other.io);
22269       }
22270     }
22271 
22272     public deleteAllTs_result deepCopy() {
22273       return new deleteAllTs_result(this);
22274     }
22275 
22276     @Deprecated
22277     public deleteAllTs_result clone() {
22278       return new deleteAllTs_result(this);
22279     }
22280 
22281     public IOError getIo() {
22282       return this.io;
22283     }
22284 
22285     public deleteAllTs_result setIo(IOError io) {
22286       this.io = io;
22287       return this;
22288     }
22289 
22290     public void unsetIo() {
22291       this.io = null;
22292     }
22293 
22294     /** Returns true if field io is set (has been asigned a value) and false otherwise */
22295     public boolean isSetIo() {
22296       return this.io != null;
22297     }
22298 
22299     public void setIoIsSet(boolean value) {
22300       if (!value) {
22301         this.io = null;
22302       }
22303     }
22304 
22305     public void setFieldValue(_Fields field, Object value) {
22306       switch (field) {
22307       case IO:
22308         if (value == null) {
22309           unsetIo();
22310         } else {
22311           setIo((IOError)value);
22312         }
22313         break;
22314 
22315       }
22316     }
22317 
22318     public void setFieldValue(int fieldID, Object value) {
22319       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
22320     }
22321 
22322     public Object getFieldValue(_Fields field) {
22323       switch (field) {
22324       case IO:
22325         return getIo();
22326 
22327       }
22328       throw new IllegalStateException();
22329     }
22330 
22331     public Object getFieldValue(int fieldId) {
22332       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
22333     }
22334 
22335     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
22336     public boolean isSet(_Fields field) {
22337       switch (field) {
22338       case IO:
22339         return isSetIo();
22340       }
22341       throw new IllegalStateException();
22342     }
22343 
22344     public boolean isSet(int fieldID) {
22345       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
22346     }
22347 
22348     @Override
22349     public boolean equals(Object that) {
22350       if (that == null)
22351         return false;
22352       if (that instanceof deleteAllTs_result)
22353         return this.equals((deleteAllTs_result)that);
22354       return false;
22355     }
22356 
22357     public boolean equals(deleteAllTs_result that) {
22358       if (that == null)
22359         return false;
22360 
22361       boolean this_present_io = true && this.isSetIo();
22362       boolean that_present_io = true && that.isSetIo();
22363       if (this_present_io || that_present_io) {
22364         if (!(this_present_io && that_present_io))
22365           return false;
22366         if (!this.io.equals(that.io))
22367           return false;
22368       }
22369 
22370       return true;
22371     }
22372 
22373     @Override
22374     public int hashCode() {
22375       HashCodeBuilder builder = new HashCodeBuilder();
22376 
22377       boolean present_io = true && (isSetIo());
22378       builder.append(present_io);
22379       if (present_io)
22380         builder.append(io);
22381 
22382       return builder.toHashCode();
22383     }
22384 
22385     public int compareTo(deleteAllTs_result other) {
22386       if (!getClass().equals(other.getClass())) {
22387         return getClass().getName().compareTo(other.getClass().getName());
22388       }
22389 
22390       int lastComparison = 0;
22391       deleteAllTs_result typedOther = (deleteAllTs_result)other;
22392 
22393       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
22394       if (lastComparison != 0) {
22395         return lastComparison;
22396       }
22397       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
22398       if (lastComparison != 0) {
22399         return lastComparison;
22400       }
22401       return 0;
22402     }
22403 
22404     public void read(TProtocol iprot) throws TException {
22405       TField field;
22406       iprot.readStructBegin();
22407       while (true)
22408       {
22409         field = iprot.readFieldBegin();
22410         if (field.type == TType.STOP) {
22411           break;
22412         }
22413         _Fields fieldId = _Fields.findByThriftId(field.id);
22414         if (fieldId == null) {
22415           TProtocolUtil.skip(iprot, field.type);
22416         } else {
22417           switch (fieldId) {
22418             case IO:
22419               if (field.type == TType.STRUCT) {
22420                 this.io = new IOError();
22421                 this.io.read(iprot);
22422               } else {
22423                 TProtocolUtil.skip(iprot, field.type);
22424               }
22425               break;
22426           }
22427           iprot.readFieldEnd();
22428         }
22429       }
22430       iprot.readStructEnd();
22431 
22432       // check for required fields of primitive type, which can't be checked in the validate method
22433       validate();
22434     }
22435 
22436     public void write(TProtocol oprot) throws TException {
22437       oprot.writeStructBegin(STRUCT_DESC);
22438 
22439       if (this.isSetIo()) {
22440         oprot.writeFieldBegin(IO_FIELD_DESC);
22441         this.io.write(oprot);
22442         oprot.writeFieldEnd();
22443       }
22444       oprot.writeFieldStop();
22445       oprot.writeStructEnd();
22446     }
22447 
22448     @Override
22449     public String toString() {
22450       StringBuilder sb = new StringBuilder("deleteAllTs_result(");
22451       boolean first = true;
22452 
22453       sb.append("io:");
22454       if (this.io == null) {
22455         sb.append("null");
22456       } else {
22457         sb.append(this.io);
22458       }
22459       first = false;
22460       sb.append(")");
22461       return sb.toString();
22462     }
22463 
22464     public void validate() throws TException {
22465       // check for required fields
22466     }
22467 
22468   }
22469 
22470   public static class deleteAllRow_args implements TBase<deleteAllRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_args>   {
22471     private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_args");
22472 
22473     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
22474     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
22475 
22476     /**
22477      * name of table
22478      */
22479     public byte[] tableName;
22480     /**
22481      * key of the row to be completely deleted.
22482      */
22483     public byte[] row;
22484 
22485     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
22486     public enum _Fields implements TFieldIdEnum {
22487       /**
22488        * name of table
22489        */
22490       TABLE_NAME((short)1, "tableName"),
22491       /**
22492        * key of the row to be completely deleted.
22493        */
22494       ROW((short)2, "row");
22495 
22496       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22497       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22498 
22499       static {
22500         for (_Fields field : EnumSet.allOf(_Fields.class)) {
22501           byId.put((int)field._thriftId, field);
22502           byName.put(field.getFieldName(), field);
22503         }
22504       }
22505 
22506       /**
22507        * Find the _Fields constant that matches fieldId, or null if its not found.
22508        */
22509       public static _Fields findByThriftId(int fieldId) {
22510         return byId.get(fieldId);
22511       }
22512 
22513       /**
22514        * Find the _Fields constant that matches fieldId, throwing an exception
22515        * if it is not found.
22516        */
22517       public static _Fields findByThriftIdOrThrow(int fieldId) {
22518         _Fields fields = findByThriftId(fieldId);
22519         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22520         return fields;
22521       }
22522 
22523       /**
22524        * Find the _Fields constant that matches name, or null if its not found.
22525        */
22526       public static _Fields findByName(String name) {
22527         return byName.get(name);
22528       }
22529 
22530       private final short _thriftId;
22531       private final String _fieldName;
22532 
22533       _Fields(short thriftId, String fieldName) {
22534         _thriftId = thriftId;
22535         _fieldName = fieldName;
22536       }
22537 
22538       public short getThriftFieldId() {
22539         return _thriftId;
22540       }
22541 
22542       public String getFieldName() {
22543         return _fieldName;
22544       }
22545     }
22546 
22547     // isset id assignments
22548 
22549     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22550       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
22551           new FieldValueMetaData(TType.STRING)));
22552       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
22553           new FieldValueMetaData(TType.STRING)));
22554     }});
22555 
22556     static {
22557       FieldMetaData.addStructMetaDataMap(deleteAllRow_args.class, metaDataMap);
22558     }
22559 
22560     public deleteAllRow_args() {
22561     }
22562 
22563     public deleteAllRow_args(
22564       byte[] tableName,
22565       byte[] row)
22566     {
22567       this();
22568       this.tableName = tableName;
22569       this.row = row;
22570     }
22571 
22572     /**
22573      * Performs a deep copy on <i>other</i>.
22574      */
22575     public deleteAllRow_args(deleteAllRow_args other) {
22576       if (other.isSetTableName()) {
22577         this.tableName = other.tableName;
22578       }
22579       if (other.isSetRow()) {
22580         this.row = other.row;
22581       }
22582     }
22583 
22584     public deleteAllRow_args deepCopy() {
22585       return new deleteAllRow_args(this);
22586     }
22587 
22588     @Deprecated
22589     public deleteAllRow_args clone() {
22590       return new deleteAllRow_args(this);
22591     }
22592 
22593     /**
22594      * name of table
22595      */
22596     public byte[] getTableName() {
22597       return this.tableName;
22598     }
22599 
22600     /**
22601      * name of table
22602      */
22603     public deleteAllRow_args setTableName(byte[] tableName) {
22604       this.tableName = tableName;
22605       return this;
22606     }
22607 
22608     public void unsetTableName() {
22609       this.tableName = null;
22610     }
22611 
22612     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
22613     public boolean isSetTableName() {
22614       return this.tableName != null;
22615     }
22616 
22617     public void setTableNameIsSet(boolean value) {
22618       if (!value) {
22619         this.tableName = null;
22620       }
22621     }
22622 
22623     /**
22624      * key of the row to be completely deleted.
22625      */
22626     public byte[] getRow() {
22627       return this.row;
22628     }
22629 
22630     /**
22631      * key of the row to be completely deleted.
22632      */
22633     public deleteAllRow_args setRow(byte[] row) {
22634       this.row = row;
22635       return this;
22636     }
22637 
22638     public void unsetRow() {
22639       this.row = null;
22640     }
22641 
22642     /** Returns true if field row is set (has been asigned a value) and false otherwise */
22643     public boolean isSetRow() {
22644       return this.row != null;
22645     }
22646 
22647     public void setRowIsSet(boolean value) {
22648       if (!value) {
22649         this.row = null;
22650       }
22651     }
22652 
22653     public void setFieldValue(_Fields field, Object value) {
22654       switch (field) {
22655       case TABLE_NAME:
22656         if (value == null) {
22657           unsetTableName();
22658         } else {
22659           setTableName((byte[])value);
22660         }
22661         break;
22662 
22663       case ROW:
22664         if (value == null) {
22665           unsetRow();
22666         } else {
22667           setRow((byte[])value);
22668         }
22669         break;
22670 
22671       }
22672     }
22673 
22674     public void setFieldValue(int fieldID, Object value) {
22675       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
22676     }
22677 
22678     public Object getFieldValue(_Fields field) {
22679       switch (field) {
22680       case TABLE_NAME:
22681         return getTableName();
22682 
22683       case ROW:
22684         return getRow();
22685 
22686       }
22687       throw new IllegalStateException();
22688     }
22689 
22690     public Object getFieldValue(int fieldId) {
22691       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
22692     }
22693 
22694     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
22695     public boolean isSet(_Fields field) {
22696       switch (field) {
22697       case TABLE_NAME:
22698         return isSetTableName();
22699       case ROW:
22700         return isSetRow();
22701       }
22702       throw new IllegalStateException();
22703     }
22704 
22705     public boolean isSet(int fieldID) {
22706       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
22707     }
22708 
22709     @Override
22710     public boolean equals(Object that) {
22711       if (that == null)
22712         return false;
22713       if (that instanceof deleteAllRow_args)
22714         return this.equals((deleteAllRow_args)that);
22715       return false;
22716     }
22717 
22718     public boolean equals(deleteAllRow_args that) {
22719       if (that == null)
22720         return false;
22721 
22722       boolean this_present_tableName = true && this.isSetTableName();
22723       boolean that_present_tableName = true && that.isSetTableName();
22724       if (this_present_tableName || that_present_tableName) {
22725         if (!(this_present_tableName && that_present_tableName))
22726           return false;
22727         if (!java.util.Arrays.equals(this.tableName, that.tableName))
22728           return false;
22729       }
22730 
22731       boolean this_present_row = true && this.isSetRow();
22732       boolean that_present_row = true && that.isSetRow();
22733       if (this_present_row || that_present_row) {
22734         if (!(this_present_row && that_present_row))
22735           return false;
22736         if (!java.util.Arrays.equals(this.row, that.row))
22737           return false;
22738       }
22739 
22740       return true;
22741     }
22742 
22743     @Override
22744     public int hashCode() {
22745       HashCodeBuilder builder = new HashCodeBuilder();
22746 
22747       boolean present_tableName = true && (isSetTableName());
22748       builder.append(present_tableName);
22749       if (present_tableName)
22750         builder.append(tableName);
22751 
22752       boolean present_row = true && (isSetRow());
22753       builder.append(present_row);
22754       if (present_row)
22755         builder.append(row);
22756 
22757       return builder.toHashCode();
22758     }
22759 
22760     public int compareTo(deleteAllRow_args other) {
22761       if (!getClass().equals(other.getClass())) {
22762         return getClass().getName().compareTo(other.getClass().getName());
22763       }
22764 
22765       int lastComparison = 0;
22766       deleteAllRow_args typedOther = (deleteAllRow_args)other;
22767 
22768       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
22769       if (lastComparison != 0) {
22770         return lastComparison;
22771       }
22772       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
22773       if (lastComparison != 0) {
22774         return lastComparison;
22775       }
22776       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
22777       if (lastComparison != 0) {
22778         return lastComparison;
22779       }
22780       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
22781       if (lastComparison != 0) {
22782         return lastComparison;
22783       }
22784       return 0;
22785     }
22786 
22787     public void read(TProtocol iprot) throws TException {
22788       TField field;
22789       iprot.readStructBegin();
22790       while (true)
22791       {
22792         field = iprot.readFieldBegin();
22793         if (field.type == TType.STOP) {
22794           break;
22795         }
22796         _Fields fieldId = _Fields.findByThriftId(field.id);
22797         if (fieldId == null) {
22798           TProtocolUtil.skip(iprot, field.type);
22799         } else {
22800           switch (fieldId) {
22801             case TABLE_NAME:
22802               if (field.type == TType.STRING) {
22803                 this.tableName = iprot.readBinary();
22804               } else {
22805                 TProtocolUtil.skip(iprot, field.type);
22806               }
22807               break;
22808             case ROW:
22809               if (field.type == TType.STRING) {
22810                 this.row = iprot.readBinary();
22811               } else {
22812                 TProtocolUtil.skip(iprot, field.type);
22813               }
22814               break;
22815           }
22816           iprot.readFieldEnd();
22817         }
22818       }
22819       iprot.readStructEnd();
22820 
22821       // check for required fields of primitive type, which can't be checked in the validate method
22822       validate();
22823     }
22824 
22825     public void write(TProtocol oprot) throws TException {
22826       validate();
22827 
22828       oprot.writeStructBegin(STRUCT_DESC);
22829       if (this.tableName != null) {
22830         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
22831         oprot.writeBinary(this.tableName);
22832         oprot.writeFieldEnd();
22833       }
22834       if (this.row != null) {
22835         oprot.writeFieldBegin(ROW_FIELD_DESC);
22836         oprot.writeBinary(this.row);
22837         oprot.writeFieldEnd();
22838       }
22839       oprot.writeFieldStop();
22840       oprot.writeStructEnd();
22841     }
22842 
22843     @Override
22844     public String toString() {
22845       StringBuilder sb = new StringBuilder("deleteAllRow_args(");
22846       boolean first = true;
22847 
22848       sb.append("tableName:");
22849       if (this.tableName == null) {
22850         sb.append("null");
22851       } else {
22852         sb.append(this.tableName);
22853       }
22854       first = false;
22855       if (!first) sb.append(", ");
22856       sb.append("row:");
22857       if (this.row == null) {
22858         sb.append("null");
22859       } else {
22860         sb.append(this.row);
22861       }
22862       first = false;
22863       sb.append(")");
22864       return sb.toString();
22865     }
22866 
22867     public void validate() throws TException {
22868       // check for required fields
22869     }
22870 
22871   }
22872 
22873   public static class deleteAllRow_result implements TBase<deleteAllRow_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRow_result>   {
22874     private static final TStruct STRUCT_DESC = new TStruct("deleteAllRow_result");
22875 
22876     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
22877 
22878     public IOError io;
22879 
22880     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
22881     public enum _Fields implements TFieldIdEnum {
22882       IO((short)1, "io");
22883 
22884       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
22885       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
22886 
22887       static {
22888         for (_Fields field : EnumSet.allOf(_Fields.class)) {
22889           byId.put((int)field._thriftId, field);
22890           byName.put(field.getFieldName(), field);
22891         }
22892       }
22893 
22894       /**
22895        * Find the _Fields constant that matches fieldId, or null if its not found.
22896        */
22897       public static _Fields findByThriftId(int fieldId) {
22898         return byId.get(fieldId);
22899       }
22900 
22901       /**
22902        * Find the _Fields constant that matches fieldId, throwing an exception
22903        * if it is not found.
22904        */
22905       public static _Fields findByThriftIdOrThrow(int fieldId) {
22906         _Fields fields = findByThriftId(fieldId);
22907         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
22908         return fields;
22909       }
22910 
22911       /**
22912        * Find the _Fields constant that matches name, or null if its not found.
22913        */
22914       public static _Fields findByName(String name) {
22915         return byName.get(name);
22916       }
22917 
22918       private final short _thriftId;
22919       private final String _fieldName;
22920 
22921       _Fields(short thriftId, String fieldName) {
22922         _thriftId = thriftId;
22923         _fieldName = fieldName;
22924       }
22925 
22926       public short getThriftFieldId() {
22927         return _thriftId;
22928       }
22929 
22930       public String getFieldName() {
22931         return _fieldName;
22932       }
22933     }
22934 
22935     // isset id assignments
22936 
22937     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
22938       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
22939           new FieldValueMetaData(TType.STRUCT)));
22940     }});
22941 
22942     static {
22943       FieldMetaData.addStructMetaDataMap(deleteAllRow_result.class, metaDataMap);
22944     }
22945 
22946     public deleteAllRow_result() {
22947     }
22948 
22949     public deleteAllRow_result(
22950       IOError io)
22951     {
22952       this();
22953       this.io = io;
22954     }
22955 
22956     /**
22957      * Performs a deep copy on <i>other</i>.
22958      */
22959     public deleteAllRow_result(deleteAllRow_result other) {
22960       if (other.isSetIo()) {
22961         this.io = new IOError(other.io);
22962       }
22963     }
22964 
22965     public deleteAllRow_result deepCopy() {
22966       return new deleteAllRow_result(this);
22967     }
22968 
22969     @Deprecated
22970     public deleteAllRow_result clone() {
22971       return new deleteAllRow_result(this);
22972     }
22973 
22974     public IOError getIo() {
22975       return this.io;
22976     }
22977 
22978     public deleteAllRow_result setIo(IOError io) {
22979       this.io = io;
22980       return this;
22981     }
22982 
22983     public void unsetIo() {
22984       this.io = null;
22985     }
22986 
22987     /** Returns true if field io is set (has been asigned a value) and false otherwise */
22988     public boolean isSetIo() {
22989       return this.io != null;
22990     }
22991 
22992     public void setIoIsSet(boolean value) {
22993       if (!value) {
22994         this.io = null;
22995       }
22996     }
22997 
22998     public void setFieldValue(_Fields field, Object value) {
22999       switch (field) {
23000       case IO:
23001         if (value == null) {
23002           unsetIo();
23003         } else {
23004           setIo((IOError)value);
23005         }
23006         break;
23007 
23008       }
23009     }
23010 
23011     public void setFieldValue(int fieldID, Object value) {
23012       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23013     }
23014 
23015     public Object getFieldValue(_Fields field) {
23016       switch (field) {
23017       case IO:
23018         return getIo();
23019 
23020       }
23021       throw new IllegalStateException();
23022     }
23023 
23024     public Object getFieldValue(int fieldId) {
23025       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23026     }
23027 
23028     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
23029     public boolean isSet(_Fields field) {
23030       switch (field) {
23031       case IO:
23032         return isSetIo();
23033       }
23034       throw new IllegalStateException();
23035     }
23036 
23037     public boolean isSet(int fieldID) {
23038       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23039     }
23040 
23041     @Override
23042     public boolean equals(Object that) {
23043       if (that == null)
23044         return false;
23045       if (that instanceof deleteAllRow_result)
23046         return this.equals((deleteAllRow_result)that);
23047       return false;
23048     }
23049 
23050     public boolean equals(deleteAllRow_result that) {
23051       if (that == null)
23052         return false;
23053 
23054       boolean this_present_io = true && this.isSetIo();
23055       boolean that_present_io = true && that.isSetIo();
23056       if (this_present_io || that_present_io) {
23057         if (!(this_present_io && that_present_io))
23058           return false;
23059         if (!this.io.equals(that.io))
23060           return false;
23061       }
23062 
23063       return true;
23064     }
23065 
23066     @Override
23067     public int hashCode() {
23068       HashCodeBuilder builder = new HashCodeBuilder();
23069 
23070       boolean present_io = true && (isSetIo());
23071       builder.append(present_io);
23072       if (present_io)
23073         builder.append(io);
23074 
23075       return builder.toHashCode();
23076     }
23077 
23078     public int compareTo(deleteAllRow_result other) {
23079       if (!getClass().equals(other.getClass())) {
23080         return getClass().getName().compareTo(other.getClass().getName());
23081       }
23082 
23083       int lastComparison = 0;
23084       deleteAllRow_result typedOther = (deleteAllRow_result)other;
23085 
23086       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
23087       if (lastComparison != 0) {
23088         return lastComparison;
23089       }
23090       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
23091       if (lastComparison != 0) {
23092         return lastComparison;
23093       }
23094       return 0;
23095     }
23096 
23097     public void read(TProtocol iprot) throws TException {
23098       TField field;
23099       iprot.readStructBegin();
23100       while (true)
23101       {
23102         field = iprot.readFieldBegin();
23103         if (field.type == TType.STOP) {
23104           break;
23105         }
23106         _Fields fieldId = _Fields.findByThriftId(field.id);
23107         if (fieldId == null) {
23108           TProtocolUtil.skip(iprot, field.type);
23109         } else {
23110           switch (fieldId) {
23111             case IO:
23112               if (field.type == TType.STRUCT) {
23113                 this.io = new IOError();
23114                 this.io.read(iprot);
23115               } else {
23116                 TProtocolUtil.skip(iprot, field.type);
23117               }
23118               break;
23119           }
23120           iprot.readFieldEnd();
23121         }
23122       }
23123       iprot.readStructEnd();
23124 
23125       // check for required fields of primitive type, which can't be checked in the validate method
23126       validate();
23127     }
23128 
23129     public void write(TProtocol oprot) throws TException {
23130       oprot.writeStructBegin(STRUCT_DESC);
23131 
23132       if (this.isSetIo()) {
23133         oprot.writeFieldBegin(IO_FIELD_DESC);
23134         this.io.write(oprot);
23135         oprot.writeFieldEnd();
23136       }
23137       oprot.writeFieldStop();
23138       oprot.writeStructEnd();
23139     }
23140 
23141     @Override
23142     public String toString() {
23143       StringBuilder sb = new StringBuilder("deleteAllRow_result(");
23144       boolean first = true;
23145 
23146       sb.append("io:");
23147       if (this.io == null) {
23148         sb.append("null");
23149       } else {
23150         sb.append(this.io);
23151       }
23152       first = false;
23153       sb.append(")");
23154       return sb.toString();
23155     }
23156 
23157     public void validate() throws TException {
23158       // check for required fields
23159     }
23160 
23161   }
23162 
23163   public static class deleteAllRowTs_args implements TBase<deleteAllRowTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_args>   {
23164     private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_args");
23165 
23166     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
23167     private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
23168     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
23169 
23170     /**
23171      * name of table
23172      */
23173     public byte[] tableName;
23174     /**
23175      * key of the row to be completely deleted.
23176      */
23177     public byte[] row;
23178     /**
23179      * timestamp
23180      */
23181     public long timestamp;
23182 
23183     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
23184     public enum _Fields implements TFieldIdEnum {
23185       /**
23186        * name of table
23187        */
23188       TABLE_NAME((short)1, "tableName"),
23189       /**
23190        * key of the row to be completely deleted.
23191        */
23192       ROW((short)2, "row"),
23193       /**
23194        * timestamp
23195        */
23196       TIMESTAMP((short)3, "timestamp");
23197 
23198       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23199       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23200 
23201       static {
23202         for (_Fields field : EnumSet.allOf(_Fields.class)) {
23203           byId.put((int)field._thriftId, field);
23204           byName.put(field.getFieldName(), field);
23205         }
23206       }
23207 
23208       /**
23209        * Find the _Fields constant that matches fieldId, or null if its not found.
23210        */
23211       public static _Fields findByThriftId(int fieldId) {
23212         return byId.get(fieldId);
23213       }
23214 
23215       /**
23216        * Find the _Fields constant that matches fieldId, throwing an exception
23217        * if it is not found.
23218        */
23219       public static _Fields findByThriftIdOrThrow(int fieldId) {
23220         _Fields fields = findByThriftId(fieldId);
23221         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
23222         return fields;
23223       }
23224 
23225       /**
23226        * Find the _Fields constant that matches name, or null if its not found.
23227        */
23228       public static _Fields findByName(String name) {
23229         return byName.get(name);
23230       }
23231 
23232       private final short _thriftId;
23233       private final String _fieldName;
23234 
23235       _Fields(short thriftId, String fieldName) {
23236         _thriftId = thriftId;
23237         _fieldName = fieldName;
23238       }
23239 
23240       public short getThriftFieldId() {
23241         return _thriftId;
23242       }
23243 
23244       public String getFieldName() {
23245         return _fieldName;
23246       }
23247     }
23248 
23249     // isset id assignments
23250     private static final int __TIMESTAMP_ISSET_ID = 0;
23251     private BitSet __isset_bit_vector = new BitSet(1);
23252 
23253     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
23254       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
23255           new FieldValueMetaData(TType.STRING)));
23256       put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
23257           new FieldValueMetaData(TType.STRING)));
23258       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
23259           new FieldValueMetaData(TType.I64)));
23260     }});
23261 
23262     static {
23263       FieldMetaData.addStructMetaDataMap(deleteAllRowTs_args.class, metaDataMap);
23264     }
23265 
23266     public deleteAllRowTs_args() {
23267     }
23268 
23269     public deleteAllRowTs_args(
23270       byte[] tableName,
23271       byte[] row,
23272       long timestamp)
23273     {
23274       this();
23275       this.tableName = tableName;
23276       this.row = row;
23277       this.timestamp = timestamp;
23278       setTimestampIsSet(true);
23279     }
23280 
23281     /**
23282      * Performs a deep copy on <i>other</i>.
23283      */
23284     public deleteAllRowTs_args(deleteAllRowTs_args other) {
23285       __isset_bit_vector.clear();
23286       __isset_bit_vector.or(other.__isset_bit_vector);
23287       if (other.isSetTableName()) {
23288         this.tableName = other.tableName;
23289       }
23290       if (other.isSetRow()) {
23291         this.row = other.row;
23292       }
23293       this.timestamp = other.timestamp;
23294     }
23295 
23296     public deleteAllRowTs_args deepCopy() {
23297       return new deleteAllRowTs_args(this);
23298     }
23299 
23300     @Deprecated
23301     public deleteAllRowTs_args clone() {
23302       return new deleteAllRowTs_args(this);
23303     }
23304 
23305     /**
23306      * name of table
23307      */
23308     public byte[] getTableName() {
23309       return this.tableName;
23310     }
23311 
23312     /**
23313      * name of table
23314      */
23315     public deleteAllRowTs_args setTableName(byte[] tableName) {
23316       this.tableName = tableName;
23317       return this;
23318     }
23319 
23320     public void unsetTableName() {
23321       this.tableName = null;
23322     }
23323 
23324     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
23325     public boolean isSetTableName() {
23326       return this.tableName != null;
23327     }
23328 
23329     public void setTableNameIsSet(boolean value) {
23330       if (!value) {
23331         this.tableName = null;
23332       }
23333     }
23334 
23335     /**
23336      * key of the row to be completely deleted.
23337      */
23338     public byte[] getRow() {
23339       return this.row;
23340     }
23341 
23342     /**
23343      * key of the row to be completely deleted.
23344      */
23345     public deleteAllRowTs_args setRow(byte[] row) {
23346       this.row = row;
23347       return this;
23348     }
23349 
23350     public void unsetRow() {
23351       this.row = null;
23352     }
23353 
23354     /** Returns true if field row is set (has been asigned a value) and false otherwise */
23355     public boolean isSetRow() {
23356       return this.row != null;
23357     }
23358 
23359     public void setRowIsSet(boolean value) {
23360       if (!value) {
23361         this.row = null;
23362       }
23363     }
23364 
23365     /**
23366      * timestamp
23367      */
23368     public long getTimestamp() {
23369       return this.timestamp;
23370     }
23371 
23372     /**
23373      * timestamp
23374      */
23375     public deleteAllRowTs_args setTimestamp(long timestamp) {
23376       this.timestamp = timestamp;
23377       setTimestampIsSet(true);
23378       return this;
23379     }
23380 
23381     public void unsetTimestamp() {
23382       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
23383     }
23384 
23385     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
23386     public boolean isSetTimestamp() {
23387       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
23388     }
23389 
23390     public void setTimestampIsSet(boolean value) {
23391       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
23392     }
23393 
23394     public void setFieldValue(_Fields field, Object value) {
23395       switch (field) {
23396       case TABLE_NAME:
23397         if (value == null) {
23398           unsetTableName();
23399         } else {
23400           setTableName((byte[])value);
23401         }
23402         break;
23403 
23404       case ROW:
23405         if (value == null) {
23406           unsetRow();
23407         } else {
23408           setRow((byte[])value);
23409         }
23410         break;
23411 
23412       case TIMESTAMP:
23413         if (value == null) {
23414           unsetTimestamp();
23415         } else {
23416           setTimestamp((Long)value);
23417         }
23418         break;
23419 
23420       }
23421     }
23422 
23423     public void setFieldValue(int fieldID, Object value) {
23424       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23425     }
23426 
23427     public Object getFieldValue(_Fields field) {
23428       switch (field) {
23429       case TABLE_NAME:
23430         return getTableName();
23431 
23432       case ROW:
23433         return getRow();
23434 
23435       case TIMESTAMP:
23436         return new Long(getTimestamp());
23437 
23438       }
23439       throw new IllegalStateException();
23440     }
23441 
23442     public Object getFieldValue(int fieldId) {
23443       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23444     }
23445 
23446     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
23447     public boolean isSet(_Fields field) {
23448       switch (field) {
23449       case TABLE_NAME:
23450         return isSetTableName();
23451       case ROW:
23452         return isSetRow();
23453       case TIMESTAMP:
23454         return isSetTimestamp();
23455       }
23456       throw new IllegalStateException();
23457     }
23458 
23459     public boolean isSet(int fieldID) {
23460       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23461     }
23462 
23463     @Override
23464     public boolean equals(Object that) {
23465       if (that == null)
23466         return false;
23467       if (that instanceof deleteAllRowTs_args)
23468         return this.equals((deleteAllRowTs_args)that);
23469       return false;
23470     }
23471 
23472     public boolean equals(deleteAllRowTs_args that) {
23473       if (that == null)
23474         return false;
23475 
23476       boolean this_present_tableName = true && this.isSetTableName();
23477       boolean that_present_tableName = true && that.isSetTableName();
23478       if (this_present_tableName || that_present_tableName) {
23479         if (!(this_present_tableName && that_present_tableName))
23480           return false;
23481         if (!java.util.Arrays.equals(this.tableName, that.tableName))
23482           return false;
23483       }
23484 
23485       boolean this_present_row = true && this.isSetRow();
23486       boolean that_present_row = true && that.isSetRow();
23487       if (this_present_row || that_present_row) {
23488         if (!(this_present_row && that_present_row))
23489           return false;
23490         if (!java.util.Arrays.equals(this.row, that.row))
23491           return false;
23492       }
23493 
23494       boolean this_present_timestamp = true;
23495       boolean that_present_timestamp = true;
23496       if (this_present_timestamp || that_present_timestamp) {
23497         if (!(this_present_timestamp && that_present_timestamp))
23498           return false;
23499         if (this.timestamp != that.timestamp)
23500           return false;
23501       }
23502 
23503       return true;
23504     }
23505 
23506     @Override
23507     public int hashCode() {
23508       HashCodeBuilder builder = new HashCodeBuilder();
23509 
23510       boolean present_tableName = true && (isSetTableName());
23511       builder.append(present_tableName);
23512       if (present_tableName)
23513         builder.append(tableName);
23514 
23515       boolean present_row = true && (isSetRow());
23516       builder.append(present_row);
23517       if (present_row)
23518         builder.append(row);
23519 
23520       boolean present_timestamp = true;
23521       builder.append(present_timestamp);
23522       if (present_timestamp)
23523         builder.append(timestamp);
23524 
23525       return builder.toHashCode();
23526     }
23527 
23528     public int compareTo(deleteAllRowTs_args other) {
23529       if (!getClass().equals(other.getClass())) {
23530         return getClass().getName().compareTo(other.getClass().getName());
23531       }
23532 
23533       int lastComparison = 0;
23534       deleteAllRowTs_args typedOther = (deleteAllRowTs_args)other;
23535 
23536       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
23537       if (lastComparison != 0) {
23538         return lastComparison;
23539       }
23540       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
23541       if (lastComparison != 0) {
23542         return lastComparison;
23543       }
23544       lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
23545       if (lastComparison != 0) {
23546         return lastComparison;
23547       }
23548       lastComparison = TBaseHelper.compareTo(row, typedOther.row);
23549       if (lastComparison != 0) {
23550         return lastComparison;
23551       }
23552       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
23553       if (lastComparison != 0) {
23554         return lastComparison;
23555       }
23556       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
23557       if (lastComparison != 0) {
23558         return lastComparison;
23559       }
23560       return 0;
23561     }
23562 
23563     public void read(TProtocol iprot) throws TException {
23564       TField field;
23565       iprot.readStructBegin();
23566       while (true)
23567       {
23568         field = iprot.readFieldBegin();
23569         if (field.type == TType.STOP) {
23570           break;
23571         }
23572         _Fields fieldId = _Fields.findByThriftId(field.id);
23573         if (fieldId == null) {
23574           TProtocolUtil.skip(iprot, field.type);
23575         } else {
23576           switch (fieldId) {
23577             case TABLE_NAME:
23578               if (field.type == TType.STRING) {
23579                 this.tableName = iprot.readBinary();
23580               } else {
23581                 TProtocolUtil.skip(iprot, field.type);
23582               }
23583               break;
23584             case ROW:
23585               if (field.type == TType.STRING) {
23586                 this.row = iprot.readBinary();
23587               } else {
23588                 TProtocolUtil.skip(iprot, field.type);
23589               }
23590               break;
23591             case TIMESTAMP:
23592               if (field.type == TType.I64) {
23593                 this.timestamp = iprot.readI64();
23594                 setTimestampIsSet(true);
23595               } else {
23596                 TProtocolUtil.skip(iprot, field.type);
23597               }
23598               break;
23599           }
23600           iprot.readFieldEnd();
23601         }
23602       }
23603       iprot.readStructEnd();
23604 
23605       // check for required fields of primitive type, which can't be checked in the validate method
23606       validate();
23607     }
23608 
23609     public void write(TProtocol oprot) throws TException {
23610       validate();
23611 
23612       oprot.writeStructBegin(STRUCT_DESC);
23613       if (this.tableName != null) {
23614         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
23615         oprot.writeBinary(this.tableName);
23616         oprot.writeFieldEnd();
23617       }
23618       if (this.row != null) {
23619         oprot.writeFieldBegin(ROW_FIELD_DESC);
23620         oprot.writeBinary(this.row);
23621         oprot.writeFieldEnd();
23622       }
23623       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
23624       oprot.writeI64(this.timestamp);
23625       oprot.writeFieldEnd();
23626       oprot.writeFieldStop();
23627       oprot.writeStructEnd();
23628     }
23629 
23630     @Override
23631     public String toString() {
23632       StringBuilder sb = new StringBuilder("deleteAllRowTs_args(");
23633       boolean first = true;
23634 
23635       sb.append("tableName:");
23636       if (this.tableName == null) {
23637         sb.append("null");
23638       } else {
23639         sb.append(this.tableName);
23640       }
23641       first = false;
23642       if (!first) sb.append(", ");
23643       sb.append("row:");
23644       if (this.row == null) {
23645         sb.append("null");
23646       } else {
23647         sb.append(this.row);
23648       }
23649       first = false;
23650       if (!first) sb.append(", ");
23651       sb.append("timestamp:");
23652       sb.append(this.timestamp);
23653       first = false;
23654       sb.append(")");
23655       return sb.toString();
23656     }
23657 
23658     public void validate() throws TException {
23659       // check for required fields
23660     }
23661 
23662   }
23663 
23664   public static class deleteAllRowTs_result implements TBase<deleteAllRowTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteAllRowTs_result>   {
23665     private static final TStruct STRUCT_DESC = new TStruct("deleteAllRowTs_result");
23666 
23667     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
23668 
23669     public IOError io;
23670 
23671     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
23672     public enum _Fields implements TFieldIdEnum {
23673       IO((short)1, "io");
23674 
23675       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23676       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23677 
23678       static {
23679         for (_Fields field : EnumSet.allOf(_Fields.class)) {
23680           byId.put((int)field._thriftId, field);
23681           byName.put(field.getFieldName(), field);
23682         }
23683       }
23684 
23685       /**
23686        * Find the _Fields constant that matches fieldId, or null if its not found.
23687        */
23688       public static _Fields findByThriftId(int fieldId) {
23689         return byId.get(fieldId);
23690       }
23691 
23692       /**
23693        * Find the _Fields constant that matches fieldId, throwing an exception
23694        * if it is not found.
23695        */
23696       public static _Fields findByThriftIdOrThrow(int fieldId) {
23697         _Fields fields = findByThriftId(fieldId);
23698         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
23699         return fields;
23700       }
23701 
23702       /**
23703        * Find the _Fields constant that matches name, or null if its not found.
23704        */
23705       public static _Fields findByName(String name) {
23706         return byName.get(name);
23707       }
23708 
23709       private final short _thriftId;
23710       private final String _fieldName;
23711 
23712       _Fields(short thriftId, String fieldName) {
23713         _thriftId = thriftId;
23714         _fieldName = fieldName;
23715       }
23716 
23717       public short getThriftFieldId() {
23718         return _thriftId;
23719       }
23720 
23721       public String getFieldName() {
23722         return _fieldName;
23723       }
23724     }
23725 
23726     // isset id assignments
23727 
23728     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
23729       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
23730           new FieldValueMetaData(TType.STRUCT)));
23731     }});
23732 
23733     static {
23734       FieldMetaData.addStructMetaDataMap(deleteAllRowTs_result.class, metaDataMap);
23735     }
23736 
23737     public deleteAllRowTs_result() {
23738     }
23739 
23740     public deleteAllRowTs_result(
23741       IOError io)
23742     {
23743       this();
23744       this.io = io;
23745     }
23746 
23747     /**
23748      * Performs a deep copy on <i>other</i>.
23749      */
23750     public deleteAllRowTs_result(deleteAllRowTs_result other) {
23751       if (other.isSetIo()) {
23752         this.io = new IOError(other.io);
23753       }
23754     }
23755 
23756     public deleteAllRowTs_result deepCopy() {
23757       return new deleteAllRowTs_result(this);
23758     }
23759 
23760     @Deprecated
23761     public deleteAllRowTs_result clone() {
23762       return new deleteAllRowTs_result(this);
23763     }
23764 
23765     public IOError getIo() {
23766       return this.io;
23767     }
23768 
23769     public deleteAllRowTs_result setIo(IOError io) {
23770       this.io = io;
23771       return this;
23772     }
23773 
23774     public void unsetIo() {
23775       this.io = null;
23776     }
23777 
23778     /** Returns true if field io is set (has been asigned a value) and false otherwise */
23779     public boolean isSetIo() {
23780       return this.io != null;
23781     }
23782 
23783     public void setIoIsSet(boolean value) {
23784       if (!value) {
23785         this.io = null;
23786       }
23787     }
23788 
23789     public void setFieldValue(_Fields field, Object value) {
23790       switch (field) {
23791       case IO:
23792         if (value == null) {
23793           unsetIo();
23794         } else {
23795           setIo((IOError)value);
23796         }
23797         break;
23798 
23799       }
23800     }
23801 
23802     public void setFieldValue(int fieldID, Object value) {
23803       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
23804     }
23805 
23806     public Object getFieldValue(_Fields field) {
23807       switch (field) {
23808       case IO:
23809         return getIo();
23810 
23811       }
23812       throw new IllegalStateException();
23813     }
23814 
23815     public Object getFieldValue(int fieldId) {
23816       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
23817     }
23818 
23819     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
23820     public boolean isSet(_Fields field) {
23821       switch (field) {
23822       case IO:
23823         return isSetIo();
23824       }
23825       throw new IllegalStateException();
23826     }
23827 
23828     public boolean isSet(int fieldID) {
23829       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
23830     }
23831 
23832     @Override
23833     public boolean equals(Object that) {
23834       if (that == null)
23835         return false;
23836       if (that instanceof deleteAllRowTs_result)
23837         return this.equals((deleteAllRowTs_result)that);
23838       return false;
23839     }
23840 
23841     public boolean equals(deleteAllRowTs_result that) {
23842       if (that == null)
23843         return false;
23844 
23845       boolean this_present_io = true && this.isSetIo();
23846       boolean that_present_io = true && that.isSetIo();
23847       if (this_present_io || that_present_io) {
23848         if (!(this_present_io && that_present_io))
23849           return false;
23850         if (!this.io.equals(that.io))
23851           return false;
23852       }
23853 
23854       return true;
23855     }
23856 
23857     @Override
23858     public int hashCode() {
23859       HashCodeBuilder builder = new HashCodeBuilder();
23860 
23861       boolean present_io = true && (isSetIo());
23862       builder.append(present_io);
23863       if (present_io)
23864         builder.append(io);
23865 
23866       return builder.toHashCode();
23867     }
23868 
23869     public int compareTo(deleteAllRowTs_result other) {
23870       if (!getClass().equals(other.getClass())) {
23871         return getClass().getName().compareTo(other.getClass().getName());
23872       }
23873 
23874       int lastComparison = 0;
23875       deleteAllRowTs_result typedOther = (deleteAllRowTs_result)other;
23876 
23877       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
23878       if (lastComparison != 0) {
23879         return lastComparison;
23880       }
23881       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
23882       if (lastComparison != 0) {
23883         return lastComparison;
23884       }
23885       return 0;
23886     }
23887 
23888     public void read(TProtocol iprot) throws TException {
23889       TField field;
23890       iprot.readStructBegin();
23891       while (true)
23892       {
23893         field = iprot.readFieldBegin();
23894         if (field.type == TType.STOP) {
23895           break;
23896         }
23897         _Fields fieldId = _Fields.findByThriftId(field.id);
23898         if (fieldId == null) {
23899           TProtocolUtil.skip(iprot, field.type);
23900         } else {
23901           switch (fieldId) {
23902             case IO:
23903               if (field.type == TType.STRUCT) {
23904                 this.io = new IOError();
23905                 this.io.read(iprot);
23906               } else {
23907                 TProtocolUtil.skip(iprot, field.type);
23908               }
23909               break;
23910           }
23911           iprot.readFieldEnd();
23912         }
23913       }
23914       iprot.readStructEnd();
23915 
23916       // check for required fields of primitive type, which can't be checked in the validate method
23917       validate();
23918     }
23919 
23920     public void write(TProtocol oprot) throws TException {
23921       oprot.writeStructBegin(STRUCT_DESC);
23922 
23923       if (this.isSetIo()) {
23924         oprot.writeFieldBegin(IO_FIELD_DESC);
23925         this.io.write(oprot);
23926         oprot.writeFieldEnd();
23927       }
23928       oprot.writeFieldStop();
23929       oprot.writeStructEnd();
23930     }
23931 
23932     @Override
23933     public String toString() {
23934       StringBuilder sb = new StringBuilder("deleteAllRowTs_result(");
23935       boolean first = true;
23936 
23937       sb.append("io:");
23938       if (this.io == null) {
23939         sb.append("null");
23940       } else {
23941         sb.append(this.io);
23942       }
23943       first = false;
23944       sb.append(")");
23945       return sb.toString();
23946     }
23947 
23948     public void validate() throws TException {
23949       // check for required fields
23950     }
23951 
23952   }
23953 
23954   public static class scannerOpen_args implements TBase<scannerOpen_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_args>   {
23955     private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_args");
23956 
23957     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
23958     private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
23959     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
23960 
23961     /**
23962      * name of table
23963      */
23964     public byte[] tableName;
23965     /**
23966      * Starting row in table to scan.
23967      * Send "" (empty string) to start at the first row.
23968      */
23969     public byte[] startRow;
23970     /**
23971      * columns to scan. If column name is a column family, all
23972      * columns of the specified column family are returned. It's also possible
23973      * to pass a regex in the column qualifier.
23974      */
23975     public List<byte[]> columns;
23976 
23977     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
23978     public enum _Fields implements TFieldIdEnum {
23979       /**
23980        * name of table
23981        */
23982       TABLE_NAME((short)1, "tableName"),
23983       /**
23984        * Starting row in table to scan.
23985        * Send "" (empty string) to start at the first row.
23986        */
23987       START_ROW((short)2, "startRow"),
23988       /**
23989        * columns to scan. If column name is a column family, all
23990        * columns of the specified column family are returned. It's also possible
23991        * to pass a regex in the column qualifier.
23992        */
23993       COLUMNS((short)3, "columns");
23994 
23995       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
23996       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
23997 
23998       static {
23999         for (_Fields field : EnumSet.allOf(_Fields.class)) {
24000           byId.put((int)field._thriftId, field);
24001           byName.put(field.getFieldName(), field);
24002         }
24003       }
24004 
24005       /**
24006        * Find the _Fields constant that matches fieldId, or null if its not found.
24007        */
24008       public static _Fields findByThriftId(int fieldId) {
24009         return byId.get(fieldId);
24010       }
24011 
24012       /**
24013        * Find the _Fields constant that matches fieldId, throwing an exception
24014        * if it is not found.
24015        */
24016       public static _Fields findByThriftIdOrThrow(int fieldId) {
24017         _Fields fields = findByThriftId(fieldId);
24018         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24019         return fields;
24020       }
24021 
24022       /**
24023        * Find the _Fields constant that matches name, or null if its not found.
24024        */
24025       public static _Fields findByName(String name) {
24026         return byName.get(name);
24027       }
24028 
24029       private final short _thriftId;
24030       private final String _fieldName;
24031 
24032       _Fields(short thriftId, String fieldName) {
24033         _thriftId = thriftId;
24034         _fieldName = fieldName;
24035       }
24036 
24037       public short getThriftFieldId() {
24038         return _thriftId;
24039       }
24040 
24041       public String getFieldName() {
24042         return _fieldName;
24043       }
24044     }
24045 
24046     // isset id assignments
24047 
24048     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24049       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
24050           new FieldValueMetaData(TType.STRING)));
24051       put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
24052           new FieldValueMetaData(TType.STRING)));
24053       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
24054           new ListMetaData(TType.LIST,
24055               new FieldValueMetaData(TType.STRING))));
24056     }});
24057 
24058     static {
24059       FieldMetaData.addStructMetaDataMap(scannerOpen_args.class, metaDataMap);
24060     }
24061 
24062     public scannerOpen_args() {
24063     }
24064 
24065     public scannerOpen_args(
24066       byte[] tableName,
24067       byte[] startRow,
24068       List<byte[]> columns)
24069     {
24070       this();
24071       this.tableName = tableName;
24072       this.startRow = startRow;
24073       this.columns = columns;
24074     }
24075 
24076     /**
24077      * Performs a deep copy on <i>other</i>.
24078      */
24079     public scannerOpen_args(scannerOpen_args other) {
24080       if (other.isSetTableName()) {
24081         this.tableName = other.tableName;
24082       }
24083       if (other.isSetStartRow()) {
24084         this.startRow = other.startRow;
24085       }
24086       if (other.isSetColumns()) {
24087         List<byte[]> __this__columns = new ArrayList<byte[]>();
24088         for (byte[] other_element : other.columns) {
24089           __this__columns.add(other_element);
24090         }
24091         this.columns = __this__columns;
24092       }
24093     }
24094 
24095     public scannerOpen_args deepCopy() {
24096       return new scannerOpen_args(this);
24097     }
24098 
24099     @Deprecated
24100     public scannerOpen_args clone() {
24101       return new scannerOpen_args(this);
24102     }
24103 
24104     /**
24105      * name of table
24106      */
24107     public byte[] getTableName() {
24108       return this.tableName;
24109     }
24110 
24111     /**
24112      * name of table
24113      */
24114     public scannerOpen_args setTableName(byte[] tableName) {
24115       this.tableName = tableName;
24116       return this;
24117     }
24118 
24119     public void unsetTableName() {
24120       this.tableName = null;
24121     }
24122 
24123     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
24124     public boolean isSetTableName() {
24125       return this.tableName != null;
24126     }
24127 
24128     public void setTableNameIsSet(boolean value) {
24129       if (!value) {
24130         this.tableName = null;
24131       }
24132     }
24133 
24134     /**
24135      * Starting row in table to scan.
24136      * Send "" (empty string) to start at the first row.
24137      */
24138     public byte[] getStartRow() {
24139       return this.startRow;
24140     }
24141 
24142     /**
24143      * Starting row in table to scan.
24144      * Send "" (empty string) to start at the first row.
24145      */
24146     public scannerOpen_args setStartRow(byte[] startRow) {
24147       this.startRow = startRow;
24148       return this;
24149     }
24150 
24151     public void unsetStartRow() {
24152       this.startRow = null;
24153     }
24154 
24155     /** Returns true if field startRow is set (has been asigned a value) and false otherwise */
24156     public boolean isSetStartRow() {
24157       return this.startRow != null;
24158     }
24159 
24160     public void setStartRowIsSet(boolean value) {
24161       if (!value) {
24162         this.startRow = null;
24163       }
24164     }
24165 
24166     public int getColumnsSize() {
24167       return (this.columns == null) ? 0 : this.columns.size();
24168     }
24169 
24170     public java.util.Iterator<byte[]> getColumnsIterator() {
24171       return (this.columns == null) ? null : this.columns.iterator();
24172     }
24173 
24174     public void addToColumns(byte[] elem) {
24175       if (this.columns == null) {
24176         this.columns = new ArrayList<byte[]>();
24177       }
24178       this.columns.add(elem);
24179     }
24180 
24181     /**
24182      * columns to scan. If column name is a column family, all
24183      * columns of the specified column family are returned. It's also possible
24184      * to pass a regex in the column qualifier.
24185      */
24186     public List<byte[]> getColumns() {
24187       return this.columns;
24188     }
24189 
24190     /**
24191      * columns to scan. If column name is a column family, all
24192      * columns of the specified column family are returned. It's also possible
24193      * to pass a regex in the column qualifier.
24194      */
24195     public scannerOpen_args setColumns(List<byte[]> columns) {
24196       this.columns = columns;
24197       return this;
24198     }
24199 
24200     public void unsetColumns() {
24201       this.columns = null;
24202     }
24203 
24204     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
24205     public boolean isSetColumns() {
24206       return this.columns != null;
24207     }
24208 
24209     public void setColumnsIsSet(boolean value) {
24210       if (!value) {
24211         this.columns = null;
24212       }
24213     }
24214 
24215     public void setFieldValue(_Fields field, Object value) {
24216       switch (field) {
24217       case TABLE_NAME:
24218         if (value == null) {
24219           unsetTableName();
24220         } else {
24221           setTableName((byte[])value);
24222         }
24223         break;
24224 
24225       case START_ROW:
24226         if (value == null) {
24227           unsetStartRow();
24228         } else {
24229           setStartRow((byte[])value);
24230         }
24231         break;
24232 
24233       case COLUMNS:
24234         if (value == null) {
24235           unsetColumns();
24236         } else {
24237           setColumns((List<byte[]>)value);
24238         }
24239         break;
24240 
24241       }
24242     }
24243 
24244     public void setFieldValue(int fieldID, Object value) {
24245       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
24246     }
24247 
24248     public Object getFieldValue(_Fields field) {
24249       switch (field) {
24250       case TABLE_NAME:
24251         return getTableName();
24252 
24253       case START_ROW:
24254         return getStartRow();
24255 
24256       case COLUMNS:
24257         return getColumns();
24258 
24259       }
24260       throw new IllegalStateException();
24261     }
24262 
24263     public Object getFieldValue(int fieldId) {
24264       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
24265     }
24266 
24267     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
24268     public boolean isSet(_Fields field) {
24269       switch (field) {
24270       case TABLE_NAME:
24271         return isSetTableName();
24272       case START_ROW:
24273         return isSetStartRow();
24274       case COLUMNS:
24275         return isSetColumns();
24276       }
24277       throw new IllegalStateException();
24278     }
24279 
24280     public boolean isSet(int fieldID) {
24281       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
24282     }
24283 
24284     @Override
24285     public boolean equals(Object that) {
24286       if (that == null)
24287         return false;
24288       if (that instanceof scannerOpen_args)
24289         return this.equals((scannerOpen_args)that);
24290       return false;
24291     }
24292 
24293     public boolean equals(scannerOpen_args that) {
24294       if (that == null)
24295         return false;
24296 
24297       boolean this_present_tableName = true && this.isSetTableName();
24298       boolean that_present_tableName = true && that.isSetTableName();
24299       if (this_present_tableName || that_present_tableName) {
24300         if (!(this_present_tableName && that_present_tableName))
24301           return false;
24302         if (!java.util.Arrays.equals(this.tableName, that.tableName))
24303           return false;
24304       }
24305 
24306       boolean this_present_startRow = true && this.isSetStartRow();
24307       boolean that_present_startRow = true && that.isSetStartRow();
24308       if (this_present_startRow || that_present_startRow) {
24309         if (!(this_present_startRow && that_present_startRow))
24310           return false;
24311         if (!java.util.Arrays.equals(this.startRow, that.startRow))
24312           return false;
24313       }
24314 
24315       boolean this_present_columns = true && this.isSetColumns();
24316       boolean that_present_columns = true && that.isSetColumns();
24317       if (this_present_columns || that_present_columns) {
24318         if (!(this_present_columns && that_present_columns))
24319           return false;
24320         if (!this.columns.equals(that.columns))
24321           return false;
24322       }
24323 
24324       return true;
24325     }
24326 
24327     @Override
24328     public int hashCode() {
24329       HashCodeBuilder builder = new HashCodeBuilder();
24330 
24331       boolean present_tableName = true && (isSetTableName());
24332       builder.append(present_tableName);
24333       if (present_tableName)
24334         builder.append(tableName);
24335 
24336       boolean present_startRow = true && (isSetStartRow());
24337       builder.append(present_startRow);
24338       if (present_startRow)
24339         builder.append(startRow);
24340 
24341       boolean present_columns = true && (isSetColumns());
24342       builder.append(present_columns);
24343       if (present_columns)
24344         builder.append(columns);
24345 
24346       return builder.toHashCode();
24347     }
24348 
24349     public int compareTo(scannerOpen_args other) {
24350       if (!getClass().equals(other.getClass())) {
24351         return getClass().getName().compareTo(other.getClass().getName());
24352       }
24353 
24354       int lastComparison = 0;
24355       scannerOpen_args typedOther = (scannerOpen_args)other;
24356 
24357       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
24358       if (lastComparison != 0) {
24359         return lastComparison;
24360       }
24361       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
24362       if (lastComparison != 0) {
24363         return lastComparison;
24364       }
24365       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
24366       if (lastComparison != 0) {
24367         return lastComparison;
24368       }
24369       lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
24370       if (lastComparison != 0) {
24371         return lastComparison;
24372       }
24373       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
24374       if (lastComparison != 0) {
24375         return lastComparison;
24376       }
24377       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
24378       if (lastComparison != 0) {
24379         return lastComparison;
24380       }
24381       return 0;
24382     }
24383 
24384     public void read(TProtocol iprot) throws TException {
24385       TField field;
24386       iprot.readStructBegin();
24387       while (true)
24388       {
24389         field = iprot.readFieldBegin();
24390         if (field.type == TType.STOP) {
24391           break;
24392         }
24393         _Fields fieldId = _Fields.findByThriftId(field.id);
24394         if (fieldId == null) {
24395           TProtocolUtil.skip(iprot, field.type);
24396         } else {
24397           switch (fieldId) {
24398             case TABLE_NAME:
24399               if (field.type == TType.STRING) {
24400                 this.tableName = iprot.readBinary();
24401               } else {
24402                 TProtocolUtil.skip(iprot, field.type);
24403               }
24404               break;
24405             case START_ROW:
24406               if (field.type == TType.STRING) {
24407                 this.startRow = iprot.readBinary();
24408               } else {
24409                 TProtocolUtil.skip(iprot, field.type);
24410               }
24411               break;
24412             case COLUMNS:
24413               if (field.type == TType.LIST) {
24414                 {
24415                   TList _list78 = iprot.readListBegin();
24416                   this.columns = new ArrayList<byte[]>(_list78.size);
24417                   for (int _i79 = 0; _i79 < _list78.size; ++_i79)
24418                   {
24419                     byte[] _elem80;
24420                     _elem80 = iprot.readBinary();
24421                     this.columns.add(_elem80);
24422                   }
24423                   iprot.readListEnd();
24424                 }
24425               } else {
24426                 TProtocolUtil.skip(iprot, field.type);
24427               }
24428               break;
24429           }
24430           iprot.readFieldEnd();
24431         }
24432       }
24433       iprot.readStructEnd();
24434 
24435       // check for required fields of primitive type, which can't be checked in the validate method
24436       validate();
24437     }
24438 
24439     public void write(TProtocol oprot) throws TException {
24440       validate();
24441 
24442       oprot.writeStructBegin(STRUCT_DESC);
24443       if (this.tableName != null) {
24444         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
24445         oprot.writeBinary(this.tableName);
24446         oprot.writeFieldEnd();
24447       }
24448       if (this.startRow != null) {
24449         oprot.writeFieldBegin(START_ROW_FIELD_DESC);
24450         oprot.writeBinary(this.startRow);
24451         oprot.writeFieldEnd();
24452       }
24453       if (this.columns != null) {
24454         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
24455         {
24456           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
24457           for (byte[] _iter81 : this.columns)
24458           {
24459             oprot.writeBinary(_iter81);
24460           }
24461           oprot.writeListEnd();
24462         }
24463         oprot.writeFieldEnd();
24464       }
24465       oprot.writeFieldStop();
24466       oprot.writeStructEnd();
24467     }
24468 
24469     @Override
24470     public String toString() {
24471       StringBuilder sb = new StringBuilder("scannerOpen_args(");
24472       boolean first = true;
24473 
24474       sb.append("tableName:");
24475       if (this.tableName == null) {
24476         sb.append("null");
24477       } else {
24478         sb.append(this.tableName);
24479       }
24480       first = false;
24481       if (!first) sb.append(", ");
24482       sb.append("startRow:");
24483       if (this.startRow == null) {
24484         sb.append("null");
24485       } else {
24486         sb.append(this.startRow);
24487       }
24488       first = false;
24489       if (!first) sb.append(", ");
24490       sb.append("columns:");
24491       if (this.columns == null) {
24492         sb.append("null");
24493       } else {
24494         sb.append(this.columns);
24495       }
24496       first = false;
24497       sb.append(")");
24498       return sb.toString();
24499     }
24500 
24501     public void validate() throws TException {
24502       // check for required fields
24503     }
24504 
24505   }
24506 
24507   public static class scannerOpen_result implements TBase<scannerOpen_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpen_result>   {
24508     private static final TStruct STRUCT_DESC = new TStruct("scannerOpen_result");
24509 
24510     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
24511     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
24512 
24513     public int success;
24514     public IOError io;
24515 
24516     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
24517     public enum _Fields implements TFieldIdEnum {
24518       SUCCESS((short)0, "success"),
24519       IO((short)1, "io");
24520 
24521       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
24522       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
24523 
24524       static {
24525         for (_Fields field : EnumSet.allOf(_Fields.class)) {
24526           byId.put((int)field._thriftId, field);
24527           byName.put(field.getFieldName(), field);
24528         }
24529       }
24530 
24531       /**
24532        * Find the _Fields constant that matches fieldId, or null if its not found.
24533        */
24534       public static _Fields findByThriftId(int fieldId) {
24535         return byId.get(fieldId);
24536       }
24537 
24538       /**
24539        * Find the _Fields constant that matches fieldId, throwing an exception
24540        * if it is not found.
24541        */
24542       public static _Fields findByThriftIdOrThrow(int fieldId) {
24543         _Fields fields = findByThriftId(fieldId);
24544         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24545         return fields;
24546       }
24547 
24548       /**
24549        * Find the _Fields constant that matches name, or null if its not found.
24550        */
24551       public static _Fields findByName(String name) {
24552         return byName.get(name);
24553       }
24554 
24555       private final short _thriftId;
24556       private final String _fieldName;
24557 
24558       _Fields(short thriftId, String fieldName) {
24559         _thriftId = thriftId;
24560         _fieldName = fieldName;
24561       }
24562 
24563       public short getThriftFieldId() {
24564         return _thriftId;
24565       }
24566 
24567       public String getFieldName() {
24568         return _fieldName;
24569       }
24570     }
24571 
24572     // isset id assignments
24573     private static final int __SUCCESS_ISSET_ID = 0;
24574     private BitSet __isset_bit_vector = new BitSet(1);
24575 
24576     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24577       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
24578           new FieldValueMetaData(TType.I32)));
24579       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
24580           new FieldValueMetaData(TType.STRUCT)));
24581     }});
24582 
24583     static {
24584       FieldMetaData.addStructMetaDataMap(scannerOpen_result.class, metaDataMap);
24585     }
24586 
24587     public scannerOpen_result() {
24588     }
24589 
24590     public scannerOpen_result(
24591       int success,
24592       IOError io)
24593     {
24594       this();
24595       this.success = success;
24596       setSuccessIsSet(true);
24597       this.io = io;
24598     }
24599 
24600     /**
24601      * Performs a deep copy on <i>other</i>.
24602      */
24603     public scannerOpen_result(scannerOpen_result other) {
24604       __isset_bit_vector.clear();
24605       __isset_bit_vector.or(other.__isset_bit_vector);
24606       this.success = other.success;
24607       if (other.isSetIo()) {
24608         this.io = new IOError(other.io);
24609       }
24610     }
24611 
24612     public scannerOpen_result deepCopy() {
24613       return new scannerOpen_result(this);
24614     }
24615 
24616     @Deprecated
24617     public scannerOpen_result clone() {
24618       return new scannerOpen_result(this);
24619     }
24620 
24621     public int getSuccess() {
24622       return this.success;
24623     }
24624 
24625     public scannerOpen_result setSuccess(int success) {
24626       this.success = success;
24627       setSuccessIsSet(true);
24628       return this;
24629     }
24630 
24631     public void unsetSuccess() {
24632       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
24633     }
24634 
24635     /** Returns true if field success is set (has been asigned a value) and false otherwise */
24636     public boolean isSetSuccess() {
24637       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
24638     }
24639 
24640     public void setSuccessIsSet(boolean value) {
24641       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
24642     }
24643 
24644     public IOError getIo() {
24645       return this.io;
24646     }
24647 
24648     public scannerOpen_result setIo(IOError io) {
24649       this.io = io;
24650       return this;
24651     }
24652 
24653     public void unsetIo() {
24654       this.io = null;
24655     }
24656 
24657     /** Returns true if field io is set (has been asigned a value) and false otherwise */
24658     public boolean isSetIo() {
24659       return this.io != null;
24660     }
24661 
24662     public void setIoIsSet(boolean value) {
24663       if (!value) {
24664         this.io = null;
24665       }
24666     }
24667 
24668     public void setFieldValue(_Fields field, Object value) {
24669       switch (field) {
24670       case SUCCESS:
24671         if (value == null) {
24672           unsetSuccess();
24673         } else {
24674           setSuccess((Integer)value);
24675         }
24676         break;
24677 
24678       case IO:
24679         if (value == null) {
24680           unsetIo();
24681         } else {
24682           setIo((IOError)value);
24683         }
24684         break;
24685 
24686       }
24687     }
24688 
24689     public void setFieldValue(int fieldID, Object value) {
24690       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
24691     }
24692 
24693     public Object getFieldValue(_Fields field) {
24694       switch (field) {
24695       case SUCCESS:
24696         return new Integer(getSuccess());
24697 
24698       case IO:
24699         return getIo();
24700 
24701       }
24702       throw new IllegalStateException();
24703     }
24704 
24705     public Object getFieldValue(int fieldId) {
24706       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
24707     }
24708 
24709     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
24710     public boolean isSet(_Fields field) {
24711       switch (field) {
24712       case SUCCESS:
24713         return isSetSuccess();
24714       case IO:
24715         return isSetIo();
24716       }
24717       throw new IllegalStateException();
24718     }
24719 
24720     public boolean isSet(int fieldID) {
24721       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
24722     }
24723 
24724     @Override
24725     public boolean equals(Object that) {
24726       if (that == null)
24727         return false;
24728       if (that instanceof scannerOpen_result)
24729         return this.equals((scannerOpen_result)that);
24730       return false;
24731     }
24732 
24733     public boolean equals(scannerOpen_result that) {
24734       if (that == null)
24735         return false;
24736 
24737       boolean this_present_success = true;
24738       boolean that_present_success = true;
24739       if (this_present_success || that_present_success) {
24740         if (!(this_present_success && that_present_success))
24741           return false;
24742         if (this.success != that.success)
24743           return false;
24744       }
24745 
24746       boolean this_present_io = true && this.isSetIo();
24747       boolean that_present_io = true && that.isSetIo();
24748       if (this_present_io || that_present_io) {
24749         if (!(this_present_io && that_present_io))
24750           return false;
24751         if (!this.io.equals(that.io))
24752           return false;
24753       }
24754 
24755       return true;
24756     }
24757 
24758     @Override
24759     public int hashCode() {
24760       HashCodeBuilder builder = new HashCodeBuilder();
24761 
24762       boolean present_success = true;
24763       builder.append(present_success);
24764       if (present_success)
24765         builder.append(success);
24766 
24767       boolean present_io = true && (isSetIo());
24768       builder.append(present_io);
24769       if (present_io)
24770         builder.append(io);
24771 
24772       return builder.toHashCode();
24773     }
24774 
24775     public int compareTo(scannerOpen_result other) {
24776       if (!getClass().equals(other.getClass())) {
24777         return getClass().getName().compareTo(other.getClass().getName());
24778       }
24779 
24780       int lastComparison = 0;
24781       scannerOpen_result typedOther = (scannerOpen_result)other;
24782 
24783       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
24784       if (lastComparison != 0) {
24785         return lastComparison;
24786       }
24787       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
24788       if (lastComparison != 0) {
24789         return lastComparison;
24790       }
24791       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
24792       if (lastComparison != 0) {
24793         return lastComparison;
24794       }
24795       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
24796       if (lastComparison != 0) {
24797         return lastComparison;
24798       }
24799       return 0;
24800     }
24801 
24802     public void read(TProtocol iprot) throws TException {
24803       TField field;
24804       iprot.readStructBegin();
24805       while (true)
24806       {
24807         field = iprot.readFieldBegin();
24808         if (field.type == TType.STOP) {
24809           break;
24810         }
24811         _Fields fieldId = _Fields.findByThriftId(field.id);
24812         if (fieldId == null) {
24813           TProtocolUtil.skip(iprot, field.type);
24814         } else {
24815           switch (fieldId) {
24816             case SUCCESS:
24817               if (field.type == TType.I32) {
24818                 this.success = iprot.readI32();
24819                 setSuccessIsSet(true);
24820               } else {
24821                 TProtocolUtil.skip(iprot, field.type);
24822               }
24823               break;
24824             case IO:
24825               if (field.type == TType.STRUCT) {
24826                 this.io = new IOError();
24827                 this.io.read(iprot);
24828               } else {
24829                 TProtocolUtil.skip(iprot, field.type);
24830               }
24831               break;
24832           }
24833           iprot.readFieldEnd();
24834         }
24835       }
24836       iprot.readStructEnd();
24837 
24838       // check for required fields of primitive type, which can't be checked in the validate method
24839       validate();
24840     }
24841 
24842     public void write(TProtocol oprot) throws TException {
24843       oprot.writeStructBegin(STRUCT_DESC);
24844 
24845       if (this.isSetSuccess()) {
24846         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
24847         oprot.writeI32(this.success);
24848         oprot.writeFieldEnd();
24849       } else if (this.isSetIo()) {
24850         oprot.writeFieldBegin(IO_FIELD_DESC);
24851         this.io.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("scannerOpen_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       sb.append(")");
24875       return sb.toString();
24876     }
24877 
24878     public void validate() throws TException {
24879       // check for required fields
24880     }
24881 
24882   }
24883 
24884   public static class scannerOpenWithStop_args implements TBase<scannerOpenWithStop_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_args>   {
24885     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_args");
24886 
24887     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
24888     private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
24889     private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3);
24890     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4);
24891 
24892     /**
24893      * name of table
24894      */
24895     public byte[] tableName;
24896     /**
24897      * Starting row in table to scan.
24898      * Send "" (empty string) to start at the first row.
24899      */
24900     public byte[] startRow;
24901     /**
24902      * row to stop scanning on. This row is *not* included in the
24903      * scanner's results
24904      */
24905     public byte[] stopRow;
24906     /**
24907      * columns to scan. If column name is a column family, all
24908      * columns of the specified column family are returned. It's also possible
24909      * to pass a regex in the column qualifier.
24910      */
24911     public List<byte[]> columns;
24912 
24913     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
24914     public enum _Fields implements TFieldIdEnum {
24915       /**
24916        * name of table
24917        */
24918       TABLE_NAME((short)1, "tableName"),
24919       /**
24920        * Starting row in table to scan.
24921        * Send "" (empty string) to start at the first row.
24922        */
24923       START_ROW((short)2, "startRow"),
24924       /**
24925        * row to stop scanning on. This row is *not* included in the
24926        * scanner's results
24927        */
24928       STOP_ROW((short)3, "stopRow"),
24929       /**
24930        * columns to scan. If column name is a column family, all
24931        * columns of the specified column family are returned. It's also possible
24932        * to pass a regex in the column qualifier.
24933        */
24934       COLUMNS((short)4, "columns");
24935 
24936       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
24937       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
24938 
24939       static {
24940         for (_Fields field : EnumSet.allOf(_Fields.class)) {
24941           byId.put((int)field._thriftId, field);
24942           byName.put(field.getFieldName(), field);
24943         }
24944       }
24945 
24946       /**
24947        * Find the _Fields constant that matches fieldId, or null if its not found.
24948        */
24949       public static _Fields findByThriftId(int fieldId) {
24950         return byId.get(fieldId);
24951       }
24952 
24953       /**
24954        * Find the _Fields constant that matches fieldId, throwing an exception
24955        * if it is not found.
24956        */
24957       public static _Fields findByThriftIdOrThrow(int fieldId) {
24958         _Fields fields = findByThriftId(fieldId);
24959         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
24960         return fields;
24961       }
24962 
24963       /**
24964        * Find the _Fields constant that matches name, or null if its not found.
24965        */
24966       public static _Fields findByName(String name) {
24967         return byName.get(name);
24968       }
24969 
24970       private final short _thriftId;
24971       private final String _fieldName;
24972 
24973       _Fields(short thriftId, String fieldName) {
24974         _thriftId = thriftId;
24975         _fieldName = fieldName;
24976       }
24977 
24978       public short getThriftFieldId() {
24979         return _thriftId;
24980       }
24981 
24982       public String getFieldName() {
24983         return _fieldName;
24984       }
24985     }
24986 
24987     // isset id assignments
24988 
24989     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
24990       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
24991           new FieldValueMetaData(TType.STRING)));
24992       put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
24993           new FieldValueMetaData(TType.STRING)));
24994       put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT,
24995           new FieldValueMetaData(TType.STRING)));
24996       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
24997           new ListMetaData(TType.LIST,
24998               new FieldValueMetaData(TType.STRING))));
24999     }});
25000 
25001     static {
25002       FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_args.class, metaDataMap);
25003     }
25004 
25005     public scannerOpenWithStop_args() {
25006     }
25007 
25008     public scannerOpenWithStop_args(
25009       byte[] tableName,
25010       byte[] startRow,
25011       byte[] stopRow,
25012       List<byte[]> columns)
25013     {
25014       this();
25015       this.tableName = tableName;
25016       this.startRow = startRow;
25017       this.stopRow = stopRow;
25018       this.columns = columns;
25019     }
25020 
25021     /**
25022      * Performs a deep copy on <i>other</i>.
25023      */
25024     public scannerOpenWithStop_args(scannerOpenWithStop_args other) {
25025       if (other.isSetTableName()) {
25026         this.tableName = other.tableName;
25027       }
25028       if (other.isSetStartRow()) {
25029         this.startRow = other.startRow;
25030       }
25031       if (other.isSetStopRow()) {
25032         this.stopRow = other.stopRow;
25033       }
25034       if (other.isSetColumns()) {
25035         List<byte[]> __this__columns = new ArrayList<byte[]>();
25036         for (byte[] other_element : other.columns) {
25037           __this__columns.add(other_element);
25038         }
25039         this.columns = __this__columns;
25040       }
25041     }
25042 
25043     public scannerOpenWithStop_args deepCopy() {
25044       return new scannerOpenWithStop_args(this);
25045     }
25046 
25047     @Deprecated
25048     public scannerOpenWithStop_args clone() {
25049       return new scannerOpenWithStop_args(this);
25050     }
25051 
25052     /**
25053      * name of table
25054      */
25055     public byte[] getTableName() {
25056       return this.tableName;
25057     }
25058 
25059     /**
25060      * name of table
25061      */
25062     public scannerOpenWithStop_args setTableName(byte[] tableName) {
25063       this.tableName = tableName;
25064       return this;
25065     }
25066 
25067     public void unsetTableName() {
25068       this.tableName = null;
25069     }
25070 
25071     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
25072     public boolean isSetTableName() {
25073       return this.tableName != null;
25074     }
25075 
25076     public void setTableNameIsSet(boolean value) {
25077       if (!value) {
25078         this.tableName = null;
25079       }
25080     }
25081 
25082     /**
25083      * Starting row in table to scan.
25084      * Send "" (empty string) to start at the first row.
25085      */
25086     public byte[] getStartRow() {
25087       return this.startRow;
25088     }
25089 
25090     /**
25091      * Starting row in table to scan.
25092      * Send "" (empty string) to start at the first row.
25093      */
25094     public scannerOpenWithStop_args setStartRow(byte[] startRow) {
25095       this.startRow = startRow;
25096       return this;
25097     }
25098 
25099     public void unsetStartRow() {
25100       this.startRow = null;
25101     }
25102 
25103     /** Returns true if field startRow is set (has been asigned a value) and false otherwise */
25104     public boolean isSetStartRow() {
25105       return this.startRow != null;
25106     }
25107 
25108     public void setStartRowIsSet(boolean value) {
25109       if (!value) {
25110         this.startRow = null;
25111       }
25112     }
25113 
25114     /**
25115      * row to stop scanning on. This row is *not* included in the
25116      * scanner's results
25117      */
25118     public byte[] getStopRow() {
25119       return this.stopRow;
25120     }
25121 
25122     /**
25123      * row to stop scanning on. This row is *not* included in the
25124      * scanner's results
25125      */
25126     public scannerOpenWithStop_args setStopRow(byte[] stopRow) {
25127       this.stopRow = stopRow;
25128       return this;
25129     }
25130 
25131     public void unsetStopRow() {
25132       this.stopRow = null;
25133     }
25134 
25135     /** Returns true if field stopRow is set (has been asigned a value) and false otherwise */
25136     public boolean isSetStopRow() {
25137       return this.stopRow != null;
25138     }
25139 
25140     public void setStopRowIsSet(boolean value) {
25141       if (!value) {
25142         this.stopRow = null;
25143       }
25144     }
25145 
25146     public int getColumnsSize() {
25147       return (this.columns == null) ? 0 : this.columns.size();
25148     }
25149 
25150     public java.util.Iterator<byte[]> getColumnsIterator() {
25151       return (this.columns == null) ? null : this.columns.iterator();
25152     }
25153 
25154     public void addToColumns(byte[] elem) {
25155       if (this.columns == null) {
25156         this.columns = new ArrayList<byte[]>();
25157       }
25158       this.columns.add(elem);
25159     }
25160 
25161     /**
25162      * columns to scan. If column name is a column family, all
25163      * columns of the specified column family are returned. It's also possible
25164      * to pass a regex in the column qualifier.
25165      */
25166     public List<byte[]> getColumns() {
25167       return this.columns;
25168     }
25169 
25170     /**
25171      * columns to scan. If column name is a column family, all
25172      * columns of the specified column family are returned. It's also possible
25173      * to pass a regex in the column qualifier.
25174      */
25175     public scannerOpenWithStop_args setColumns(List<byte[]> columns) {
25176       this.columns = columns;
25177       return this;
25178     }
25179 
25180     public void unsetColumns() {
25181       this.columns = null;
25182     }
25183 
25184     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
25185     public boolean isSetColumns() {
25186       return this.columns != null;
25187     }
25188 
25189     public void setColumnsIsSet(boolean value) {
25190       if (!value) {
25191         this.columns = null;
25192       }
25193     }
25194 
25195     public void setFieldValue(_Fields field, Object value) {
25196       switch (field) {
25197       case TABLE_NAME:
25198         if (value == null) {
25199           unsetTableName();
25200         } else {
25201           setTableName((byte[])value);
25202         }
25203         break;
25204 
25205       case START_ROW:
25206         if (value == null) {
25207           unsetStartRow();
25208         } else {
25209           setStartRow((byte[])value);
25210         }
25211         break;
25212 
25213       case STOP_ROW:
25214         if (value == null) {
25215           unsetStopRow();
25216         } else {
25217           setStopRow((byte[])value);
25218         }
25219         break;
25220 
25221       case COLUMNS:
25222         if (value == null) {
25223           unsetColumns();
25224         } else {
25225           setColumns((List<byte[]>)value);
25226         }
25227         break;
25228 
25229       }
25230     }
25231 
25232     public void setFieldValue(int fieldID, Object value) {
25233       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
25234     }
25235 
25236     public Object getFieldValue(_Fields field) {
25237       switch (field) {
25238       case TABLE_NAME:
25239         return getTableName();
25240 
25241       case START_ROW:
25242         return getStartRow();
25243 
25244       case STOP_ROW:
25245         return getStopRow();
25246 
25247       case COLUMNS:
25248         return getColumns();
25249 
25250       }
25251       throw new IllegalStateException();
25252     }
25253 
25254     public Object getFieldValue(int fieldId) {
25255       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
25256     }
25257 
25258     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
25259     public boolean isSet(_Fields field) {
25260       switch (field) {
25261       case TABLE_NAME:
25262         return isSetTableName();
25263       case START_ROW:
25264         return isSetStartRow();
25265       case STOP_ROW:
25266         return isSetStopRow();
25267       case COLUMNS:
25268         return isSetColumns();
25269       }
25270       throw new IllegalStateException();
25271     }
25272 
25273     public boolean isSet(int fieldID) {
25274       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
25275     }
25276 
25277     @Override
25278     public boolean equals(Object that) {
25279       if (that == null)
25280         return false;
25281       if (that instanceof scannerOpenWithStop_args)
25282         return this.equals((scannerOpenWithStop_args)that);
25283       return false;
25284     }
25285 
25286     public boolean equals(scannerOpenWithStop_args that) {
25287       if (that == null)
25288         return false;
25289 
25290       boolean this_present_tableName = true && this.isSetTableName();
25291       boolean that_present_tableName = true && that.isSetTableName();
25292       if (this_present_tableName || that_present_tableName) {
25293         if (!(this_present_tableName && that_present_tableName))
25294           return false;
25295         if (!java.util.Arrays.equals(this.tableName, that.tableName))
25296           return false;
25297       }
25298 
25299       boolean this_present_startRow = true && this.isSetStartRow();
25300       boolean that_present_startRow = true && that.isSetStartRow();
25301       if (this_present_startRow || that_present_startRow) {
25302         if (!(this_present_startRow && that_present_startRow))
25303           return false;
25304         if (!java.util.Arrays.equals(this.startRow, that.startRow))
25305           return false;
25306       }
25307 
25308       boolean this_present_stopRow = true && this.isSetStopRow();
25309       boolean that_present_stopRow = true && that.isSetStopRow();
25310       if (this_present_stopRow || that_present_stopRow) {
25311         if (!(this_present_stopRow && that_present_stopRow))
25312           return false;
25313         if (!java.util.Arrays.equals(this.stopRow, that.stopRow))
25314           return false;
25315       }
25316 
25317       boolean this_present_columns = true && this.isSetColumns();
25318       boolean that_present_columns = true && that.isSetColumns();
25319       if (this_present_columns || that_present_columns) {
25320         if (!(this_present_columns && that_present_columns))
25321           return false;
25322         if (!this.columns.equals(that.columns))
25323           return false;
25324       }
25325 
25326       return true;
25327     }
25328 
25329     @Override
25330     public int hashCode() {
25331       HashCodeBuilder builder = new HashCodeBuilder();
25332 
25333       boolean present_tableName = true && (isSetTableName());
25334       builder.append(present_tableName);
25335       if (present_tableName)
25336         builder.append(tableName);
25337 
25338       boolean present_startRow = true && (isSetStartRow());
25339       builder.append(present_startRow);
25340       if (present_startRow)
25341         builder.append(startRow);
25342 
25343       boolean present_stopRow = true && (isSetStopRow());
25344       builder.append(present_stopRow);
25345       if (present_stopRow)
25346         builder.append(stopRow);
25347 
25348       boolean present_columns = true && (isSetColumns());
25349       builder.append(present_columns);
25350       if (present_columns)
25351         builder.append(columns);
25352 
25353       return builder.toHashCode();
25354     }
25355 
25356     public int compareTo(scannerOpenWithStop_args other) {
25357       if (!getClass().equals(other.getClass())) {
25358         return getClass().getName().compareTo(other.getClass().getName());
25359       }
25360 
25361       int lastComparison = 0;
25362       scannerOpenWithStop_args typedOther = (scannerOpenWithStop_args)other;
25363 
25364       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
25365       if (lastComparison != 0) {
25366         return lastComparison;
25367       }
25368       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
25369       if (lastComparison != 0) {
25370         return lastComparison;
25371       }
25372       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
25373       if (lastComparison != 0) {
25374         return lastComparison;
25375       }
25376       lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
25377       if (lastComparison != 0) {
25378         return lastComparison;
25379       }
25380       lastComparison = Boolean.valueOf(isSetStopRow()).compareTo(isSetStopRow());
25381       if (lastComparison != 0) {
25382         return lastComparison;
25383       }
25384       lastComparison = TBaseHelper.compareTo(stopRow, typedOther.stopRow);
25385       if (lastComparison != 0) {
25386         return lastComparison;
25387       }
25388       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
25389       if (lastComparison != 0) {
25390         return lastComparison;
25391       }
25392       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
25393       if (lastComparison != 0) {
25394         return lastComparison;
25395       }
25396       return 0;
25397     }
25398 
25399     public void read(TProtocol iprot) throws TException {
25400       TField field;
25401       iprot.readStructBegin();
25402       while (true)
25403       {
25404         field = iprot.readFieldBegin();
25405         if (field.type == TType.STOP) {
25406           break;
25407         }
25408         _Fields fieldId = _Fields.findByThriftId(field.id);
25409         if (fieldId == null) {
25410           TProtocolUtil.skip(iprot, field.type);
25411         } else {
25412           switch (fieldId) {
25413             case TABLE_NAME:
25414               if (field.type == TType.STRING) {
25415                 this.tableName = iprot.readBinary();
25416               } else {
25417                 TProtocolUtil.skip(iprot, field.type);
25418               }
25419               break;
25420             case START_ROW:
25421               if (field.type == TType.STRING) {
25422                 this.startRow = iprot.readBinary();
25423               } else {
25424                 TProtocolUtil.skip(iprot, field.type);
25425               }
25426               break;
25427             case STOP_ROW:
25428               if (field.type == TType.STRING) {
25429                 this.stopRow = iprot.readBinary();
25430               } else {
25431                 TProtocolUtil.skip(iprot, field.type);
25432               }
25433               break;
25434             case COLUMNS:
25435               if (field.type == TType.LIST) {
25436                 {
25437                   TList _list82 = iprot.readListBegin();
25438                   this.columns = new ArrayList<byte[]>(_list82.size);
25439                   for (int _i83 = 0; _i83 < _list82.size; ++_i83)
25440                   {
25441                     byte[] _elem84;
25442                     _elem84 = iprot.readBinary();
25443                     this.columns.add(_elem84);
25444                   }
25445                   iprot.readListEnd();
25446                 }
25447               } else {
25448                 TProtocolUtil.skip(iprot, field.type);
25449               }
25450               break;
25451           }
25452           iprot.readFieldEnd();
25453         }
25454       }
25455       iprot.readStructEnd();
25456 
25457       // check for required fields of primitive type, which can't be checked in the validate method
25458       validate();
25459     }
25460 
25461     public void write(TProtocol oprot) throws TException {
25462       validate();
25463 
25464       oprot.writeStructBegin(STRUCT_DESC);
25465       if (this.tableName != null) {
25466         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
25467         oprot.writeBinary(this.tableName);
25468         oprot.writeFieldEnd();
25469       }
25470       if (this.startRow != null) {
25471         oprot.writeFieldBegin(START_ROW_FIELD_DESC);
25472         oprot.writeBinary(this.startRow);
25473         oprot.writeFieldEnd();
25474       }
25475       if (this.stopRow != null) {
25476         oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
25477         oprot.writeBinary(this.stopRow);
25478         oprot.writeFieldEnd();
25479       }
25480       if (this.columns != null) {
25481         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
25482         {
25483           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
25484           for (byte[] _iter85 : this.columns)
25485           {
25486             oprot.writeBinary(_iter85);
25487           }
25488           oprot.writeListEnd();
25489         }
25490         oprot.writeFieldEnd();
25491       }
25492       oprot.writeFieldStop();
25493       oprot.writeStructEnd();
25494     }
25495 
25496     @Override
25497     public String toString() {
25498       StringBuilder sb = new StringBuilder("scannerOpenWithStop_args(");
25499       boolean first = true;
25500 
25501       sb.append("tableName:");
25502       if (this.tableName == null) {
25503         sb.append("null");
25504       } else {
25505         sb.append(this.tableName);
25506       }
25507       first = false;
25508       if (!first) sb.append(", ");
25509       sb.append("startRow:");
25510       if (this.startRow == null) {
25511         sb.append("null");
25512       } else {
25513         sb.append(this.startRow);
25514       }
25515       first = false;
25516       if (!first) sb.append(", ");
25517       sb.append("stopRow:");
25518       if (this.stopRow == null) {
25519         sb.append("null");
25520       } else {
25521         sb.append(this.stopRow);
25522       }
25523       first = false;
25524       if (!first) sb.append(", ");
25525       sb.append("columns:");
25526       if (this.columns == null) {
25527         sb.append("null");
25528       } else {
25529         sb.append(this.columns);
25530       }
25531       first = false;
25532       sb.append(")");
25533       return sb.toString();
25534     }
25535 
25536     public void validate() throws TException {
25537       // check for required fields
25538     }
25539 
25540   }
25541 
25542   public static class scannerOpenWithStop_result implements TBase<scannerOpenWithStop_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStop_result>   {
25543     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStop_result");
25544 
25545     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
25546     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
25547 
25548     public int success;
25549     public IOError io;
25550 
25551     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
25552     public enum _Fields implements TFieldIdEnum {
25553       SUCCESS((short)0, "success"),
25554       IO((short)1, "io");
25555 
25556       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
25557       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
25558 
25559       static {
25560         for (_Fields field : EnumSet.allOf(_Fields.class)) {
25561           byId.put((int)field._thriftId, field);
25562           byName.put(field.getFieldName(), field);
25563         }
25564       }
25565 
25566       /**
25567        * Find the _Fields constant that matches fieldId, or null if its not found.
25568        */
25569       public static _Fields findByThriftId(int fieldId) {
25570         return byId.get(fieldId);
25571       }
25572 
25573       /**
25574        * Find the _Fields constant that matches fieldId, throwing an exception
25575        * if it is not found.
25576        */
25577       public static _Fields findByThriftIdOrThrow(int fieldId) {
25578         _Fields fields = findByThriftId(fieldId);
25579         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
25580         return fields;
25581       }
25582 
25583       /**
25584        * Find the _Fields constant that matches name, or null if its not found.
25585        */
25586       public static _Fields findByName(String name) {
25587         return byName.get(name);
25588       }
25589 
25590       private final short _thriftId;
25591       private final String _fieldName;
25592 
25593       _Fields(short thriftId, String fieldName) {
25594         _thriftId = thriftId;
25595         _fieldName = fieldName;
25596       }
25597 
25598       public short getThriftFieldId() {
25599         return _thriftId;
25600       }
25601 
25602       public String getFieldName() {
25603         return _fieldName;
25604       }
25605     }
25606 
25607     // isset id assignments
25608     private static final int __SUCCESS_ISSET_ID = 0;
25609     private BitSet __isset_bit_vector = new BitSet(1);
25610 
25611     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
25612       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
25613           new FieldValueMetaData(TType.I32)));
25614       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
25615           new FieldValueMetaData(TType.STRUCT)));
25616     }});
25617 
25618     static {
25619       FieldMetaData.addStructMetaDataMap(scannerOpenWithStop_result.class, metaDataMap);
25620     }
25621 
25622     public scannerOpenWithStop_result() {
25623     }
25624 
25625     public scannerOpenWithStop_result(
25626       int success,
25627       IOError io)
25628     {
25629       this();
25630       this.success = success;
25631       setSuccessIsSet(true);
25632       this.io = io;
25633     }
25634 
25635     /**
25636      * Performs a deep copy on <i>other</i>.
25637      */
25638     public scannerOpenWithStop_result(scannerOpenWithStop_result other) {
25639       __isset_bit_vector.clear();
25640       __isset_bit_vector.or(other.__isset_bit_vector);
25641       this.success = other.success;
25642       if (other.isSetIo()) {
25643         this.io = new IOError(other.io);
25644       }
25645     }
25646 
25647     public scannerOpenWithStop_result deepCopy() {
25648       return new scannerOpenWithStop_result(this);
25649     }
25650 
25651     @Deprecated
25652     public scannerOpenWithStop_result clone() {
25653       return new scannerOpenWithStop_result(this);
25654     }
25655 
25656     public int getSuccess() {
25657       return this.success;
25658     }
25659 
25660     public scannerOpenWithStop_result setSuccess(int success) {
25661       this.success = success;
25662       setSuccessIsSet(true);
25663       return this;
25664     }
25665 
25666     public void unsetSuccess() {
25667       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
25668     }
25669 
25670     /** Returns true if field success is set (has been asigned a value) and false otherwise */
25671     public boolean isSetSuccess() {
25672       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
25673     }
25674 
25675     public void setSuccessIsSet(boolean value) {
25676       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
25677     }
25678 
25679     public IOError getIo() {
25680       return this.io;
25681     }
25682 
25683     public scannerOpenWithStop_result setIo(IOError io) {
25684       this.io = io;
25685       return this;
25686     }
25687 
25688     public void unsetIo() {
25689       this.io = null;
25690     }
25691 
25692     /** Returns true if field io is set (has been asigned a value) and false otherwise */
25693     public boolean isSetIo() {
25694       return this.io != null;
25695     }
25696 
25697     public void setIoIsSet(boolean value) {
25698       if (!value) {
25699         this.io = null;
25700       }
25701     }
25702 
25703     public void setFieldValue(_Fields field, Object value) {
25704       switch (field) {
25705       case SUCCESS:
25706         if (value == null) {
25707           unsetSuccess();
25708         } else {
25709           setSuccess((Integer)value);
25710         }
25711         break;
25712 
25713       case IO:
25714         if (value == null) {
25715           unsetIo();
25716         } else {
25717           setIo((IOError)value);
25718         }
25719         break;
25720 
25721       }
25722     }
25723 
25724     public void setFieldValue(int fieldID, Object value) {
25725       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
25726     }
25727 
25728     public Object getFieldValue(_Fields field) {
25729       switch (field) {
25730       case SUCCESS:
25731         return new Integer(getSuccess());
25732 
25733       case IO:
25734         return getIo();
25735 
25736       }
25737       throw new IllegalStateException();
25738     }
25739 
25740     public Object getFieldValue(int fieldId) {
25741       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
25742     }
25743 
25744     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
25745     public boolean isSet(_Fields field) {
25746       switch (field) {
25747       case SUCCESS:
25748         return isSetSuccess();
25749       case IO:
25750         return isSetIo();
25751       }
25752       throw new IllegalStateException();
25753     }
25754 
25755     public boolean isSet(int fieldID) {
25756       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
25757     }
25758 
25759     @Override
25760     public boolean equals(Object that) {
25761       if (that == null)
25762         return false;
25763       if (that instanceof scannerOpenWithStop_result)
25764         return this.equals((scannerOpenWithStop_result)that);
25765       return false;
25766     }
25767 
25768     public boolean equals(scannerOpenWithStop_result that) {
25769       if (that == null)
25770         return false;
25771 
25772       boolean this_present_success = true;
25773       boolean that_present_success = true;
25774       if (this_present_success || that_present_success) {
25775         if (!(this_present_success && that_present_success))
25776           return false;
25777         if (this.success != that.success)
25778           return false;
25779       }
25780 
25781       boolean this_present_io = true && this.isSetIo();
25782       boolean that_present_io = true && that.isSetIo();
25783       if (this_present_io || that_present_io) {
25784         if (!(this_present_io && that_present_io))
25785           return false;
25786         if (!this.io.equals(that.io))
25787           return false;
25788       }
25789 
25790       return true;
25791     }
25792 
25793     @Override
25794     public int hashCode() {
25795       HashCodeBuilder builder = new HashCodeBuilder();
25796 
25797       boolean present_success = true;
25798       builder.append(present_success);
25799       if (present_success)
25800         builder.append(success);
25801 
25802       boolean present_io = true && (isSetIo());
25803       builder.append(present_io);
25804       if (present_io)
25805         builder.append(io);
25806 
25807       return builder.toHashCode();
25808     }
25809 
25810     public int compareTo(scannerOpenWithStop_result other) {
25811       if (!getClass().equals(other.getClass())) {
25812         return getClass().getName().compareTo(other.getClass().getName());
25813       }
25814 
25815       int lastComparison = 0;
25816       scannerOpenWithStop_result typedOther = (scannerOpenWithStop_result)other;
25817 
25818       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
25819       if (lastComparison != 0) {
25820         return lastComparison;
25821       }
25822       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
25823       if (lastComparison != 0) {
25824         return lastComparison;
25825       }
25826       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
25827       if (lastComparison != 0) {
25828         return lastComparison;
25829       }
25830       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
25831       if (lastComparison != 0) {
25832         return lastComparison;
25833       }
25834       return 0;
25835     }
25836 
25837     public void read(TProtocol iprot) throws TException {
25838       TField field;
25839       iprot.readStructBegin();
25840       while (true)
25841       {
25842         field = iprot.readFieldBegin();
25843         if (field.type == TType.STOP) {
25844           break;
25845         }
25846         _Fields fieldId = _Fields.findByThriftId(field.id);
25847         if (fieldId == null) {
25848           TProtocolUtil.skip(iprot, field.type);
25849         } else {
25850           switch (fieldId) {
25851             case SUCCESS:
25852               if (field.type == TType.I32) {
25853                 this.success = iprot.readI32();
25854                 setSuccessIsSet(true);
25855               } else {
25856                 TProtocolUtil.skip(iprot, field.type);
25857               }
25858               break;
25859             case IO:
25860               if (field.type == TType.STRUCT) {
25861                 this.io = new IOError();
25862                 this.io.read(iprot);
25863               } else {
25864                 TProtocolUtil.skip(iprot, field.type);
25865               }
25866               break;
25867           }
25868           iprot.readFieldEnd();
25869         }
25870       }
25871       iprot.readStructEnd();
25872 
25873       // check for required fields of primitive type, which can't be checked in the validate method
25874       validate();
25875     }
25876 
25877     public void write(TProtocol oprot) throws TException {
25878       oprot.writeStructBegin(STRUCT_DESC);
25879 
25880       if (this.isSetSuccess()) {
25881         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25882         oprot.writeI32(this.success);
25883         oprot.writeFieldEnd();
25884       } else if (this.isSetIo()) {
25885         oprot.writeFieldBegin(IO_FIELD_DESC);
25886         this.io.write(oprot);
25887         oprot.writeFieldEnd();
25888       }
25889       oprot.writeFieldStop();
25890       oprot.writeStructEnd();
25891     }
25892 
25893     @Override
25894     public String toString() {
25895       StringBuilder sb = new StringBuilder("scannerOpenWithStop_result(");
25896       boolean first = true;
25897 
25898       sb.append("success:");
25899       sb.append(this.success);
25900       first = false;
25901       if (!first) sb.append(", ");
25902       sb.append("io:");
25903       if (this.io == null) {
25904         sb.append("null");
25905       } else {
25906         sb.append(this.io);
25907       }
25908       first = false;
25909       sb.append(")");
25910       return sb.toString();
25911     }
25912 
25913     public void validate() throws TException {
25914       // check for required fields
25915     }
25916 
25917   }
25918 
25919   public static class scannerOpenWithPrefix_args implements TBase<scannerOpenWithPrefix_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_args>   {
25920     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_args");
25921 
25922     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
25923     private static final TField START_AND_PREFIX_FIELD_DESC = new TField("startAndPrefix", TType.STRING, (short)2);
25924     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
25925 
25926     /**
25927      * name of table
25928      */
25929     public byte[] tableName;
25930     /**
25931      * the prefix (and thus start row) of the keys you want
25932      */
25933     public byte[] startAndPrefix;
25934     /**
25935      * the columns you want returned
25936      */
25937     public List<byte[]> columns;
25938 
25939     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
25940     public enum _Fields implements TFieldIdEnum {
25941       /**
25942        * name of table
25943        */
25944       TABLE_NAME((short)1, "tableName"),
25945       /**
25946        * the prefix (and thus start row) of the keys you want
25947        */
25948       START_AND_PREFIX((short)2, "startAndPrefix"),
25949       /**
25950        * the columns you want returned
25951        */
25952       COLUMNS((short)3, "columns");
25953 
25954       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
25955       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
25956 
25957       static {
25958         for (_Fields field : EnumSet.allOf(_Fields.class)) {
25959           byId.put((int)field._thriftId, field);
25960           byName.put(field.getFieldName(), field);
25961         }
25962       }
25963 
25964       /**
25965        * Find the _Fields constant that matches fieldId, or null if its not found.
25966        */
25967       public static _Fields findByThriftId(int fieldId) {
25968         return byId.get(fieldId);
25969       }
25970 
25971       /**
25972        * Find the _Fields constant that matches fieldId, throwing an exception
25973        * if it is not found.
25974        */
25975       public static _Fields findByThriftIdOrThrow(int fieldId) {
25976         _Fields fields = findByThriftId(fieldId);
25977         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
25978         return fields;
25979       }
25980 
25981       /**
25982        * Find the _Fields constant that matches name, or null if its not found.
25983        */
25984       public static _Fields findByName(String name) {
25985         return byName.get(name);
25986       }
25987 
25988       private final short _thriftId;
25989       private final String _fieldName;
25990 
25991       _Fields(short thriftId, String fieldName) {
25992         _thriftId = thriftId;
25993         _fieldName = fieldName;
25994       }
25995 
25996       public short getThriftFieldId() {
25997         return _thriftId;
25998       }
25999 
26000       public String getFieldName() {
26001         return _fieldName;
26002       }
26003     }
26004 
26005     // isset id assignments
26006 
26007     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26008       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
26009           new FieldValueMetaData(TType.STRING)));
26010       put(_Fields.START_AND_PREFIX, new FieldMetaData("startAndPrefix", TFieldRequirementType.DEFAULT,
26011           new FieldValueMetaData(TType.STRING)));
26012       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
26013           new ListMetaData(TType.LIST,
26014               new FieldValueMetaData(TType.STRING))));
26015     }});
26016 
26017     static {
26018       FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_args.class, metaDataMap);
26019     }
26020 
26021     public scannerOpenWithPrefix_args() {
26022     }
26023 
26024     public scannerOpenWithPrefix_args(
26025       byte[] tableName,
26026       byte[] startAndPrefix,
26027       List<byte[]> columns)
26028     {
26029       this();
26030       this.tableName = tableName;
26031       this.startAndPrefix = startAndPrefix;
26032       this.columns = columns;
26033     }
26034 
26035     /**
26036      * Performs a deep copy on <i>other</i>.
26037      */
26038     public scannerOpenWithPrefix_args(scannerOpenWithPrefix_args other) {
26039       if (other.isSetTableName()) {
26040         this.tableName = other.tableName;
26041       }
26042       if (other.isSetStartAndPrefix()) {
26043         this.startAndPrefix = other.startAndPrefix;
26044       }
26045       if (other.isSetColumns()) {
26046         List<byte[]> __this__columns = new ArrayList<byte[]>();
26047         for (byte[] other_element : other.columns) {
26048           __this__columns.add(other_element);
26049         }
26050         this.columns = __this__columns;
26051       }
26052     }
26053 
26054     public scannerOpenWithPrefix_args deepCopy() {
26055       return new scannerOpenWithPrefix_args(this);
26056     }
26057 
26058     @Deprecated
26059     public scannerOpenWithPrefix_args clone() {
26060       return new scannerOpenWithPrefix_args(this);
26061     }
26062 
26063     /**
26064      * name of table
26065      */
26066     public byte[] getTableName() {
26067       return this.tableName;
26068     }
26069 
26070     /**
26071      * name of table
26072      */
26073     public scannerOpenWithPrefix_args setTableName(byte[] tableName) {
26074       this.tableName = tableName;
26075       return this;
26076     }
26077 
26078     public void unsetTableName() {
26079       this.tableName = null;
26080     }
26081 
26082     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
26083     public boolean isSetTableName() {
26084       return this.tableName != null;
26085     }
26086 
26087     public void setTableNameIsSet(boolean value) {
26088       if (!value) {
26089         this.tableName = null;
26090       }
26091     }
26092 
26093     /**
26094      * the prefix (and thus start row) of the keys you want
26095      */
26096     public byte[] getStartAndPrefix() {
26097       return this.startAndPrefix;
26098     }
26099 
26100     /**
26101      * the prefix (and thus start row) of the keys you want
26102      */
26103     public scannerOpenWithPrefix_args setStartAndPrefix(byte[] startAndPrefix) {
26104       this.startAndPrefix = startAndPrefix;
26105       return this;
26106     }
26107 
26108     public void unsetStartAndPrefix() {
26109       this.startAndPrefix = null;
26110     }
26111 
26112     /** Returns true if field startAndPrefix is set (has been asigned a value) and false otherwise */
26113     public boolean isSetStartAndPrefix() {
26114       return this.startAndPrefix != null;
26115     }
26116 
26117     public void setStartAndPrefixIsSet(boolean value) {
26118       if (!value) {
26119         this.startAndPrefix = null;
26120       }
26121     }
26122 
26123     public int getColumnsSize() {
26124       return (this.columns == null) ? 0 : this.columns.size();
26125     }
26126 
26127     public java.util.Iterator<byte[]> getColumnsIterator() {
26128       return (this.columns == null) ? null : this.columns.iterator();
26129     }
26130 
26131     public void addToColumns(byte[] elem) {
26132       if (this.columns == null) {
26133         this.columns = new ArrayList<byte[]>();
26134       }
26135       this.columns.add(elem);
26136     }
26137 
26138     /**
26139      * the columns you want returned
26140      */
26141     public List<byte[]> getColumns() {
26142       return this.columns;
26143     }
26144 
26145     /**
26146      * the columns you want returned
26147      */
26148     public scannerOpenWithPrefix_args setColumns(List<byte[]> columns) {
26149       this.columns = columns;
26150       return this;
26151     }
26152 
26153     public void unsetColumns() {
26154       this.columns = null;
26155     }
26156 
26157     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
26158     public boolean isSetColumns() {
26159       return this.columns != null;
26160     }
26161 
26162     public void setColumnsIsSet(boolean value) {
26163       if (!value) {
26164         this.columns = null;
26165       }
26166     }
26167 
26168     public void setFieldValue(_Fields field, Object value) {
26169       switch (field) {
26170       case TABLE_NAME:
26171         if (value == null) {
26172           unsetTableName();
26173         } else {
26174           setTableName((byte[])value);
26175         }
26176         break;
26177 
26178       case START_AND_PREFIX:
26179         if (value == null) {
26180           unsetStartAndPrefix();
26181         } else {
26182           setStartAndPrefix((byte[])value);
26183         }
26184         break;
26185 
26186       case COLUMNS:
26187         if (value == null) {
26188           unsetColumns();
26189         } else {
26190           setColumns((List<byte[]>)value);
26191         }
26192         break;
26193 
26194       }
26195     }
26196 
26197     public void setFieldValue(int fieldID, Object value) {
26198       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26199     }
26200 
26201     public Object getFieldValue(_Fields field) {
26202       switch (field) {
26203       case TABLE_NAME:
26204         return getTableName();
26205 
26206       case START_AND_PREFIX:
26207         return getStartAndPrefix();
26208 
26209       case COLUMNS:
26210         return getColumns();
26211 
26212       }
26213       throw new IllegalStateException();
26214     }
26215 
26216     public Object getFieldValue(int fieldId) {
26217       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26218     }
26219 
26220     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
26221     public boolean isSet(_Fields field) {
26222       switch (field) {
26223       case TABLE_NAME:
26224         return isSetTableName();
26225       case START_AND_PREFIX:
26226         return isSetStartAndPrefix();
26227       case COLUMNS:
26228         return isSetColumns();
26229       }
26230       throw new IllegalStateException();
26231     }
26232 
26233     public boolean isSet(int fieldID) {
26234       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26235     }
26236 
26237     @Override
26238     public boolean equals(Object that) {
26239       if (that == null)
26240         return false;
26241       if (that instanceof scannerOpenWithPrefix_args)
26242         return this.equals((scannerOpenWithPrefix_args)that);
26243       return false;
26244     }
26245 
26246     public boolean equals(scannerOpenWithPrefix_args that) {
26247       if (that == null)
26248         return false;
26249 
26250       boolean this_present_tableName = true && this.isSetTableName();
26251       boolean that_present_tableName = true && that.isSetTableName();
26252       if (this_present_tableName || that_present_tableName) {
26253         if (!(this_present_tableName && that_present_tableName))
26254           return false;
26255         if (!java.util.Arrays.equals(this.tableName, that.tableName))
26256           return false;
26257       }
26258 
26259       boolean this_present_startAndPrefix = true && this.isSetStartAndPrefix();
26260       boolean that_present_startAndPrefix = true && that.isSetStartAndPrefix();
26261       if (this_present_startAndPrefix || that_present_startAndPrefix) {
26262         if (!(this_present_startAndPrefix && that_present_startAndPrefix))
26263           return false;
26264         if (!java.util.Arrays.equals(this.startAndPrefix, that.startAndPrefix))
26265           return false;
26266       }
26267 
26268       boolean this_present_columns = true && this.isSetColumns();
26269       boolean that_present_columns = true && that.isSetColumns();
26270       if (this_present_columns || that_present_columns) {
26271         if (!(this_present_columns && that_present_columns))
26272           return false;
26273         if (!this.columns.equals(that.columns))
26274           return false;
26275       }
26276 
26277       return true;
26278     }
26279 
26280     @Override
26281     public int hashCode() {
26282       HashCodeBuilder builder = new HashCodeBuilder();
26283 
26284       boolean present_tableName = true && (isSetTableName());
26285       builder.append(present_tableName);
26286       if (present_tableName)
26287         builder.append(tableName);
26288 
26289       boolean present_startAndPrefix = true && (isSetStartAndPrefix());
26290       builder.append(present_startAndPrefix);
26291       if (present_startAndPrefix)
26292         builder.append(startAndPrefix);
26293 
26294       boolean present_columns = true && (isSetColumns());
26295       builder.append(present_columns);
26296       if (present_columns)
26297         builder.append(columns);
26298 
26299       return builder.toHashCode();
26300     }
26301 
26302     public int compareTo(scannerOpenWithPrefix_args other) {
26303       if (!getClass().equals(other.getClass())) {
26304         return getClass().getName().compareTo(other.getClass().getName());
26305       }
26306 
26307       int lastComparison = 0;
26308       scannerOpenWithPrefix_args typedOther = (scannerOpenWithPrefix_args)other;
26309 
26310       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
26311       if (lastComparison != 0) {
26312         return lastComparison;
26313       }
26314       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
26315       if (lastComparison != 0) {
26316         return lastComparison;
26317       }
26318       lastComparison = Boolean.valueOf(isSetStartAndPrefix()).compareTo(isSetStartAndPrefix());
26319       if (lastComparison != 0) {
26320         return lastComparison;
26321       }
26322       lastComparison = TBaseHelper.compareTo(startAndPrefix, typedOther.startAndPrefix);
26323       if (lastComparison != 0) {
26324         return lastComparison;
26325       }
26326       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
26327       if (lastComparison != 0) {
26328         return lastComparison;
26329       }
26330       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
26331       if (lastComparison != 0) {
26332         return lastComparison;
26333       }
26334       return 0;
26335     }
26336 
26337     public void read(TProtocol iprot) throws TException {
26338       TField field;
26339       iprot.readStructBegin();
26340       while (true)
26341       {
26342         field = iprot.readFieldBegin();
26343         if (field.type == TType.STOP) {
26344           break;
26345         }
26346         _Fields fieldId = _Fields.findByThriftId(field.id);
26347         if (fieldId == null) {
26348           TProtocolUtil.skip(iprot, field.type);
26349         } else {
26350           switch (fieldId) {
26351             case TABLE_NAME:
26352               if (field.type == TType.STRING) {
26353                 this.tableName = iprot.readBinary();
26354               } else {
26355                 TProtocolUtil.skip(iprot, field.type);
26356               }
26357               break;
26358             case START_AND_PREFIX:
26359               if (field.type == TType.STRING) {
26360                 this.startAndPrefix = iprot.readBinary();
26361               } else {
26362                 TProtocolUtil.skip(iprot, field.type);
26363               }
26364               break;
26365             case COLUMNS:
26366               if (field.type == TType.LIST) {
26367                 {
26368                   TList _list86 = iprot.readListBegin();
26369                   this.columns = new ArrayList<byte[]>(_list86.size);
26370                   for (int _i87 = 0; _i87 < _list86.size; ++_i87)
26371                   {
26372                     byte[] _elem88;
26373                     _elem88 = iprot.readBinary();
26374                     this.columns.add(_elem88);
26375                   }
26376                   iprot.readListEnd();
26377                 }
26378               } else {
26379                 TProtocolUtil.skip(iprot, field.type);
26380               }
26381               break;
26382           }
26383           iprot.readFieldEnd();
26384         }
26385       }
26386       iprot.readStructEnd();
26387 
26388       // check for required fields of primitive type, which can't be checked in the validate method
26389       validate();
26390     }
26391 
26392     public void write(TProtocol oprot) throws TException {
26393       validate();
26394 
26395       oprot.writeStructBegin(STRUCT_DESC);
26396       if (this.tableName != null) {
26397         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
26398         oprot.writeBinary(this.tableName);
26399         oprot.writeFieldEnd();
26400       }
26401       if (this.startAndPrefix != null) {
26402         oprot.writeFieldBegin(START_AND_PREFIX_FIELD_DESC);
26403         oprot.writeBinary(this.startAndPrefix);
26404         oprot.writeFieldEnd();
26405       }
26406       if (this.columns != null) {
26407         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
26408         {
26409           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
26410           for (byte[] _iter89 : this.columns)
26411           {
26412             oprot.writeBinary(_iter89);
26413           }
26414           oprot.writeListEnd();
26415         }
26416         oprot.writeFieldEnd();
26417       }
26418       oprot.writeFieldStop();
26419       oprot.writeStructEnd();
26420     }
26421 
26422     @Override
26423     public String toString() {
26424       StringBuilder sb = new StringBuilder("scannerOpenWithPrefix_args(");
26425       boolean first = true;
26426 
26427       sb.append("tableName:");
26428       if (this.tableName == null) {
26429         sb.append("null");
26430       } else {
26431         sb.append(this.tableName);
26432       }
26433       first = false;
26434       if (!first) sb.append(", ");
26435       sb.append("startAndPrefix:");
26436       if (this.startAndPrefix == null) {
26437         sb.append("null");
26438       } else {
26439         sb.append(this.startAndPrefix);
26440       }
26441       first = false;
26442       if (!first) sb.append(", ");
26443       sb.append("columns:");
26444       if (this.columns == null) {
26445         sb.append("null");
26446       } else {
26447         sb.append(this.columns);
26448       }
26449       first = false;
26450       sb.append(")");
26451       return sb.toString();
26452     }
26453 
26454     public void validate() throws TException {
26455       // check for required fields
26456     }
26457 
26458   }
26459 
26460   public static class scannerOpenWithPrefix_result implements TBase<scannerOpenWithPrefix_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithPrefix_result>   {
26461     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithPrefix_result");
26462 
26463     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
26464     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
26465 
26466     public int success;
26467     public IOError io;
26468 
26469     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
26470     public enum _Fields implements TFieldIdEnum {
26471       SUCCESS((short)0, "success"),
26472       IO((short)1, "io");
26473 
26474       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26475       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26476 
26477       static {
26478         for (_Fields field : EnumSet.allOf(_Fields.class)) {
26479           byId.put((int)field._thriftId, field);
26480           byName.put(field.getFieldName(), field);
26481         }
26482       }
26483 
26484       /**
26485        * Find the _Fields constant that matches fieldId, or null if its not found.
26486        */
26487       public static _Fields findByThriftId(int fieldId) {
26488         return byId.get(fieldId);
26489       }
26490 
26491       /**
26492        * Find the _Fields constant that matches fieldId, throwing an exception
26493        * if it is not found.
26494        */
26495       public static _Fields findByThriftIdOrThrow(int fieldId) {
26496         _Fields fields = findByThriftId(fieldId);
26497         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
26498         return fields;
26499       }
26500 
26501       /**
26502        * Find the _Fields constant that matches name, or null if its not found.
26503        */
26504       public static _Fields findByName(String name) {
26505         return byName.get(name);
26506       }
26507 
26508       private final short _thriftId;
26509       private final String _fieldName;
26510 
26511       _Fields(short thriftId, String fieldName) {
26512         _thriftId = thriftId;
26513         _fieldName = fieldName;
26514       }
26515 
26516       public short getThriftFieldId() {
26517         return _thriftId;
26518       }
26519 
26520       public String getFieldName() {
26521         return _fieldName;
26522       }
26523     }
26524 
26525     // isset id assignments
26526     private static final int __SUCCESS_ISSET_ID = 0;
26527     private BitSet __isset_bit_vector = new BitSet(1);
26528 
26529     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26530       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
26531           new FieldValueMetaData(TType.I32)));
26532       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
26533           new FieldValueMetaData(TType.STRUCT)));
26534     }});
26535 
26536     static {
26537       FieldMetaData.addStructMetaDataMap(scannerOpenWithPrefix_result.class, metaDataMap);
26538     }
26539 
26540     public scannerOpenWithPrefix_result() {
26541     }
26542 
26543     public scannerOpenWithPrefix_result(
26544       int success,
26545       IOError io)
26546     {
26547       this();
26548       this.success = success;
26549       setSuccessIsSet(true);
26550       this.io = io;
26551     }
26552 
26553     /**
26554      * Performs a deep copy on <i>other</i>.
26555      */
26556     public scannerOpenWithPrefix_result(scannerOpenWithPrefix_result other) {
26557       __isset_bit_vector.clear();
26558       __isset_bit_vector.or(other.__isset_bit_vector);
26559       this.success = other.success;
26560       if (other.isSetIo()) {
26561         this.io = new IOError(other.io);
26562       }
26563     }
26564 
26565     public scannerOpenWithPrefix_result deepCopy() {
26566       return new scannerOpenWithPrefix_result(this);
26567     }
26568 
26569     @Deprecated
26570     public scannerOpenWithPrefix_result clone() {
26571       return new scannerOpenWithPrefix_result(this);
26572     }
26573 
26574     public int getSuccess() {
26575       return this.success;
26576     }
26577 
26578     public scannerOpenWithPrefix_result setSuccess(int success) {
26579       this.success = success;
26580       setSuccessIsSet(true);
26581       return this;
26582     }
26583 
26584     public void unsetSuccess() {
26585       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
26586     }
26587 
26588     /** Returns true if field success is set (has been asigned a value) and false otherwise */
26589     public boolean isSetSuccess() {
26590       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
26591     }
26592 
26593     public void setSuccessIsSet(boolean value) {
26594       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
26595     }
26596 
26597     public IOError getIo() {
26598       return this.io;
26599     }
26600 
26601     public scannerOpenWithPrefix_result setIo(IOError io) {
26602       this.io = io;
26603       return this;
26604     }
26605 
26606     public void unsetIo() {
26607       this.io = null;
26608     }
26609 
26610     /** Returns true if field io is set (has been asigned a value) and false otherwise */
26611     public boolean isSetIo() {
26612       return this.io != null;
26613     }
26614 
26615     public void setIoIsSet(boolean value) {
26616       if (!value) {
26617         this.io = null;
26618       }
26619     }
26620 
26621     public void setFieldValue(_Fields field, Object value) {
26622       switch (field) {
26623       case SUCCESS:
26624         if (value == null) {
26625           unsetSuccess();
26626         } else {
26627           setSuccess((Integer)value);
26628         }
26629         break;
26630 
26631       case IO:
26632         if (value == null) {
26633           unsetIo();
26634         } else {
26635           setIo((IOError)value);
26636         }
26637         break;
26638 
26639       }
26640     }
26641 
26642     public void setFieldValue(int fieldID, Object value) {
26643       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
26644     }
26645 
26646     public Object getFieldValue(_Fields field) {
26647       switch (field) {
26648       case SUCCESS:
26649         return new Integer(getSuccess());
26650 
26651       case IO:
26652         return getIo();
26653 
26654       }
26655       throw new IllegalStateException();
26656     }
26657 
26658     public Object getFieldValue(int fieldId) {
26659       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
26660     }
26661 
26662     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
26663     public boolean isSet(_Fields field) {
26664       switch (field) {
26665       case SUCCESS:
26666         return isSetSuccess();
26667       case IO:
26668         return isSetIo();
26669       }
26670       throw new IllegalStateException();
26671     }
26672 
26673     public boolean isSet(int fieldID) {
26674       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
26675     }
26676 
26677     @Override
26678     public boolean equals(Object that) {
26679       if (that == null)
26680         return false;
26681       if (that instanceof scannerOpenWithPrefix_result)
26682         return this.equals((scannerOpenWithPrefix_result)that);
26683       return false;
26684     }
26685 
26686     public boolean equals(scannerOpenWithPrefix_result that) {
26687       if (that == null)
26688         return false;
26689 
26690       boolean this_present_success = true;
26691       boolean that_present_success = true;
26692       if (this_present_success || that_present_success) {
26693         if (!(this_present_success && that_present_success))
26694           return false;
26695         if (this.success != that.success)
26696           return false;
26697       }
26698 
26699       boolean this_present_io = true && this.isSetIo();
26700       boolean that_present_io = true && that.isSetIo();
26701       if (this_present_io || that_present_io) {
26702         if (!(this_present_io && that_present_io))
26703           return false;
26704         if (!this.io.equals(that.io))
26705           return false;
26706       }
26707 
26708       return true;
26709     }
26710 
26711     @Override
26712     public int hashCode() {
26713       HashCodeBuilder builder = new HashCodeBuilder();
26714 
26715       boolean present_success = true;
26716       builder.append(present_success);
26717       if (present_success)
26718         builder.append(success);
26719 
26720       boolean present_io = true && (isSetIo());
26721       builder.append(present_io);
26722       if (present_io)
26723         builder.append(io);
26724 
26725       return builder.toHashCode();
26726     }
26727 
26728     public int compareTo(scannerOpenWithPrefix_result other) {
26729       if (!getClass().equals(other.getClass())) {
26730         return getClass().getName().compareTo(other.getClass().getName());
26731       }
26732 
26733       int lastComparison = 0;
26734       scannerOpenWithPrefix_result typedOther = (scannerOpenWithPrefix_result)other;
26735 
26736       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
26737       if (lastComparison != 0) {
26738         return lastComparison;
26739       }
26740       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
26741       if (lastComparison != 0) {
26742         return lastComparison;
26743       }
26744       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
26745       if (lastComparison != 0) {
26746         return lastComparison;
26747       }
26748       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
26749       if (lastComparison != 0) {
26750         return lastComparison;
26751       }
26752       return 0;
26753     }
26754 
26755     public void read(TProtocol iprot) throws TException {
26756       TField field;
26757       iprot.readStructBegin();
26758       while (true)
26759       {
26760         field = iprot.readFieldBegin();
26761         if (field.type == TType.STOP) {
26762           break;
26763         }
26764         _Fields fieldId = _Fields.findByThriftId(field.id);
26765         if (fieldId == null) {
26766           TProtocolUtil.skip(iprot, field.type);
26767         } else {
26768           switch (fieldId) {
26769             case SUCCESS:
26770               if (field.type == TType.I32) {
26771                 this.success = iprot.readI32();
26772                 setSuccessIsSet(true);
26773               } else {
26774                 TProtocolUtil.skip(iprot, field.type);
26775               }
26776               break;
26777             case IO:
26778               if (field.type == TType.STRUCT) {
26779                 this.io = new IOError();
26780                 this.io.read(iprot);
26781               } else {
26782                 TProtocolUtil.skip(iprot, field.type);
26783               }
26784               break;
26785           }
26786           iprot.readFieldEnd();
26787         }
26788       }
26789       iprot.readStructEnd();
26790 
26791       // check for required fields of primitive type, which can't be checked in the validate method
26792       validate();
26793     }
26794 
26795     public void write(TProtocol oprot) throws TException {
26796       oprot.writeStructBegin(STRUCT_DESC);
26797 
26798       if (this.isSetSuccess()) {
26799         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
26800         oprot.writeI32(this.success);
26801         oprot.writeFieldEnd();
26802       } else if (this.isSetIo()) {
26803         oprot.writeFieldBegin(IO_FIELD_DESC);
26804         this.io.write(oprot);
26805         oprot.writeFieldEnd();
26806       }
26807       oprot.writeFieldStop();
26808       oprot.writeStructEnd();
26809     }
26810 
26811     @Override
26812     public String toString() {
26813       StringBuilder sb = new StringBuilder("scannerOpenWithPrefix_result(");
26814       boolean first = true;
26815 
26816       sb.append("success:");
26817       sb.append(this.success);
26818       first = false;
26819       if (!first) sb.append(", ");
26820       sb.append("io:");
26821       if (this.io == null) {
26822         sb.append("null");
26823       } else {
26824         sb.append(this.io);
26825       }
26826       first = false;
26827       sb.append(")");
26828       return sb.toString();
26829     }
26830 
26831     public void validate() throws TException {
26832       // check for required fields
26833     }
26834 
26835   }
26836 
26837   public static class scannerOpenTs_args implements TBase<scannerOpenTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_args>   {
26838     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_args");
26839 
26840     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
26841     private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
26842     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)3);
26843     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)4);
26844 
26845     /**
26846      * name of table
26847      */
26848     public byte[] tableName;
26849     /**
26850      * Starting row in table to scan.
26851      * Send "" (empty string) to start at the first row.
26852      */
26853     public byte[] startRow;
26854     /**
26855      * columns to scan. If column name is a column family, all
26856      * columns of the specified column family are returned. It's also possible
26857      * to pass a regex in the column qualifier.
26858      */
26859     public List<byte[]> columns;
26860     /**
26861      * timestamp
26862      */
26863     public long timestamp;
26864 
26865     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
26866     public enum _Fields implements TFieldIdEnum {
26867       /**
26868        * name of table
26869        */
26870       TABLE_NAME((short)1, "tableName"),
26871       /**
26872        * Starting row in table to scan.
26873        * Send "" (empty string) to start at the first row.
26874        */
26875       START_ROW((short)2, "startRow"),
26876       /**
26877        * columns to scan. If column name is a column family, all
26878        * columns of the specified column family are returned. It's also possible
26879        * to pass a regex in the column qualifier.
26880        */
26881       COLUMNS((short)3, "columns"),
26882       /**
26883        * timestamp
26884        */
26885       TIMESTAMP((short)4, "timestamp");
26886 
26887       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
26888       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
26889 
26890       static {
26891         for (_Fields field : EnumSet.allOf(_Fields.class)) {
26892           byId.put((int)field._thriftId, field);
26893           byName.put(field.getFieldName(), field);
26894         }
26895       }
26896 
26897       /**
26898        * Find the _Fields constant that matches fieldId, or null if its not found.
26899        */
26900       public static _Fields findByThriftId(int fieldId) {
26901         return byId.get(fieldId);
26902       }
26903 
26904       /**
26905        * Find the _Fields constant that matches fieldId, throwing an exception
26906        * if it is not found.
26907        */
26908       public static _Fields findByThriftIdOrThrow(int fieldId) {
26909         _Fields fields = findByThriftId(fieldId);
26910         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
26911         return fields;
26912       }
26913 
26914       /**
26915        * Find the _Fields constant that matches name, or null if its not found.
26916        */
26917       public static _Fields findByName(String name) {
26918         return byName.get(name);
26919       }
26920 
26921       private final short _thriftId;
26922       private final String _fieldName;
26923 
26924       _Fields(short thriftId, String fieldName) {
26925         _thriftId = thriftId;
26926         _fieldName = fieldName;
26927       }
26928 
26929       public short getThriftFieldId() {
26930         return _thriftId;
26931       }
26932 
26933       public String getFieldName() {
26934         return _fieldName;
26935       }
26936     }
26937 
26938     // isset id assignments
26939     private static final int __TIMESTAMP_ISSET_ID = 0;
26940     private BitSet __isset_bit_vector = new BitSet(1);
26941 
26942     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
26943       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
26944           new FieldValueMetaData(TType.STRING)));
26945       put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
26946           new FieldValueMetaData(TType.STRING)));
26947       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
26948           new ListMetaData(TType.LIST,
26949               new FieldValueMetaData(TType.STRING))));
26950       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
26951           new FieldValueMetaData(TType.I64)));
26952     }});
26953 
26954     static {
26955       FieldMetaData.addStructMetaDataMap(scannerOpenTs_args.class, metaDataMap);
26956     }
26957 
26958     public scannerOpenTs_args() {
26959     }
26960 
26961     public scannerOpenTs_args(
26962       byte[] tableName,
26963       byte[] startRow,
26964       List<byte[]> columns,
26965       long timestamp)
26966     {
26967       this();
26968       this.tableName = tableName;
26969       this.startRow = startRow;
26970       this.columns = columns;
26971       this.timestamp = timestamp;
26972       setTimestampIsSet(true);
26973     }
26974 
26975     /**
26976      * Performs a deep copy on <i>other</i>.
26977      */
26978     public scannerOpenTs_args(scannerOpenTs_args other) {
26979       __isset_bit_vector.clear();
26980       __isset_bit_vector.or(other.__isset_bit_vector);
26981       if (other.isSetTableName()) {
26982         this.tableName = other.tableName;
26983       }
26984       if (other.isSetStartRow()) {
26985         this.startRow = other.startRow;
26986       }
26987       if (other.isSetColumns()) {
26988         List<byte[]> __this__columns = new ArrayList<byte[]>();
26989         for (byte[] other_element : other.columns) {
26990           __this__columns.add(other_element);
26991         }
26992         this.columns = __this__columns;
26993       }
26994       this.timestamp = other.timestamp;
26995     }
26996 
26997     public scannerOpenTs_args deepCopy() {
26998       return new scannerOpenTs_args(this);
26999     }
27000 
27001     @Deprecated
27002     public scannerOpenTs_args clone() {
27003       return new scannerOpenTs_args(this);
27004     }
27005 
27006     /**
27007      * name of table
27008      */
27009     public byte[] getTableName() {
27010       return this.tableName;
27011     }
27012 
27013     /**
27014      * name of table
27015      */
27016     public scannerOpenTs_args setTableName(byte[] tableName) {
27017       this.tableName = tableName;
27018       return this;
27019     }
27020 
27021     public void unsetTableName() {
27022       this.tableName = null;
27023     }
27024 
27025     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
27026     public boolean isSetTableName() {
27027       return this.tableName != null;
27028     }
27029 
27030     public void setTableNameIsSet(boolean value) {
27031       if (!value) {
27032         this.tableName = null;
27033       }
27034     }
27035 
27036     /**
27037      * Starting row in table to scan.
27038      * Send "" (empty string) to start at the first row.
27039      */
27040     public byte[] getStartRow() {
27041       return this.startRow;
27042     }
27043 
27044     /**
27045      * Starting row in table to scan.
27046      * Send "" (empty string) to start at the first row.
27047      */
27048     public scannerOpenTs_args setStartRow(byte[] startRow) {
27049       this.startRow = startRow;
27050       return this;
27051     }
27052 
27053     public void unsetStartRow() {
27054       this.startRow = null;
27055     }
27056 
27057     /** Returns true if field startRow is set (has been asigned a value) and false otherwise */
27058     public boolean isSetStartRow() {
27059       return this.startRow != null;
27060     }
27061 
27062     public void setStartRowIsSet(boolean value) {
27063       if (!value) {
27064         this.startRow = null;
27065       }
27066     }
27067 
27068     public int getColumnsSize() {
27069       return (this.columns == null) ? 0 : this.columns.size();
27070     }
27071 
27072     public java.util.Iterator<byte[]> getColumnsIterator() {
27073       return (this.columns == null) ? null : this.columns.iterator();
27074     }
27075 
27076     public void addToColumns(byte[] elem) {
27077       if (this.columns == null) {
27078         this.columns = new ArrayList<byte[]>();
27079       }
27080       this.columns.add(elem);
27081     }
27082 
27083     /**
27084      * columns to scan. If column name is a column family, all
27085      * columns of the specified column family are returned. It's also possible
27086      * to pass a regex in the column qualifier.
27087      */
27088     public List<byte[]> getColumns() {
27089       return this.columns;
27090     }
27091 
27092     /**
27093      * columns to scan. If column name is a column family, all
27094      * columns of the specified column family are returned. It's also possible
27095      * to pass a regex in the column qualifier.
27096      */
27097     public scannerOpenTs_args setColumns(List<byte[]> columns) {
27098       this.columns = columns;
27099       return this;
27100     }
27101 
27102     public void unsetColumns() {
27103       this.columns = null;
27104     }
27105 
27106     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
27107     public boolean isSetColumns() {
27108       return this.columns != null;
27109     }
27110 
27111     public void setColumnsIsSet(boolean value) {
27112       if (!value) {
27113         this.columns = null;
27114       }
27115     }
27116 
27117     /**
27118      * timestamp
27119      */
27120     public long getTimestamp() {
27121       return this.timestamp;
27122     }
27123 
27124     /**
27125      * timestamp
27126      */
27127     public scannerOpenTs_args setTimestamp(long timestamp) {
27128       this.timestamp = timestamp;
27129       setTimestampIsSet(true);
27130       return this;
27131     }
27132 
27133     public void unsetTimestamp() {
27134       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
27135     }
27136 
27137     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
27138     public boolean isSetTimestamp() {
27139       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
27140     }
27141 
27142     public void setTimestampIsSet(boolean value) {
27143       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
27144     }
27145 
27146     public void setFieldValue(_Fields field, Object value) {
27147       switch (field) {
27148       case TABLE_NAME:
27149         if (value == null) {
27150           unsetTableName();
27151         } else {
27152           setTableName((byte[])value);
27153         }
27154         break;
27155 
27156       case START_ROW:
27157         if (value == null) {
27158           unsetStartRow();
27159         } else {
27160           setStartRow((byte[])value);
27161         }
27162         break;
27163 
27164       case COLUMNS:
27165         if (value == null) {
27166           unsetColumns();
27167         } else {
27168           setColumns((List<byte[]>)value);
27169         }
27170         break;
27171 
27172       case TIMESTAMP:
27173         if (value == null) {
27174           unsetTimestamp();
27175         } else {
27176           setTimestamp((Long)value);
27177         }
27178         break;
27179 
27180       }
27181     }
27182 
27183     public void setFieldValue(int fieldID, Object value) {
27184       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27185     }
27186 
27187     public Object getFieldValue(_Fields field) {
27188       switch (field) {
27189       case TABLE_NAME:
27190         return getTableName();
27191 
27192       case START_ROW:
27193         return getStartRow();
27194 
27195       case COLUMNS:
27196         return getColumns();
27197 
27198       case TIMESTAMP:
27199         return new Long(getTimestamp());
27200 
27201       }
27202       throw new IllegalStateException();
27203     }
27204 
27205     public Object getFieldValue(int fieldId) {
27206       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27207     }
27208 
27209     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
27210     public boolean isSet(_Fields field) {
27211       switch (field) {
27212       case TABLE_NAME:
27213         return isSetTableName();
27214       case START_ROW:
27215         return isSetStartRow();
27216       case COLUMNS:
27217         return isSetColumns();
27218       case TIMESTAMP:
27219         return isSetTimestamp();
27220       }
27221       throw new IllegalStateException();
27222     }
27223 
27224     public boolean isSet(int fieldID) {
27225       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27226     }
27227 
27228     @Override
27229     public boolean equals(Object that) {
27230       if (that == null)
27231         return false;
27232       if (that instanceof scannerOpenTs_args)
27233         return this.equals((scannerOpenTs_args)that);
27234       return false;
27235     }
27236 
27237     public boolean equals(scannerOpenTs_args that) {
27238       if (that == null)
27239         return false;
27240 
27241       boolean this_present_tableName = true && this.isSetTableName();
27242       boolean that_present_tableName = true && that.isSetTableName();
27243       if (this_present_tableName || that_present_tableName) {
27244         if (!(this_present_tableName && that_present_tableName))
27245           return false;
27246         if (!java.util.Arrays.equals(this.tableName, that.tableName))
27247           return false;
27248       }
27249 
27250       boolean this_present_startRow = true && this.isSetStartRow();
27251       boolean that_present_startRow = true && that.isSetStartRow();
27252       if (this_present_startRow || that_present_startRow) {
27253         if (!(this_present_startRow && that_present_startRow))
27254           return false;
27255         if (!java.util.Arrays.equals(this.startRow, that.startRow))
27256           return false;
27257       }
27258 
27259       boolean this_present_columns = true && this.isSetColumns();
27260       boolean that_present_columns = true && that.isSetColumns();
27261       if (this_present_columns || that_present_columns) {
27262         if (!(this_present_columns && that_present_columns))
27263           return false;
27264         if (!this.columns.equals(that.columns))
27265           return false;
27266       }
27267 
27268       boolean this_present_timestamp = true;
27269       boolean that_present_timestamp = true;
27270       if (this_present_timestamp || that_present_timestamp) {
27271         if (!(this_present_timestamp && that_present_timestamp))
27272           return false;
27273         if (this.timestamp != that.timestamp)
27274           return false;
27275       }
27276 
27277       return true;
27278     }
27279 
27280     @Override
27281     public int hashCode() {
27282       HashCodeBuilder builder = new HashCodeBuilder();
27283 
27284       boolean present_tableName = true && (isSetTableName());
27285       builder.append(present_tableName);
27286       if (present_tableName)
27287         builder.append(tableName);
27288 
27289       boolean present_startRow = true && (isSetStartRow());
27290       builder.append(present_startRow);
27291       if (present_startRow)
27292         builder.append(startRow);
27293 
27294       boolean present_columns = true && (isSetColumns());
27295       builder.append(present_columns);
27296       if (present_columns)
27297         builder.append(columns);
27298 
27299       boolean present_timestamp = true;
27300       builder.append(present_timestamp);
27301       if (present_timestamp)
27302         builder.append(timestamp);
27303 
27304       return builder.toHashCode();
27305     }
27306 
27307     public int compareTo(scannerOpenTs_args other) {
27308       if (!getClass().equals(other.getClass())) {
27309         return getClass().getName().compareTo(other.getClass().getName());
27310       }
27311 
27312       int lastComparison = 0;
27313       scannerOpenTs_args typedOther = (scannerOpenTs_args)other;
27314 
27315       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
27316       if (lastComparison != 0) {
27317         return lastComparison;
27318       }
27319       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
27320       if (lastComparison != 0) {
27321         return lastComparison;
27322       }
27323       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
27324       if (lastComparison != 0) {
27325         return lastComparison;
27326       }
27327       lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
27328       if (lastComparison != 0) {
27329         return lastComparison;
27330       }
27331       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
27332       if (lastComparison != 0) {
27333         return lastComparison;
27334       }
27335       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
27336       if (lastComparison != 0) {
27337         return lastComparison;
27338       }
27339       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
27340       if (lastComparison != 0) {
27341         return lastComparison;
27342       }
27343       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
27344       if (lastComparison != 0) {
27345         return lastComparison;
27346       }
27347       return 0;
27348     }
27349 
27350     public void read(TProtocol iprot) throws TException {
27351       TField field;
27352       iprot.readStructBegin();
27353       while (true)
27354       {
27355         field = iprot.readFieldBegin();
27356         if (field.type == TType.STOP) {
27357           break;
27358         }
27359         _Fields fieldId = _Fields.findByThriftId(field.id);
27360         if (fieldId == null) {
27361           TProtocolUtil.skip(iprot, field.type);
27362         } else {
27363           switch (fieldId) {
27364             case TABLE_NAME:
27365               if (field.type == TType.STRING) {
27366                 this.tableName = iprot.readBinary();
27367               } else {
27368                 TProtocolUtil.skip(iprot, field.type);
27369               }
27370               break;
27371             case START_ROW:
27372               if (field.type == TType.STRING) {
27373                 this.startRow = iprot.readBinary();
27374               } else {
27375                 TProtocolUtil.skip(iprot, field.type);
27376               }
27377               break;
27378             case COLUMNS:
27379               if (field.type == TType.LIST) {
27380                 {
27381                   TList _list90 = iprot.readListBegin();
27382                   this.columns = new ArrayList<byte[]>(_list90.size);
27383                   for (int _i91 = 0; _i91 < _list90.size; ++_i91)
27384                   {
27385                     byte[] _elem92;
27386                     _elem92 = iprot.readBinary();
27387                     this.columns.add(_elem92);
27388                   }
27389                   iprot.readListEnd();
27390                 }
27391               } else {
27392                 TProtocolUtil.skip(iprot, field.type);
27393               }
27394               break;
27395             case TIMESTAMP:
27396               if (field.type == TType.I64) {
27397                 this.timestamp = iprot.readI64();
27398                 setTimestampIsSet(true);
27399               } else {
27400                 TProtocolUtil.skip(iprot, field.type);
27401               }
27402               break;
27403           }
27404           iprot.readFieldEnd();
27405         }
27406       }
27407       iprot.readStructEnd();
27408 
27409       // check for required fields of primitive type, which can't be checked in the validate method
27410       validate();
27411     }
27412 
27413     public void write(TProtocol oprot) throws TException {
27414       validate();
27415 
27416       oprot.writeStructBegin(STRUCT_DESC);
27417       if (this.tableName != null) {
27418         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
27419         oprot.writeBinary(this.tableName);
27420         oprot.writeFieldEnd();
27421       }
27422       if (this.startRow != null) {
27423         oprot.writeFieldBegin(START_ROW_FIELD_DESC);
27424         oprot.writeBinary(this.startRow);
27425         oprot.writeFieldEnd();
27426       }
27427       if (this.columns != null) {
27428         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
27429         {
27430           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
27431           for (byte[] _iter93 : this.columns)
27432           {
27433             oprot.writeBinary(_iter93);
27434           }
27435           oprot.writeListEnd();
27436         }
27437         oprot.writeFieldEnd();
27438       }
27439       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
27440       oprot.writeI64(this.timestamp);
27441       oprot.writeFieldEnd();
27442       oprot.writeFieldStop();
27443       oprot.writeStructEnd();
27444     }
27445 
27446     @Override
27447     public String toString() {
27448       StringBuilder sb = new StringBuilder("scannerOpenTs_args(");
27449       boolean first = true;
27450 
27451       sb.append("tableName:");
27452       if (this.tableName == null) {
27453         sb.append("null");
27454       } else {
27455         sb.append(this.tableName);
27456       }
27457       first = false;
27458       if (!first) sb.append(", ");
27459       sb.append("startRow:");
27460       if (this.startRow == null) {
27461         sb.append("null");
27462       } else {
27463         sb.append(this.startRow);
27464       }
27465       first = false;
27466       if (!first) sb.append(", ");
27467       sb.append("columns:");
27468       if (this.columns == null) {
27469         sb.append("null");
27470       } else {
27471         sb.append(this.columns);
27472       }
27473       first = false;
27474       if (!first) sb.append(", ");
27475       sb.append("timestamp:");
27476       sb.append(this.timestamp);
27477       first = false;
27478       sb.append(")");
27479       return sb.toString();
27480     }
27481 
27482     public void validate() throws TException {
27483       // check for required fields
27484     }
27485 
27486   }
27487 
27488   public static class scannerOpenTs_result implements TBase<scannerOpenTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenTs_result>   {
27489     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenTs_result");
27490 
27491     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
27492     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
27493 
27494     public int success;
27495     public IOError io;
27496 
27497     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
27498     public enum _Fields implements TFieldIdEnum {
27499       SUCCESS((short)0, "success"),
27500       IO((short)1, "io");
27501 
27502       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
27503       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
27504 
27505       static {
27506         for (_Fields field : EnumSet.allOf(_Fields.class)) {
27507           byId.put((int)field._thriftId, field);
27508           byName.put(field.getFieldName(), field);
27509         }
27510       }
27511 
27512       /**
27513        * Find the _Fields constant that matches fieldId, or null if its not found.
27514        */
27515       public static _Fields findByThriftId(int fieldId) {
27516         return byId.get(fieldId);
27517       }
27518 
27519       /**
27520        * Find the _Fields constant that matches fieldId, throwing an exception
27521        * if it is not found.
27522        */
27523       public static _Fields findByThriftIdOrThrow(int fieldId) {
27524         _Fields fields = findByThriftId(fieldId);
27525         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27526         return fields;
27527       }
27528 
27529       /**
27530        * Find the _Fields constant that matches name, or null if its not found.
27531        */
27532       public static _Fields findByName(String name) {
27533         return byName.get(name);
27534       }
27535 
27536       private final short _thriftId;
27537       private final String _fieldName;
27538 
27539       _Fields(short thriftId, String fieldName) {
27540         _thriftId = thriftId;
27541         _fieldName = fieldName;
27542       }
27543 
27544       public short getThriftFieldId() {
27545         return _thriftId;
27546       }
27547 
27548       public String getFieldName() {
27549         return _fieldName;
27550       }
27551     }
27552 
27553     // isset id assignments
27554     private static final int __SUCCESS_ISSET_ID = 0;
27555     private BitSet __isset_bit_vector = new BitSet(1);
27556 
27557     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27558       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
27559           new FieldValueMetaData(TType.I32)));
27560       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
27561           new FieldValueMetaData(TType.STRUCT)));
27562     }});
27563 
27564     static {
27565       FieldMetaData.addStructMetaDataMap(scannerOpenTs_result.class, metaDataMap);
27566     }
27567 
27568     public scannerOpenTs_result() {
27569     }
27570 
27571     public scannerOpenTs_result(
27572       int success,
27573       IOError io)
27574     {
27575       this();
27576       this.success = success;
27577       setSuccessIsSet(true);
27578       this.io = io;
27579     }
27580 
27581     /**
27582      * Performs a deep copy on <i>other</i>.
27583      */
27584     public scannerOpenTs_result(scannerOpenTs_result other) {
27585       __isset_bit_vector.clear();
27586       __isset_bit_vector.or(other.__isset_bit_vector);
27587       this.success = other.success;
27588       if (other.isSetIo()) {
27589         this.io = new IOError(other.io);
27590       }
27591     }
27592 
27593     public scannerOpenTs_result deepCopy() {
27594       return new scannerOpenTs_result(this);
27595     }
27596 
27597     @Deprecated
27598     public scannerOpenTs_result clone() {
27599       return new scannerOpenTs_result(this);
27600     }
27601 
27602     public int getSuccess() {
27603       return this.success;
27604     }
27605 
27606     public scannerOpenTs_result setSuccess(int success) {
27607       this.success = success;
27608       setSuccessIsSet(true);
27609       return this;
27610     }
27611 
27612     public void unsetSuccess() {
27613       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
27614     }
27615 
27616     /** Returns true if field success is set (has been asigned a value) and false otherwise */
27617     public boolean isSetSuccess() {
27618       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
27619     }
27620 
27621     public void setSuccessIsSet(boolean value) {
27622       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
27623     }
27624 
27625     public IOError getIo() {
27626       return this.io;
27627     }
27628 
27629     public scannerOpenTs_result setIo(IOError io) {
27630       this.io = io;
27631       return this;
27632     }
27633 
27634     public void unsetIo() {
27635       this.io = null;
27636     }
27637 
27638     /** Returns true if field io is set (has been asigned a value) and false otherwise */
27639     public boolean isSetIo() {
27640       return this.io != null;
27641     }
27642 
27643     public void setIoIsSet(boolean value) {
27644       if (!value) {
27645         this.io = null;
27646       }
27647     }
27648 
27649     public void setFieldValue(_Fields field, Object value) {
27650       switch (field) {
27651       case SUCCESS:
27652         if (value == null) {
27653           unsetSuccess();
27654         } else {
27655           setSuccess((Integer)value);
27656         }
27657         break;
27658 
27659       case IO:
27660         if (value == null) {
27661           unsetIo();
27662         } else {
27663           setIo((IOError)value);
27664         }
27665         break;
27666 
27667       }
27668     }
27669 
27670     public void setFieldValue(int fieldID, Object value) {
27671       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
27672     }
27673 
27674     public Object getFieldValue(_Fields field) {
27675       switch (field) {
27676       case SUCCESS:
27677         return new Integer(getSuccess());
27678 
27679       case IO:
27680         return getIo();
27681 
27682       }
27683       throw new IllegalStateException();
27684     }
27685 
27686     public Object getFieldValue(int fieldId) {
27687       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
27688     }
27689 
27690     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
27691     public boolean isSet(_Fields field) {
27692       switch (field) {
27693       case SUCCESS:
27694         return isSetSuccess();
27695       case IO:
27696         return isSetIo();
27697       }
27698       throw new IllegalStateException();
27699     }
27700 
27701     public boolean isSet(int fieldID) {
27702       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
27703     }
27704 
27705     @Override
27706     public boolean equals(Object that) {
27707       if (that == null)
27708         return false;
27709       if (that instanceof scannerOpenTs_result)
27710         return this.equals((scannerOpenTs_result)that);
27711       return false;
27712     }
27713 
27714     public boolean equals(scannerOpenTs_result that) {
27715       if (that == null)
27716         return false;
27717 
27718       boolean this_present_success = true;
27719       boolean that_present_success = true;
27720       if (this_present_success || that_present_success) {
27721         if (!(this_present_success && that_present_success))
27722           return false;
27723         if (this.success != that.success)
27724           return false;
27725       }
27726 
27727       boolean this_present_io = true && this.isSetIo();
27728       boolean that_present_io = true && that.isSetIo();
27729       if (this_present_io || that_present_io) {
27730         if (!(this_present_io && that_present_io))
27731           return false;
27732         if (!this.io.equals(that.io))
27733           return false;
27734       }
27735 
27736       return true;
27737     }
27738 
27739     @Override
27740     public int hashCode() {
27741       HashCodeBuilder builder = new HashCodeBuilder();
27742 
27743       boolean present_success = true;
27744       builder.append(present_success);
27745       if (present_success)
27746         builder.append(success);
27747 
27748       boolean present_io = true && (isSetIo());
27749       builder.append(present_io);
27750       if (present_io)
27751         builder.append(io);
27752 
27753       return builder.toHashCode();
27754     }
27755 
27756     public int compareTo(scannerOpenTs_result other) {
27757       if (!getClass().equals(other.getClass())) {
27758         return getClass().getName().compareTo(other.getClass().getName());
27759       }
27760 
27761       int lastComparison = 0;
27762       scannerOpenTs_result typedOther = (scannerOpenTs_result)other;
27763 
27764       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
27765       if (lastComparison != 0) {
27766         return lastComparison;
27767       }
27768       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
27769       if (lastComparison != 0) {
27770         return lastComparison;
27771       }
27772       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
27773       if (lastComparison != 0) {
27774         return lastComparison;
27775       }
27776       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
27777       if (lastComparison != 0) {
27778         return lastComparison;
27779       }
27780       return 0;
27781     }
27782 
27783     public void read(TProtocol iprot) throws TException {
27784       TField field;
27785       iprot.readStructBegin();
27786       while (true)
27787       {
27788         field = iprot.readFieldBegin();
27789         if (field.type == TType.STOP) {
27790           break;
27791         }
27792         _Fields fieldId = _Fields.findByThriftId(field.id);
27793         if (fieldId == null) {
27794           TProtocolUtil.skip(iprot, field.type);
27795         } else {
27796           switch (fieldId) {
27797             case SUCCESS:
27798               if (field.type == TType.I32) {
27799                 this.success = iprot.readI32();
27800                 setSuccessIsSet(true);
27801               } else {
27802                 TProtocolUtil.skip(iprot, field.type);
27803               }
27804               break;
27805             case IO:
27806               if (field.type == TType.STRUCT) {
27807                 this.io = new IOError();
27808                 this.io.read(iprot);
27809               } else {
27810                 TProtocolUtil.skip(iprot, field.type);
27811               }
27812               break;
27813           }
27814           iprot.readFieldEnd();
27815         }
27816       }
27817       iprot.readStructEnd();
27818 
27819       // check for required fields of primitive type, which can't be checked in the validate method
27820       validate();
27821     }
27822 
27823     public void write(TProtocol oprot) throws TException {
27824       oprot.writeStructBegin(STRUCT_DESC);
27825 
27826       if (this.isSetSuccess()) {
27827         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27828         oprot.writeI32(this.success);
27829         oprot.writeFieldEnd();
27830       } else if (this.isSetIo()) {
27831         oprot.writeFieldBegin(IO_FIELD_DESC);
27832         this.io.write(oprot);
27833         oprot.writeFieldEnd();
27834       }
27835       oprot.writeFieldStop();
27836       oprot.writeStructEnd();
27837     }
27838 
27839     @Override
27840     public String toString() {
27841       StringBuilder sb = new StringBuilder("scannerOpenTs_result(");
27842       boolean first = true;
27843 
27844       sb.append("success:");
27845       sb.append(this.success);
27846       first = false;
27847       if (!first) sb.append(", ");
27848       sb.append("io:");
27849       if (this.io == null) {
27850         sb.append("null");
27851       } else {
27852         sb.append(this.io);
27853       }
27854       first = false;
27855       sb.append(")");
27856       return sb.toString();
27857     }
27858 
27859     public void validate() throws TException {
27860       // check for required fields
27861     }
27862 
27863   }
27864 
27865   public static class scannerOpenWithStopTs_args implements TBase<scannerOpenWithStopTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_args>   {
27866     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_args");
27867 
27868     private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
27869     private static final TField START_ROW_FIELD_DESC = new TField("startRow", TType.STRING, (short)2);
27870     private static final TField STOP_ROW_FIELD_DESC = new TField("stopRow", TType.STRING, (short)3);
27871     private static final TField COLUMNS_FIELD_DESC = new TField("columns", TType.LIST, (short)4);
27872     private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)5);
27873 
27874     /**
27875      * name of table
27876      */
27877     public byte[] tableName;
27878     /**
27879      * Starting row in table to scan.
27880      * Send "" (empty string) to start at the first row.
27881      */
27882     public byte[] startRow;
27883     /**
27884      * row to stop scanning on. This row is *not* included in the
27885      * scanner's results
27886      */
27887     public byte[] stopRow;
27888     /**
27889      * columns to scan. If column name is a column family, all
27890      * columns of the specified column family are returned. It's also possible
27891      * to pass a regex in the column qualifier.
27892      */
27893     public List<byte[]> columns;
27894     /**
27895      * timestamp
27896      */
27897     public long timestamp;
27898 
27899     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
27900     public enum _Fields implements TFieldIdEnum {
27901       /**
27902        * name of table
27903        */
27904       TABLE_NAME((short)1, "tableName"),
27905       /**
27906        * Starting row in table to scan.
27907        * Send "" (empty string) to start at the first row.
27908        */
27909       START_ROW((short)2, "startRow"),
27910       /**
27911        * row to stop scanning on. This row is *not* included in the
27912        * scanner's results
27913        */
27914       STOP_ROW((short)3, "stopRow"),
27915       /**
27916        * columns to scan. If column name is a column family, all
27917        * columns of the specified column family are returned. It's also possible
27918        * to pass a regex in the column qualifier.
27919        */
27920       COLUMNS((short)4, "columns"),
27921       /**
27922        * timestamp
27923        */
27924       TIMESTAMP((short)5, "timestamp");
27925 
27926       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
27927       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
27928 
27929       static {
27930         for (_Fields field : EnumSet.allOf(_Fields.class)) {
27931           byId.put((int)field._thriftId, field);
27932           byName.put(field.getFieldName(), field);
27933         }
27934       }
27935 
27936       /**
27937        * Find the _Fields constant that matches fieldId, or null if its not found.
27938        */
27939       public static _Fields findByThriftId(int fieldId) {
27940         return byId.get(fieldId);
27941       }
27942 
27943       /**
27944        * Find the _Fields constant that matches fieldId, throwing an exception
27945        * if it is not found.
27946        */
27947       public static _Fields findByThriftIdOrThrow(int fieldId) {
27948         _Fields fields = findByThriftId(fieldId);
27949         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
27950         return fields;
27951       }
27952 
27953       /**
27954        * Find the _Fields constant that matches name, or null if its not found.
27955        */
27956       public static _Fields findByName(String name) {
27957         return byName.get(name);
27958       }
27959 
27960       private final short _thriftId;
27961       private final String _fieldName;
27962 
27963       _Fields(short thriftId, String fieldName) {
27964         _thriftId = thriftId;
27965         _fieldName = fieldName;
27966       }
27967 
27968       public short getThriftFieldId() {
27969         return _thriftId;
27970       }
27971 
27972       public String getFieldName() {
27973         return _fieldName;
27974       }
27975     }
27976 
27977     // isset id assignments
27978     private static final int __TIMESTAMP_ISSET_ID = 0;
27979     private BitSet __isset_bit_vector = new BitSet(1);
27980 
27981     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27982       put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
27983           new FieldValueMetaData(TType.STRING)));
27984       put(_Fields.START_ROW, new FieldMetaData("startRow", TFieldRequirementType.DEFAULT,
27985           new FieldValueMetaData(TType.STRING)));
27986       put(_Fields.STOP_ROW, new FieldMetaData("stopRow", TFieldRequirementType.DEFAULT,
27987           new FieldValueMetaData(TType.STRING)));
27988       put(_Fields.COLUMNS, new FieldMetaData("columns", TFieldRequirementType.DEFAULT,
27989           new ListMetaData(TType.LIST,
27990               new FieldValueMetaData(TType.STRING))));
27991       put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
27992           new FieldValueMetaData(TType.I64)));
27993     }});
27994 
27995     static {
27996       FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_args.class, metaDataMap);
27997     }
27998 
27999     public scannerOpenWithStopTs_args() {
28000     }
28001 
28002     public scannerOpenWithStopTs_args(
28003       byte[] tableName,
28004       byte[] startRow,
28005       byte[] stopRow,
28006       List<byte[]> columns,
28007       long timestamp)
28008     {
28009       this();
28010       this.tableName = tableName;
28011       this.startRow = startRow;
28012       this.stopRow = stopRow;
28013       this.columns = columns;
28014       this.timestamp = timestamp;
28015       setTimestampIsSet(true);
28016     }
28017 
28018     /**
28019      * Performs a deep copy on <i>other</i>.
28020      */
28021     public scannerOpenWithStopTs_args(scannerOpenWithStopTs_args other) {
28022       __isset_bit_vector.clear();
28023       __isset_bit_vector.or(other.__isset_bit_vector);
28024       if (other.isSetTableName()) {
28025         this.tableName = other.tableName;
28026       }
28027       if (other.isSetStartRow()) {
28028         this.startRow = other.startRow;
28029       }
28030       if (other.isSetStopRow()) {
28031         this.stopRow = other.stopRow;
28032       }
28033       if (other.isSetColumns()) {
28034         List<byte[]> __this__columns = new ArrayList<byte[]>();
28035         for (byte[] other_element : other.columns) {
28036           __this__columns.add(other_element);
28037         }
28038         this.columns = __this__columns;
28039       }
28040       this.timestamp = other.timestamp;
28041     }
28042 
28043     public scannerOpenWithStopTs_args deepCopy() {
28044       return new scannerOpenWithStopTs_args(this);
28045     }
28046 
28047     @Deprecated
28048     public scannerOpenWithStopTs_args clone() {
28049       return new scannerOpenWithStopTs_args(this);
28050     }
28051 
28052     /**
28053      * name of table
28054      */
28055     public byte[] getTableName() {
28056       return this.tableName;
28057     }
28058 
28059     /**
28060      * name of table
28061      */
28062     public scannerOpenWithStopTs_args setTableName(byte[] tableName) {
28063       this.tableName = tableName;
28064       return this;
28065     }
28066 
28067     public void unsetTableName() {
28068       this.tableName = null;
28069     }
28070 
28071     /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
28072     public boolean isSetTableName() {
28073       return this.tableName != null;
28074     }
28075 
28076     public void setTableNameIsSet(boolean value) {
28077       if (!value) {
28078         this.tableName = null;
28079       }
28080     }
28081 
28082     /**
28083      * Starting row in table to scan.
28084      * Send "" (empty string) to start at the first row.
28085      */
28086     public byte[] getStartRow() {
28087       return this.startRow;
28088     }
28089 
28090     /**
28091      * Starting row in table to scan.
28092      * Send "" (empty string) to start at the first row.
28093      */
28094     public scannerOpenWithStopTs_args setStartRow(byte[] startRow) {
28095       this.startRow = startRow;
28096       return this;
28097     }
28098 
28099     public void unsetStartRow() {
28100       this.startRow = null;
28101     }
28102 
28103     /** Returns true if field startRow is set (has been asigned a value) and false otherwise */
28104     public boolean isSetStartRow() {
28105       return this.startRow != null;
28106     }
28107 
28108     public void setStartRowIsSet(boolean value) {
28109       if (!value) {
28110         this.startRow = null;
28111       }
28112     }
28113 
28114     /**
28115      * row to stop scanning on. This row is *not* included in the
28116      * scanner's results
28117      */
28118     public byte[] getStopRow() {
28119       return this.stopRow;
28120     }
28121 
28122     /**
28123      * row to stop scanning on. This row is *not* included in the
28124      * scanner's results
28125      */
28126     public scannerOpenWithStopTs_args setStopRow(byte[] stopRow) {
28127       this.stopRow = stopRow;
28128       return this;
28129     }
28130 
28131     public void unsetStopRow() {
28132       this.stopRow = null;
28133     }
28134 
28135     /** Returns true if field stopRow is set (has been asigned a value) and false otherwise */
28136     public boolean isSetStopRow() {
28137       return this.stopRow != null;
28138     }
28139 
28140     public void setStopRowIsSet(boolean value) {
28141       if (!value) {
28142         this.stopRow = null;
28143       }
28144     }
28145 
28146     public int getColumnsSize() {
28147       return (this.columns == null) ? 0 : this.columns.size();
28148     }
28149 
28150     public java.util.Iterator<byte[]> getColumnsIterator() {
28151       return (this.columns == null) ? null : this.columns.iterator();
28152     }
28153 
28154     public void addToColumns(byte[] elem) {
28155       if (this.columns == null) {
28156         this.columns = new ArrayList<byte[]>();
28157       }
28158       this.columns.add(elem);
28159     }
28160 
28161     /**
28162      * columns to scan. If column name is a column family, all
28163      * columns of the specified column family are returned. It's also possible
28164      * to pass a regex in the column qualifier.
28165      */
28166     public List<byte[]> getColumns() {
28167       return this.columns;
28168     }
28169 
28170     /**
28171      * columns to scan. If column name is a column family, all
28172      * columns of the specified column family are returned. It's also possible
28173      * to pass a regex in the column qualifier.
28174      */
28175     public scannerOpenWithStopTs_args setColumns(List<byte[]> columns) {
28176       this.columns = columns;
28177       return this;
28178     }
28179 
28180     public void unsetColumns() {
28181       this.columns = null;
28182     }
28183 
28184     /** Returns true if field columns is set (has been asigned a value) and false otherwise */
28185     public boolean isSetColumns() {
28186       return this.columns != null;
28187     }
28188 
28189     public void setColumnsIsSet(boolean value) {
28190       if (!value) {
28191         this.columns = null;
28192       }
28193     }
28194 
28195     /**
28196      * timestamp
28197      */
28198     public long getTimestamp() {
28199       return this.timestamp;
28200     }
28201 
28202     /**
28203      * timestamp
28204      */
28205     public scannerOpenWithStopTs_args setTimestamp(long timestamp) {
28206       this.timestamp = timestamp;
28207       setTimestampIsSet(true);
28208       return this;
28209     }
28210 
28211     public void unsetTimestamp() {
28212       __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
28213     }
28214 
28215     /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
28216     public boolean isSetTimestamp() {
28217       return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
28218     }
28219 
28220     public void setTimestampIsSet(boolean value) {
28221       __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
28222     }
28223 
28224     public void setFieldValue(_Fields field, Object value) {
28225       switch (field) {
28226       case TABLE_NAME:
28227         if (value == null) {
28228           unsetTableName();
28229         } else {
28230           setTableName((byte[])value);
28231         }
28232         break;
28233 
28234       case START_ROW:
28235         if (value == null) {
28236           unsetStartRow();
28237         } else {
28238           setStartRow((byte[])value);
28239         }
28240         break;
28241 
28242       case STOP_ROW:
28243         if (value == null) {
28244           unsetStopRow();
28245         } else {
28246           setStopRow((byte[])value);
28247         }
28248         break;
28249 
28250       case COLUMNS:
28251         if (value == null) {
28252           unsetColumns();
28253         } else {
28254           setColumns((List<byte[]>)value);
28255         }
28256         break;
28257 
28258       case TIMESTAMP:
28259         if (value == null) {
28260           unsetTimestamp();
28261         } else {
28262           setTimestamp((Long)value);
28263         }
28264         break;
28265 
28266       }
28267     }
28268 
28269     public void setFieldValue(int fieldID, Object value) {
28270       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
28271     }
28272 
28273     public Object getFieldValue(_Fields field) {
28274       switch (field) {
28275       case TABLE_NAME:
28276         return getTableName();
28277 
28278       case START_ROW:
28279         return getStartRow();
28280 
28281       case STOP_ROW:
28282         return getStopRow();
28283 
28284       case COLUMNS:
28285         return getColumns();
28286 
28287       case TIMESTAMP:
28288         return new Long(getTimestamp());
28289 
28290       }
28291       throw new IllegalStateException();
28292     }
28293 
28294     public Object getFieldValue(int fieldId) {
28295       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
28296     }
28297 
28298     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
28299     public boolean isSet(_Fields field) {
28300       switch (field) {
28301       case TABLE_NAME:
28302         return isSetTableName();
28303       case START_ROW:
28304         return isSetStartRow();
28305       case STOP_ROW:
28306         return isSetStopRow();
28307       case COLUMNS:
28308         return isSetColumns();
28309       case TIMESTAMP:
28310         return isSetTimestamp();
28311       }
28312       throw new IllegalStateException();
28313     }
28314 
28315     public boolean isSet(int fieldID) {
28316       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
28317     }
28318 
28319     @Override
28320     public boolean equals(Object that) {
28321       if (that == null)
28322         return false;
28323       if (that instanceof scannerOpenWithStopTs_args)
28324         return this.equals((scannerOpenWithStopTs_args)that);
28325       return false;
28326     }
28327 
28328     public boolean equals(scannerOpenWithStopTs_args that) {
28329       if (that == null)
28330         return false;
28331 
28332       boolean this_present_tableName = true && this.isSetTableName();
28333       boolean that_present_tableName = true && that.isSetTableName();
28334       if (this_present_tableName || that_present_tableName) {
28335         if (!(this_present_tableName && that_present_tableName))
28336           return false;
28337         if (!java.util.Arrays.equals(this.tableName, that.tableName))
28338           return false;
28339       }
28340 
28341       boolean this_present_startRow = true && this.isSetStartRow();
28342       boolean that_present_startRow = true && that.isSetStartRow();
28343       if (this_present_startRow || that_present_startRow) {
28344         if (!(this_present_startRow && that_present_startRow))
28345           return false;
28346         if (!java.util.Arrays.equals(this.startRow, that.startRow))
28347           return false;
28348       }
28349 
28350       boolean this_present_stopRow = true && this.isSetStopRow();
28351       boolean that_present_stopRow = true && that.isSetStopRow();
28352       if (this_present_stopRow || that_present_stopRow) {
28353         if (!(this_present_stopRow && that_present_stopRow))
28354           return false;
28355         if (!java.util.Arrays.equals(this.stopRow, that.stopRow))
28356           return false;
28357       }
28358 
28359       boolean this_present_columns = true && this.isSetColumns();
28360       boolean that_present_columns = true && that.isSetColumns();
28361       if (this_present_columns || that_present_columns) {
28362         if (!(this_present_columns && that_present_columns))
28363           return false;
28364         if (!this.columns.equals(that.columns))
28365           return false;
28366       }
28367 
28368       boolean this_present_timestamp = true;
28369       boolean that_present_timestamp = true;
28370       if (this_present_timestamp || that_present_timestamp) {
28371         if (!(this_present_timestamp && that_present_timestamp))
28372           return false;
28373         if (this.timestamp != that.timestamp)
28374           return false;
28375       }
28376 
28377       return true;
28378     }
28379 
28380     @Override
28381     public int hashCode() {
28382       HashCodeBuilder builder = new HashCodeBuilder();
28383 
28384       boolean present_tableName = true && (isSetTableName());
28385       builder.append(present_tableName);
28386       if (present_tableName)
28387         builder.append(tableName);
28388 
28389       boolean present_startRow = true && (isSetStartRow());
28390       builder.append(present_startRow);
28391       if (present_startRow)
28392         builder.append(startRow);
28393 
28394       boolean present_stopRow = true && (isSetStopRow());
28395       builder.append(present_stopRow);
28396       if (present_stopRow)
28397         builder.append(stopRow);
28398 
28399       boolean present_columns = true && (isSetColumns());
28400       builder.append(present_columns);
28401       if (present_columns)
28402         builder.append(columns);
28403 
28404       boolean present_timestamp = true;
28405       builder.append(present_timestamp);
28406       if (present_timestamp)
28407         builder.append(timestamp);
28408 
28409       return builder.toHashCode();
28410     }
28411 
28412     public int compareTo(scannerOpenWithStopTs_args other) {
28413       if (!getClass().equals(other.getClass())) {
28414         return getClass().getName().compareTo(other.getClass().getName());
28415       }
28416 
28417       int lastComparison = 0;
28418       scannerOpenWithStopTs_args typedOther = (scannerOpenWithStopTs_args)other;
28419 
28420       lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
28421       if (lastComparison != 0) {
28422         return lastComparison;
28423       }
28424       lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
28425       if (lastComparison != 0) {
28426         return lastComparison;
28427       }
28428       lastComparison = Boolean.valueOf(isSetStartRow()).compareTo(isSetStartRow());
28429       if (lastComparison != 0) {
28430         return lastComparison;
28431       }
28432       lastComparison = TBaseHelper.compareTo(startRow, typedOther.startRow);
28433       if (lastComparison != 0) {
28434         return lastComparison;
28435       }
28436       lastComparison = Boolean.valueOf(isSetStopRow()).compareTo(isSetStopRow());
28437       if (lastComparison != 0) {
28438         return lastComparison;
28439       }
28440       lastComparison = TBaseHelper.compareTo(stopRow, typedOther.stopRow);
28441       if (lastComparison != 0) {
28442         return lastComparison;
28443       }
28444       lastComparison = Boolean.valueOf(isSetColumns()).compareTo(isSetColumns());
28445       if (lastComparison != 0) {
28446         return lastComparison;
28447       }
28448       lastComparison = TBaseHelper.compareTo(columns, typedOther.columns);
28449       if (lastComparison != 0) {
28450         return lastComparison;
28451       }
28452       lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
28453       if (lastComparison != 0) {
28454         return lastComparison;
28455       }
28456       lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
28457       if (lastComparison != 0) {
28458         return lastComparison;
28459       }
28460       return 0;
28461     }
28462 
28463     public void read(TProtocol iprot) throws TException {
28464       TField field;
28465       iprot.readStructBegin();
28466       while (true)
28467       {
28468         field = iprot.readFieldBegin();
28469         if (field.type == TType.STOP) {
28470           break;
28471         }
28472         _Fields fieldId = _Fields.findByThriftId(field.id);
28473         if (fieldId == null) {
28474           TProtocolUtil.skip(iprot, field.type);
28475         } else {
28476           switch (fieldId) {
28477             case TABLE_NAME:
28478               if (field.type == TType.STRING) {
28479                 this.tableName = iprot.readBinary();
28480               } else {
28481                 TProtocolUtil.skip(iprot, field.type);
28482               }
28483               break;
28484             case START_ROW:
28485               if (field.type == TType.STRING) {
28486                 this.startRow = iprot.readBinary();
28487               } else {
28488                 TProtocolUtil.skip(iprot, field.type);
28489               }
28490               break;
28491             case STOP_ROW:
28492               if (field.type == TType.STRING) {
28493                 this.stopRow = iprot.readBinary();
28494               } else {
28495                 TProtocolUtil.skip(iprot, field.type);
28496               }
28497               break;
28498             case COLUMNS:
28499               if (field.type == TType.LIST) {
28500                 {
28501                   TList _list94 = iprot.readListBegin();
28502                   this.columns = new ArrayList<byte[]>(_list94.size);
28503                   for (int _i95 = 0; _i95 < _list94.size; ++_i95)
28504                   {
28505                     byte[] _elem96;
28506                     _elem96 = iprot.readBinary();
28507                     this.columns.add(_elem96);
28508                   }
28509                   iprot.readListEnd();
28510                 }
28511               } else {
28512                 TProtocolUtil.skip(iprot, field.type);
28513               }
28514               break;
28515             case TIMESTAMP:
28516               if (field.type == TType.I64) {
28517                 this.timestamp = iprot.readI64();
28518                 setTimestampIsSet(true);
28519               } else {
28520                 TProtocolUtil.skip(iprot, field.type);
28521               }
28522               break;
28523           }
28524           iprot.readFieldEnd();
28525         }
28526       }
28527       iprot.readStructEnd();
28528 
28529       // check for required fields of primitive type, which can't be checked in the validate method
28530       validate();
28531     }
28532 
28533     public void write(TProtocol oprot) throws TException {
28534       validate();
28535 
28536       oprot.writeStructBegin(STRUCT_DESC);
28537       if (this.tableName != null) {
28538         oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
28539         oprot.writeBinary(this.tableName);
28540         oprot.writeFieldEnd();
28541       }
28542       if (this.startRow != null) {
28543         oprot.writeFieldBegin(START_ROW_FIELD_DESC);
28544         oprot.writeBinary(this.startRow);
28545         oprot.writeFieldEnd();
28546       }
28547       if (this.stopRow != null) {
28548         oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
28549         oprot.writeBinary(this.stopRow);
28550         oprot.writeFieldEnd();
28551       }
28552       if (this.columns != null) {
28553         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
28554         {
28555           oprot.writeListBegin(new TList(TType.STRING, this.columns.size()));
28556           for (byte[] _iter97 : this.columns)
28557           {
28558             oprot.writeBinary(_iter97);
28559           }
28560           oprot.writeListEnd();
28561         }
28562         oprot.writeFieldEnd();
28563       }
28564       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
28565       oprot.writeI64(this.timestamp);
28566       oprot.writeFieldEnd();
28567       oprot.writeFieldStop();
28568       oprot.writeStructEnd();
28569     }
28570 
28571     @Override
28572     public String toString() {
28573       StringBuilder sb = new StringBuilder("scannerOpenWithStopTs_args(");
28574       boolean first = true;
28575 
28576       sb.append("tableName:");
28577       if (this.tableName == null) {
28578         sb.append("null");
28579       } else {
28580         sb.append(this.tableName);
28581       }
28582       first = false;
28583       if (!first) sb.append(", ");
28584       sb.append("startRow:");
28585       if (this.startRow == null) {
28586         sb.append("null");
28587       } else {
28588         sb.append(this.startRow);
28589       }
28590       first = false;
28591       if (!first) sb.append(", ");
28592       sb.append("stopRow:");
28593       if (this.stopRow == null) {
28594         sb.append("null");
28595       } else {
28596         sb.append(this.stopRow);
28597       }
28598       first = false;
28599       if (!first) sb.append(", ");
28600       sb.append("columns:");
28601       if (this.columns == null) {
28602         sb.append("null");
28603       } else {
28604         sb.append(this.columns);
28605       }
28606       first = false;
28607       if (!first) sb.append(", ");
28608       sb.append("timestamp:");
28609       sb.append(this.timestamp);
28610       first = false;
28611       sb.append(")");
28612       return sb.toString();
28613     }
28614 
28615     public void validate() throws TException {
28616       // check for required fields
28617     }
28618 
28619   }
28620 
28621   public static class scannerOpenWithStopTs_result implements TBase<scannerOpenWithStopTs_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerOpenWithStopTs_result>   {
28622     private static final TStruct STRUCT_DESC = new TStruct("scannerOpenWithStopTs_result");
28623 
28624     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
28625     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
28626 
28627     public int success;
28628     public IOError io;
28629 
28630     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
28631     public enum _Fields implements TFieldIdEnum {
28632       SUCCESS((short)0, "success"),
28633       IO((short)1, "io");
28634 
28635       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
28636       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
28637 
28638       static {
28639         for (_Fields field : EnumSet.allOf(_Fields.class)) {
28640           byId.put((int)field._thriftId, field);
28641           byName.put(field.getFieldName(), field);
28642         }
28643       }
28644 
28645       /**
28646        * Find the _Fields constant that matches fieldId, or null if its not found.
28647        */
28648       public static _Fields findByThriftId(int fieldId) {
28649         return byId.get(fieldId);
28650       }
28651 
28652       /**
28653        * Find the _Fields constant that matches fieldId, throwing an exception
28654        * if it is not found.
28655        */
28656       public static _Fields findByThriftIdOrThrow(int fieldId) {
28657         _Fields fields = findByThriftId(fieldId);
28658         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
28659         return fields;
28660       }
28661 
28662       /**
28663        * Find the _Fields constant that matches name, or null if its not found.
28664        */
28665       public static _Fields findByName(String name) {
28666         return byName.get(name);
28667       }
28668 
28669       private final short _thriftId;
28670       private final String _fieldName;
28671 
28672       _Fields(short thriftId, String fieldName) {
28673         _thriftId = thriftId;
28674         _fieldName = fieldName;
28675       }
28676 
28677       public short getThriftFieldId() {
28678         return _thriftId;
28679       }
28680 
28681       public String getFieldName() {
28682         return _fieldName;
28683       }
28684     }
28685 
28686     // isset id assignments
28687     private static final int __SUCCESS_ISSET_ID = 0;
28688     private BitSet __isset_bit_vector = new BitSet(1);
28689 
28690     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
28691       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
28692           new FieldValueMetaData(TType.I32)));
28693       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
28694           new FieldValueMetaData(TType.STRUCT)));
28695     }});
28696 
28697     static {
28698       FieldMetaData.addStructMetaDataMap(scannerOpenWithStopTs_result.class, metaDataMap);
28699     }
28700 
28701     public scannerOpenWithStopTs_result() {
28702     }
28703 
28704     public scannerOpenWithStopTs_result(
28705       int success,
28706       IOError io)
28707     {
28708       this();
28709       this.success = success;
28710       setSuccessIsSet(true);
28711       this.io = io;
28712     }
28713 
28714     /**
28715      * Performs a deep copy on <i>other</i>.
28716      */
28717     public scannerOpenWithStopTs_result(scannerOpenWithStopTs_result other) {
28718       __isset_bit_vector.clear();
28719       __isset_bit_vector.or(other.__isset_bit_vector);
28720       this.success = other.success;
28721       if (other.isSetIo()) {
28722         this.io = new IOError(other.io);
28723       }
28724     }
28725 
28726     public scannerOpenWithStopTs_result deepCopy() {
28727       return new scannerOpenWithStopTs_result(this);
28728     }
28729 
28730     @Deprecated
28731     public scannerOpenWithStopTs_result clone() {
28732       return new scannerOpenWithStopTs_result(this);
28733     }
28734 
28735     public int getSuccess() {
28736       return this.success;
28737     }
28738 
28739     public scannerOpenWithStopTs_result setSuccess(int success) {
28740       this.success = success;
28741       setSuccessIsSet(true);
28742       return this;
28743     }
28744 
28745     public void unsetSuccess() {
28746       __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
28747     }
28748 
28749     /** Returns true if field success is set (has been asigned a value) and false otherwise */
28750     public boolean isSetSuccess() {
28751       return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
28752     }
28753 
28754     public void setSuccessIsSet(boolean value) {
28755       __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
28756     }
28757 
28758     public IOError getIo() {
28759       return this.io;
28760     }
28761 
28762     public scannerOpenWithStopTs_result setIo(IOError io) {
28763       this.io = io;
28764       return this;
28765     }
28766 
28767     public void unsetIo() {
28768       this.io = null;
28769     }
28770 
28771     /** Returns true if field io is set (has been asigned a value) and false otherwise */
28772     public boolean isSetIo() {
28773       return this.io != null;
28774     }
28775 
28776     public void setIoIsSet(boolean value) {
28777       if (!value) {
28778         this.io = null;
28779       }
28780     }
28781 
28782     public void setFieldValue(_Fields field, Object value) {
28783       switch (field) {
28784       case SUCCESS:
28785         if (value == null) {
28786           unsetSuccess();
28787         } else {
28788           setSuccess((Integer)value);
28789         }
28790         break;
28791 
28792       case IO:
28793         if (value == null) {
28794           unsetIo();
28795         } else {
28796           setIo((IOError)value);
28797         }
28798         break;
28799 
28800       }
28801     }
28802 
28803     public void setFieldValue(int fieldID, Object value) {
28804       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
28805     }
28806 
28807     public Object getFieldValue(_Fields field) {
28808       switch (field) {
28809       case SUCCESS:
28810         return new Integer(getSuccess());
28811 
28812       case IO:
28813         return getIo();
28814 
28815       }
28816       throw new IllegalStateException();
28817     }
28818 
28819     public Object getFieldValue(int fieldId) {
28820       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
28821     }
28822 
28823     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
28824     public boolean isSet(_Fields field) {
28825       switch (field) {
28826       case SUCCESS:
28827         return isSetSuccess();
28828       case IO:
28829         return isSetIo();
28830       }
28831       throw new IllegalStateException();
28832     }
28833 
28834     public boolean isSet(int fieldID) {
28835       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
28836     }
28837 
28838     @Override
28839     public boolean equals(Object that) {
28840       if (that == null)
28841         return false;
28842       if (that instanceof scannerOpenWithStopTs_result)
28843         return this.equals((scannerOpenWithStopTs_result)that);
28844       return false;
28845     }
28846 
28847     public boolean equals(scannerOpenWithStopTs_result that) {
28848       if (that == null)
28849         return false;
28850 
28851       boolean this_present_success = true;
28852       boolean that_present_success = true;
28853       if (this_present_success || that_present_success) {
28854         if (!(this_present_success && that_present_success))
28855           return false;
28856         if (this.success != that.success)
28857           return false;
28858       }
28859 
28860       boolean this_present_io = true && this.isSetIo();
28861       boolean that_present_io = true && that.isSetIo();
28862       if (this_present_io || that_present_io) {
28863         if (!(this_present_io && that_present_io))
28864           return false;
28865         if (!this.io.equals(that.io))
28866           return false;
28867       }
28868 
28869       return true;
28870     }
28871 
28872     @Override
28873     public int hashCode() {
28874       HashCodeBuilder builder = new HashCodeBuilder();
28875 
28876       boolean present_success = true;
28877       builder.append(present_success);
28878       if (present_success)
28879         builder.append(success);
28880 
28881       boolean present_io = true && (isSetIo());
28882       builder.append(present_io);
28883       if (present_io)
28884         builder.append(io);
28885 
28886       return builder.toHashCode();
28887     }
28888 
28889     public int compareTo(scannerOpenWithStopTs_result other) {
28890       if (!getClass().equals(other.getClass())) {
28891         return getClass().getName().compareTo(other.getClass().getName());
28892       }
28893 
28894       int lastComparison = 0;
28895       scannerOpenWithStopTs_result typedOther = (scannerOpenWithStopTs_result)other;
28896 
28897       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
28898       if (lastComparison != 0) {
28899         return lastComparison;
28900       }
28901       lastComparison = TBaseHelper.compareTo(success, typedOther.success);
28902       if (lastComparison != 0) {
28903         return lastComparison;
28904       }
28905       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
28906       if (lastComparison != 0) {
28907         return lastComparison;
28908       }
28909       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
28910       if (lastComparison != 0) {
28911         return lastComparison;
28912       }
28913       return 0;
28914     }
28915 
28916     public void read(TProtocol iprot) throws TException {
28917       TField field;
28918       iprot.readStructBegin();
28919       while (true)
28920       {
28921         field = iprot.readFieldBegin();
28922         if (field.type == TType.STOP) {
28923           break;
28924         }
28925         _Fields fieldId = _Fields.findByThriftId(field.id);
28926         if (fieldId == null) {
28927           TProtocolUtil.skip(iprot, field.type);
28928         } else {
28929           switch (fieldId) {
28930             case SUCCESS:
28931               if (field.type == TType.I32) {
28932                 this.success = iprot.readI32();
28933                 setSuccessIsSet(true);
28934               } else {
28935                 TProtocolUtil.skip(iprot, field.type);
28936               }
28937               break;
28938             case IO:
28939               if (field.type == TType.STRUCT) {
28940                 this.io = new IOError();
28941                 this.io.read(iprot);
28942               } else {
28943                 TProtocolUtil.skip(iprot, field.type);
28944               }
28945               break;
28946           }
28947           iprot.readFieldEnd();
28948         }
28949       }
28950       iprot.readStructEnd();
28951 
28952       // check for required fields of primitive type, which can't be checked in the validate method
28953       validate();
28954     }
28955 
28956     public void write(TProtocol oprot) throws TException {
28957       oprot.writeStructBegin(STRUCT_DESC);
28958 
28959       if (this.isSetSuccess()) {
28960         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28961         oprot.writeI32(this.success);
28962         oprot.writeFieldEnd();
28963       } else if (this.isSetIo()) {
28964         oprot.writeFieldBegin(IO_FIELD_DESC);
28965         this.io.write(oprot);
28966         oprot.writeFieldEnd();
28967       }
28968       oprot.writeFieldStop();
28969       oprot.writeStructEnd();
28970     }
28971 
28972     @Override
28973     public String toString() {
28974       StringBuilder sb = new StringBuilder("scannerOpenWithStopTs_result(");
28975       boolean first = true;
28976 
28977       sb.append("success:");
28978       sb.append(this.success);
28979       first = false;
28980       if (!first) sb.append(", ");
28981       sb.append("io:");
28982       if (this.io == null) {
28983         sb.append("null");
28984       } else {
28985         sb.append(this.io);
28986       }
28987       first = false;
28988       sb.append(")");
28989       return sb.toString();
28990     }
28991 
28992     public void validate() throws TException {
28993       // check for required fields
28994     }
28995 
28996   }
28997 
28998   public static class scannerGet_args implements TBase<scannerGet_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGet_args>   {
28999     private static final TStruct STRUCT_DESC = new TStruct("scannerGet_args");
29000 
29001     private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
29002 
29003     /**
29004      * id of a scanner returned by scannerOpen
29005      */
29006     public int id;
29007 
29008     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
29009     public enum _Fields implements TFieldIdEnum {
29010       /**
29011        * id of a scanner returned by scannerOpen
29012        */
29013       ID((short)1, "id");
29014 
29015       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29016       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29017 
29018       static {
29019         for (_Fields field : EnumSet.allOf(_Fields.class)) {
29020           byId.put((int)field._thriftId, field);
29021           byName.put(field.getFieldName(), field);
29022         }
29023       }
29024 
29025       /**
29026        * Find the _Fields constant that matches fieldId, or null if its not found.
29027        */
29028       public static _Fields findByThriftId(int fieldId) {
29029         return byId.get(fieldId);
29030       }
29031 
29032       /**
29033        * Find the _Fields constant that matches fieldId, throwing an exception
29034        * if it is not found.
29035        */
29036       public static _Fields findByThriftIdOrThrow(int fieldId) {
29037         _Fields fields = findByThriftId(fieldId);
29038         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29039         return fields;
29040       }
29041 
29042       /**
29043        * Find the _Fields constant that matches name, or null if its not found.
29044        */
29045       public static _Fields findByName(String name) {
29046         return byName.get(name);
29047       }
29048 
29049       private final short _thriftId;
29050       private final String _fieldName;
29051 
29052       _Fields(short thriftId, String fieldName) {
29053         _thriftId = thriftId;
29054         _fieldName = fieldName;
29055       }
29056 
29057       public short getThriftFieldId() {
29058         return _thriftId;
29059       }
29060 
29061       public String getFieldName() {
29062         return _fieldName;
29063       }
29064     }
29065 
29066     // isset id assignments
29067     private static final int __ID_ISSET_ID = 0;
29068     private BitSet __isset_bit_vector = new BitSet(1);
29069 
29070     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29071       put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
29072           new FieldValueMetaData(TType.I32)));
29073     }});
29074 
29075     static {
29076       FieldMetaData.addStructMetaDataMap(scannerGet_args.class, metaDataMap);
29077     }
29078 
29079     public scannerGet_args() {
29080     }
29081 
29082     public scannerGet_args(
29083       int id)
29084     {
29085       this();
29086       this.id = id;
29087       setIdIsSet(true);
29088     }
29089 
29090     /**
29091      * Performs a deep copy on <i>other</i>.
29092      */
29093     public scannerGet_args(scannerGet_args other) {
29094       __isset_bit_vector.clear();
29095       __isset_bit_vector.or(other.__isset_bit_vector);
29096       this.id = other.id;
29097     }
29098 
29099     public scannerGet_args deepCopy() {
29100       return new scannerGet_args(this);
29101     }
29102 
29103     @Deprecated
29104     public scannerGet_args clone() {
29105       return new scannerGet_args(this);
29106     }
29107 
29108     /**
29109      * id of a scanner returned by scannerOpen
29110      */
29111     public int getId() {
29112       return this.id;
29113     }
29114 
29115     /**
29116      * id of a scanner returned by scannerOpen
29117      */
29118     public scannerGet_args setId(int id) {
29119       this.id = id;
29120       setIdIsSet(true);
29121       return this;
29122     }
29123 
29124     public void unsetId() {
29125       __isset_bit_vector.clear(__ID_ISSET_ID);
29126     }
29127 
29128     /** Returns true if field id is set (has been asigned a value) and false otherwise */
29129     public boolean isSetId() {
29130       return __isset_bit_vector.get(__ID_ISSET_ID);
29131     }
29132 
29133     public void setIdIsSet(boolean value) {
29134       __isset_bit_vector.set(__ID_ISSET_ID, value);
29135     }
29136 
29137     public void setFieldValue(_Fields field, Object value) {
29138       switch (field) {
29139       case ID:
29140         if (value == null) {
29141           unsetId();
29142         } else {
29143           setId((Integer)value);
29144         }
29145         break;
29146 
29147       }
29148     }
29149 
29150     public void setFieldValue(int fieldID, Object value) {
29151       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29152     }
29153 
29154     public Object getFieldValue(_Fields field) {
29155       switch (field) {
29156       case ID:
29157         return new Integer(getId());
29158 
29159       }
29160       throw new IllegalStateException();
29161     }
29162 
29163     public Object getFieldValue(int fieldId) {
29164       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29165     }
29166 
29167     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
29168     public boolean isSet(_Fields field) {
29169       switch (field) {
29170       case ID:
29171         return isSetId();
29172       }
29173       throw new IllegalStateException();
29174     }
29175 
29176     public boolean isSet(int fieldID) {
29177       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
29178     }
29179 
29180     @Override
29181     public boolean equals(Object that) {
29182       if (that == null)
29183         return false;
29184       if (that instanceof scannerGet_args)
29185         return this.equals((scannerGet_args)that);
29186       return false;
29187     }
29188 
29189     public boolean equals(scannerGet_args that) {
29190       if (that == null)
29191         return false;
29192 
29193       boolean this_present_id = true;
29194       boolean that_present_id = true;
29195       if (this_present_id || that_present_id) {
29196         if (!(this_present_id && that_present_id))
29197           return false;
29198         if (this.id != that.id)
29199           return false;
29200       }
29201 
29202       return true;
29203     }
29204 
29205     @Override
29206     public int hashCode() {
29207       HashCodeBuilder builder = new HashCodeBuilder();
29208 
29209       boolean present_id = true;
29210       builder.append(present_id);
29211       if (present_id)
29212         builder.append(id);
29213 
29214       return builder.toHashCode();
29215     }
29216 
29217     public int compareTo(scannerGet_args other) {
29218       if (!getClass().equals(other.getClass())) {
29219         return getClass().getName().compareTo(other.getClass().getName());
29220       }
29221 
29222       int lastComparison = 0;
29223       scannerGet_args typedOther = (scannerGet_args)other;
29224 
29225       lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
29226       if (lastComparison != 0) {
29227         return lastComparison;
29228       }
29229       lastComparison = TBaseHelper.compareTo(id, typedOther.id);
29230       if (lastComparison != 0) {
29231         return lastComparison;
29232       }
29233       return 0;
29234     }
29235 
29236     public void read(TProtocol iprot) throws TException {
29237       TField field;
29238       iprot.readStructBegin();
29239       while (true)
29240       {
29241         field = iprot.readFieldBegin();
29242         if (field.type == TType.STOP) {
29243           break;
29244         }
29245         _Fields fieldId = _Fields.findByThriftId(field.id);
29246         if (fieldId == null) {
29247           TProtocolUtil.skip(iprot, field.type);
29248         } else {
29249           switch (fieldId) {
29250             case ID:
29251               if (field.type == TType.I32) {
29252                 this.id = iprot.readI32();
29253                 setIdIsSet(true);
29254               } else {
29255                 TProtocolUtil.skip(iprot, field.type);
29256               }
29257               break;
29258           }
29259           iprot.readFieldEnd();
29260         }
29261       }
29262       iprot.readStructEnd();
29263 
29264       // check for required fields of primitive type, which can't be checked in the validate method
29265       validate();
29266     }
29267 
29268     public void write(TProtocol oprot) throws TException {
29269       validate();
29270 
29271       oprot.writeStructBegin(STRUCT_DESC);
29272       oprot.writeFieldBegin(ID_FIELD_DESC);
29273       oprot.writeI32(this.id);
29274       oprot.writeFieldEnd();
29275       oprot.writeFieldStop();
29276       oprot.writeStructEnd();
29277     }
29278 
29279     @Override
29280     public String toString() {
29281       StringBuilder sb = new StringBuilder("scannerGet_args(");
29282       boolean first = true;
29283 
29284       sb.append("id:");
29285       sb.append(this.id);
29286       first = false;
29287       sb.append(")");
29288       return sb.toString();
29289     }
29290 
29291     public void validate() throws TException {
29292       // check for required fields
29293     }
29294 
29295   }
29296 
29297   public static class scannerGet_result implements TBase<scannerGet_result._Fields>, java.io.Serializable, Cloneable   {
29298     private static final TStruct STRUCT_DESC = new TStruct("scannerGet_result");
29299 
29300     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
29301     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
29302     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
29303 
29304     public List<TRowResult> success;
29305     public IOError io;
29306     public IllegalArgument ia;
29307 
29308     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
29309     public enum _Fields implements TFieldIdEnum {
29310       SUCCESS((short)0, "success"),
29311       IO((short)1, "io"),
29312       IA((short)2, "ia");
29313 
29314       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29315       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29316 
29317       static {
29318         for (_Fields field : EnumSet.allOf(_Fields.class)) {
29319           byId.put((int)field._thriftId, field);
29320           byName.put(field.getFieldName(), field);
29321         }
29322       }
29323 
29324       /**
29325        * Find the _Fields constant that matches fieldId, or null if its not found.
29326        */
29327       public static _Fields findByThriftId(int fieldId) {
29328         return byId.get(fieldId);
29329       }
29330 
29331       /**
29332        * Find the _Fields constant that matches fieldId, throwing an exception
29333        * if it is not found.
29334        */
29335       public static _Fields findByThriftIdOrThrow(int fieldId) {
29336         _Fields fields = findByThriftId(fieldId);
29337         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29338         return fields;
29339       }
29340 
29341       /**
29342        * Find the _Fields constant that matches name, or null if its not found.
29343        */
29344       public static _Fields findByName(String name) {
29345         return byName.get(name);
29346       }
29347 
29348       private final short _thriftId;
29349       private final String _fieldName;
29350 
29351       _Fields(short thriftId, String fieldName) {
29352         _thriftId = thriftId;
29353         _fieldName = fieldName;
29354       }
29355 
29356       public short getThriftFieldId() {
29357         return _thriftId;
29358       }
29359 
29360       public String getFieldName() {
29361         return _fieldName;
29362       }
29363     }
29364 
29365     // isset id assignments
29366 
29367     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29368       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
29369           new ListMetaData(TType.LIST,
29370               new StructMetaData(TType.STRUCT, TRowResult.class))));
29371       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
29372           new FieldValueMetaData(TType.STRUCT)));
29373       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
29374           new FieldValueMetaData(TType.STRUCT)));
29375     }});
29376 
29377     static {
29378       FieldMetaData.addStructMetaDataMap(scannerGet_result.class, metaDataMap);
29379     }
29380 
29381     public scannerGet_result() {
29382     }
29383 
29384     public scannerGet_result(
29385       List<TRowResult> success,
29386       IOError io,
29387       IllegalArgument ia)
29388     {
29389       this();
29390       this.success = success;
29391       this.io = io;
29392       this.ia = ia;
29393     }
29394 
29395     /**
29396      * Performs a deep copy on <i>other</i>.
29397      */
29398     public scannerGet_result(scannerGet_result other) {
29399       if (other.isSetSuccess()) {
29400         List<TRowResult> __this__success = new ArrayList<TRowResult>();
29401         for (TRowResult other_element : other.success) {
29402           __this__success.add(new TRowResult(other_element));
29403         }
29404         this.success = __this__success;
29405       }
29406       if (other.isSetIo()) {
29407         this.io = new IOError(other.io);
29408       }
29409       if (other.isSetIa()) {
29410         this.ia = new IllegalArgument(other.ia);
29411       }
29412     }
29413 
29414     public scannerGet_result deepCopy() {
29415       return new scannerGet_result(this);
29416     }
29417 
29418     @Deprecated
29419     public scannerGet_result clone() {
29420       return new scannerGet_result(this);
29421     }
29422 
29423     public int getSuccessSize() {
29424       return (this.success == null) ? 0 : this.success.size();
29425     }
29426 
29427     public java.util.Iterator<TRowResult> getSuccessIterator() {
29428       return (this.success == null) ? null : this.success.iterator();
29429     }
29430 
29431     public void addToSuccess(TRowResult elem) {
29432       if (this.success == null) {
29433         this.success = new ArrayList<TRowResult>();
29434       }
29435       this.success.add(elem);
29436     }
29437 
29438     public List<TRowResult> getSuccess() {
29439       return this.success;
29440     }
29441 
29442     public scannerGet_result setSuccess(List<TRowResult> success) {
29443       this.success = success;
29444       return this;
29445     }
29446 
29447     public void unsetSuccess() {
29448       this.success = null;
29449     }
29450 
29451     /** Returns true if field success is set (has been asigned a value) and false otherwise */
29452     public boolean isSetSuccess() {
29453       return this.success != null;
29454     }
29455 
29456     public void setSuccessIsSet(boolean value) {
29457       if (!value) {
29458         this.success = null;
29459       }
29460     }
29461 
29462     public IOError getIo() {
29463       return this.io;
29464     }
29465 
29466     public scannerGet_result setIo(IOError io) {
29467       this.io = io;
29468       return this;
29469     }
29470 
29471     public void unsetIo() {
29472       this.io = null;
29473     }
29474 
29475     /** Returns true if field io is set (has been asigned a value) and false otherwise */
29476     public boolean isSetIo() {
29477       return this.io != null;
29478     }
29479 
29480     public void setIoIsSet(boolean value) {
29481       if (!value) {
29482         this.io = null;
29483       }
29484     }
29485 
29486     public IllegalArgument getIa() {
29487       return this.ia;
29488     }
29489 
29490     public scannerGet_result setIa(IllegalArgument ia) {
29491       this.ia = ia;
29492       return this;
29493     }
29494 
29495     public void unsetIa() {
29496       this.ia = null;
29497     }
29498 
29499     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
29500     public boolean isSetIa() {
29501       return this.ia != null;
29502     }
29503 
29504     public void setIaIsSet(boolean value) {
29505       if (!value) {
29506         this.ia = null;
29507       }
29508     }
29509 
29510     public void setFieldValue(_Fields field, Object value) {
29511       switch (field) {
29512       case SUCCESS:
29513         if (value == null) {
29514           unsetSuccess();
29515         } else {
29516           setSuccess((List<TRowResult>)value);
29517         }
29518         break;
29519 
29520       case IO:
29521         if (value == null) {
29522           unsetIo();
29523         } else {
29524           setIo((IOError)value);
29525         }
29526         break;
29527 
29528       case IA:
29529         if (value == null) {
29530           unsetIa();
29531         } else {
29532           setIa((IllegalArgument)value);
29533         }
29534         break;
29535 
29536       }
29537     }
29538 
29539     public void setFieldValue(int fieldID, Object value) {
29540       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29541     }
29542 
29543     public Object getFieldValue(_Fields field) {
29544       switch (field) {
29545       case SUCCESS:
29546         return getSuccess();
29547 
29548       case IO:
29549         return getIo();
29550 
29551       case IA:
29552         return getIa();
29553 
29554       }
29555       throw new IllegalStateException();
29556     }
29557 
29558     public Object getFieldValue(int fieldId) {
29559       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29560     }
29561 
29562     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
29563     public boolean isSet(_Fields field) {
29564       switch (field) {
29565       case SUCCESS:
29566         return isSetSuccess();
29567       case IO:
29568         return isSetIo();
29569       case IA:
29570         return isSetIa();
29571       }
29572       throw new IllegalStateException();
29573     }
29574 
29575     public boolean isSet(int fieldID) {
29576       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
29577     }
29578 
29579     @Override
29580     public boolean equals(Object that) {
29581       if (that == null)
29582         return false;
29583       if (that instanceof scannerGet_result)
29584         return this.equals((scannerGet_result)that);
29585       return false;
29586     }
29587 
29588     public boolean equals(scannerGet_result that) {
29589       if (that == null)
29590         return false;
29591 
29592       boolean this_present_success = true && this.isSetSuccess();
29593       boolean that_present_success = true && that.isSetSuccess();
29594       if (this_present_success || that_present_success) {
29595         if (!(this_present_success && that_present_success))
29596           return false;
29597         if (!this.success.equals(that.success))
29598           return false;
29599       }
29600 
29601       boolean this_present_io = true && this.isSetIo();
29602       boolean that_present_io = true && that.isSetIo();
29603       if (this_present_io || that_present_io) {
29604         if (!(this_present_io && that_present_io))
29605           return false;
29606         if (!this.io.equals(that.io))
29607           return false;
29608       }
29609 
29610       boolean this_present_ia = true && this.isSetIa();
29611       boolean that_present_ia = true && that.isSetIa();
29612       if (this_present_ia || that_present_ia) {
29613         if (!(this_present_ia && that_present_ia))
29614           return false;
29615         if (!this.ia.equals(that.ia))
29616           return false;
29617       }
29618 
29619       return true;
29620     }
29621 
29622     @Override
29623     public int hashCode() {
29624       HashCodeBuilder builder = new HashCodeBuilder();
29625 
29626       boolean present_success = true && (isSetSuccess());
29627       builder.append(present_success);
29628       if (present_success)
29629         builder.append(success);
29630 
29631       boolean present_io = true && (isSetIo());
29632       builder.append(present_io);
29633       if (present_io)
29634         builder.append(io);
29635 
29636       boolean present_ia = true && (isSetIa());
29637       builder.append(present_ia);
29638       if (present_ia)
29639         builder.append(ia);
29640 
29641       return builder.toHashCode();
29642     }
29643 
29644     public void read(TProtocol iprot) throws TException {
29645       TField field;
29646       iprot.readStructBegin();
29647       while (true)
29648       {
29649         field = iprot.readFieldBegin();
29650         if (field.type == TType.STOP) {
29651           break;
29652         }
29653         _Fields fieldId = _Fields.findByThriftId(field.id);
29654         if (fieldId == null) {
29655           TProtocolUtil.skip(iprot, field.type);
29656         } else {
29657           switch (fieldId) {
29658             case SUCCESS:
29659               if (field.type == TType.LIST) {
29660                 {
29661                   TList _list98 = iprot.readListBegin();
29662                   this.success = new ArrayList<TRowResult>(_list98.size);
29663                   for (int _i99 = 0; _i99 < _list98.size; ++_i99)
29664                   {
29665                     TRowResult _elem100;
29666                     _elem100 = new TRowResult();
29667                     _elem100.read(iprot);
29668                     this.success.add(_elem100);
29669                   }
29670                   iprot.readListEnd();
29671                 }
29672               } else {
29673                 TProtocolUtil.skip(iprot, field.type);
29674               }
29675               break;
29676             case IO:
29677               if (field.type == TType.STRUCT) {
29678                 this.io = new IOError();
29679                 this.io.read(iprot);
29680               } else {
29681                 TProtocolUtil.skip(iprot, field.type);
29682               }
29683               break;
29684             case IA:
29685               if (field.type == TType.STRUCT) {
29686                 this.ia = new IllegalArgument();
29687                 this.ia.read(iprot);
29688               } else {
29689                 TProtocolUtil.skip(iprot, field.type);
29690               }
29691               break;
29692           }
29693           iprot.readFieldEnd();
29694         }
29695       }
29696       iprot.readStructEnd();
29697 
29698       // check for required fields of primitive type, which can't be checked in the validate method
29699       validate();
29700     }
29701 
29702     public void write(TProtocol oprot) throws TException {
29703       oprot.writeStructBegin(STRUCT_DESC);
29704 
29705       if (this.isSetSuccess()) {
29706         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29707         {
29708           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
29709           for (TRowResult _iter101 : this.success)
29710           {
29711             _iter101.write(oprot);
29712           }
29713           oprot.writeListEnd();
29714         }
29715         oprot.writeFieldEnd();
29716       } else if (this.isSetIo()) {
29717         oprot.writeFieldBegin(IO_FIELD_DESC);
29718         this.io.write(oprot);
29719         oprot.writeFieldEnd();
29720       } else if (this.isSetIa()) {
29721         oprot.writeFieldBegin(IA_FIELD_DESC);
29722         this.ia.write(oprot);
29723         oprot.writeFieldEnd();
29724       }
29725       oprot.writeFieldStop();
29726       oprot.writeStructEnd();
29727     }
29728 
29729     @Override
29730     public String toString() {
29731       StringBuilder sb = new StringBuilder("scannerGet_result(");
29732       boolean first = true;
29733 
29734       sb.append("success:");
29735       if (this.success == null) {
29736         sb.append("null");
29737       } else {
29738         sb.append(this.success);
29739       }
29740       first = false;
29741       if (!first) sb.append(", ");
29742       sb.append("io:");
29743       if (this.io == null) {
29744         sb.append("null");
29745       } else {
29746         sb.append(this.io);
29747       }
29748       first = false;
29749       if (!first) sb.append(", ");
29750       sb.append("ia:");
29751       if (this.ia == null) {
29752         sb.append("null");
29753       } else {
29754         sb.append(this.ia);
29755       }
29756       first = false;
29757       sb.append(")");
29758       return sb.toString();
29759     }
29760 
29761     public void validate() throws TException {
29762       // check for required fields
29763     }
29764 
29765   }
29766 
29767   public static class scannerGetList_args implements TBase<scannerGetList_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerGetList_args>   {
29768     private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_args");
29769 
29770     private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
29771     private static final TField NB_ROWS_FIELD_DESC = new TField("nbRows", TType.I32, (short)2);
29772 
29773     /**
29774      * id of a scanner returned by scannerOpen
29775      */
29776     public int id;
29777     /**
29778      * number of results to return
29779      */
29780     public int nbRows;
29781 
29782     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
29783     public enum _Fields implements TFieldIdEnum {
29784       /**
29785        * id of a scanner returned by scannerOpen
29786        */
29787       ID((short)1, "id"),
29788       /**
29789        * number of results to return
29790        */
29791       NB_ROWS((short)2, "nbRows");
29792 
29793       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
29794       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
29795 
29796       static {
29797         for (_Fields field : EnumSet.allOf(_Fields.class)) {
29798           byId.put((int)field._thriftId, field);
29799           byName.put(field.getFieldName(), field);
29800         }
29801       }
29802 
29803       /**
29804        * Find the _Fields constant that matches fieldId, or null if its not found.
29805        */
29806       public static _Fields findByThriftId(int fieldId) {
29807         return byId.get(fieldId);
29808       }
29809 
29810       /**
29811        * Find the _Fields constant that matches fieldId, throwing an exception
29812        * if it is not found.
29813        */
29814       public static _Fields findByThriftIdOrThrow(int fieldId) {
29815         _Fields fields = findByThriftId(fieldId);
29816         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
29817         return fields;
29818       }
29819 
29820       /**
29821        * Find the _Fields constant that matches name, or null if its not found.
29822        */
29823       public static _Fields findByName(String name) {
29824         return byName.get(name);
29825       }
29826 
29827       private final short _thriftId;
29828       private final String _fieldName;
29829 
29830       _Fields(short thriftId, String fieldName) {
29831         _thriftId = thriftId;
29832         _fieldName = fieldName;
29833       }
29834 
29835       public short getThriftFieldId() {
29836         return _thriftId;
29837       }
29838 
29839       public String getFieldName() {
29840         return _fieldName;
29841       }
29842     }
29843 
29844     // isset id assignments
29845     private static final int __ID_ISSET_ID = 0;
29846     private static final int __NBROWS_ISSET_ID = 1;
29847     private BitSet __isset_bit_vector = new BitSet(2);
29848 
29849     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
29850       put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
29851           new FieldValueMetaData(TType.I32)));
29852       put(_Fields.NB_ROWS, new FieldMetaData("nbRows", TFieldRequirementType.DEFAULT,
29853           new FieldValueMetaData(TType.I32)));
29854     }});
29855 
29856     static {
29857       FieldMetaData.addStructMetaDataMap(scannerGetList_args.class, metaDataMap);
29858     }
29859 
29860     public scannerGetList_args() {
29861     }
29862 
29863     public scannerGetList_args(
29864       int id,
29865       int nbRows)
29866     {
29867       this();
29868       this.id = id;
29869       setIdIsSet(true);
29870       this.nbRows = nbRows;
29871       setNbRowsIsSet(true);
29872     }
29873 
29874     /**
29875      * Performs a deep copy on <i>other</i>.
29876      */
29877     public scannerGetList_args(scannerGetList_args other) {
29878       __isset_bit_vector.clear();
29879       __isset_bit_vector.or(other.__isset_bit_vector);
29880       this.id = other.id;
29881       this.nbRows = other.nbRows;
29882     }
29883 
29884     public scannerGetList_args deepCopy() {
29885       return new scannerGetList_args(this);
29886     }
29887 
29888     @Deprecated
29889     public scannerGetList_args clone() {
29890       return new scannerGetList_args(this);
29891     }
29892 
29893     /**
29894      * id of a scanner returned by scannerOpen
29895      */
29896     public int getId() {
29897       return this.id;
29898     }
29899 
29900     /**
29901      * id of a scanner returned by scannerOpen
29902      */
29903     public scannerGetList_args setId(int id) {
29904       this.id = id;
29905       setIdIsSet(true);
29906       return this;
29907     }
29908 
29909     public void unsetId() {
29910       __isset_bit_vector.clear(__ID_ISSET_ID);
29911     }
29912 
29913     /** Returns true if field id is set (has been asigned a value) and false otherwise */
29914     public boolean isSetId() {
29915       return __isset_bit_vector.get(__ID_ISSET_ID);
29916     }
29917 
29918     public void setIdIsSet(boolean value) {
29919       __isset_bit_vector.set(__ID_ISSET_ID, value);
29920     }
29921 
29922     /**
29923      * number of results to return
29924      */
29925     public int getNbRows() {
29926       return this.nbRows;
29927     }
29928 
29929     /**
29930      * number of results to return
29931      */
29932     public scannerGetList_args setNbRows(int nbRows) {
29933       this.nbRows = nbRows;
29934       setNbRowsIsSet(true);
29935       return this;
29936     }
29937 
29938     public void unsetNbRows() {
29939       __isset_bit_vector.clear(__NBROWS_ISSET_ID);
29940     }
29941 
29942     /** Returns true if field nbRows is set (has been asigned a value) and false otherwise */
29943     public boolean isSetNbRows() {
29944       return __isset_bit_vector.get(__NBROWS_ISSET_ID);
29945     }
29946 
29947     public void setNbRowsIsSet(boolean value) {
29948       __isset_bit_vector.set(__NBROWS_ISSET_ID, value);
29949     }
29950 
29951     public void setFieldValue(_Fields field, Object value) {
29952       switch (field) {
29953       case ID:
29954         if (value == null) {
29955           unsetId();
29956         } else {
29957           setId((Integer)value);
29958         }
29959         break;
29960 
29961       case NB_ROWS:
29962         if (value == null) {
29963           unsetNbRows();
29964         } else {
29965           setNbRows((Integer)value);
29966         }
29967         break;
29968 
29969       }
29970     }
29971 
29972     public void setFieldValue(int fieldID, Object value) {
29973       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
29974     }
29975 
29976     public Object getFieldValue(_Fields field) {
29977       switch (field) {
29978       case ID:
29979         return new Integer(getId());
29980 
29981       case NB_ROWS:
29982         return new Integer(getNbRows());
29983 
29984       }
29985       throw new IllegalStateException();
29986     }
29987 
29988     public Object getFieldValue(int fieldId) {
29989       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
29990     }
29991 
29992     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
29993     public boolean isSet(_Fields field) {
29994       switch (field) {
29995       case ID:
29996         return isSetId();
29997       case NB_ROWS:
29998         return isSetNbRows();
29999       }
30000       throw new IllegalStateException();
30001     }
30002 
30003     public boolean isSet(int fieldID) {
30004       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30005     }
30006 
30007     @Override
30008     public boolean equals(Object that) {
30009       if (that == null)
30010         return false;
30011       if (that instanceof scannerGetList_args)
30012         return this.equals((scannerGetList_args)that);
30013       return false;
30014     }
30015 
30016     public boolean equals(scannerGetList_args that) {
30017       if (that == null)
30018         return false;
30019 
30020       boolean this_present_id = true;
30021       boolean that_present_id = true;
30022       if (this_present_id || that_present_id) {
30023         if (!(this_present_id && that_present_id))
30024           return false;
30025         if (this.id != that.id)
30026           return false;
30027       }
30028 
30029       boolean this_present_nbRows = true;
30030       boolean that_present_nbRows = true;
30031       if (this_present_nbRows || that_present_nbRows) {
30032         if (!(this_present_nbRows && that_present_nbRows))
30033           return false;
30034         if (this.nbRows != that.nbRows)
30035           return false;
30036       }
30037 
30038       return true;
30039     }
30040 
30041     @Override
30042     public int hashCode() {
30043       HashCodeBuilder builder = new HashCodeBuilder();
30044 
30045       boolean present_id = true;
30046       builder.append(present_id);
30047       if (present_id)
30048         builder.append(id);
30049 
30050       boolean present_nbRows = true;
30051       builder.append(present_nbRows);
30052       if (present_nbRows)
30053         builder.append(nbRows);
30054 
30055       return builder.toHashCode();
30056     }
30057 
30058     public int compareTo(scannerGetList_args other) {
30059       if (!getClass().equals(other.getClass())) {
30060         return getClass().getName().compareTo(other.getClass().getName());
30061       }
30062 
30063       int lastComparison = 0;
30064       scannerGetList_args typedOther = (scannerGetList_args)other;
30065 
30066       lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
30067       if (lastComparison != 0) {
30068         return lastComparison;
30069       }
30070       lastComparison = TBaseHelper.compareTo(id, typedOther.id);
30071       if (lastComparison != 0) {
30072         return lastComparison;
30073       }
30074       lastComparison = Boolean.valueOf(isSetNbRows()).compareTo(isSetNbRows());
30075       if (lastComparison != 0) {
30076         return lastComparison;
30077       }
30078       lastComparison = TBaseHelper.compareTo(nbRows, typedOther.nbRows);
30079       if (lastComparison != 0) {
30080         return lastComparison;
30081       }
30082       return 0;
30083     }
30084 
30085     public void read(TProtocol iprot) throws TException {
30086       TField field;
30087       iprot.readStructBegin();
30088       while (true)
30089       {
30090         field = iprot.readFieldBegin();
30091         if (field.type == TType.STOP) {
30092           break;
30093         }
30094         _Fields fieldId = _Fields.findByThriftId(field.id);
30095         if (fieldId == null) {
30096           TProtocolUtil.skip(iprot, field.type);
30097         } else {
30098           switch (fieldId) {
30099             case ID:
30100               if (field.type == TType.I32) {
30101                 this.id = iprot.readI32();
30102                 setIdIsSet(true);
30103               } else {
30104                 TProtocolUtil.skip(iprot, field.type);
30105               }
30106               break;
30107             case NB_ROWS:
30108               if (field.type == TType.I32) {
30109                 this.nbRows = iprot.readI32();
30110                 setNbRowsIsSet(true);
30111               } else {
30112                 TProtocolUtil.skip(iprot, field.type);
30113               }
30114               break;
30115           }
30116           iprot.readFieldEnd();
30117         }
30118       }
30119       iprot.readStructEnd();
30120 
30121       // check for required fields of primitive type, which can't be checked in the validate method
30122       validate();
30123     }
30124 
30125     public void write(TProtocol oprot) throws TException {
30126       validate();
30127 
30128       oprot.writeStructBegin(STRUCT_DESC);
30129       oprot.writeFieldBegin(ID_FIELD_DESC);
30130       oprot.writeI32(this.id);
30131       oprot.writeFieldEnd();
30132       oprot.writeFieldBegin(NB_ROWS_FIELD_DESC);
30133       oprot.writeI32(this.nbRows);
30134       oprot.writeFieldEnd();
30135       oprot.writeFieldStop();
30136       oprot.writeStructEnd();
30137     }
30138 
30139     @Override
30140     public String toString() {
30141       StringBuilder sb = new StringBuilder("scannerGetList_args(");
30142       boolean first = true;
30143 
30144       sb.append("id:");
30145       sb.append(this.id);
30146       first = false;
30147       if (!first) sb.append(", ");
30148       sb.append("nbRows:");
30149       sb.append(this.nbRows);
30150       first = false;
30151       sb.append(")");
30152       return sb.toString();
30153     }
30154 
30155     public void validate() throws TException {
30156       // check for required fields
30157     }
30158 
30159   }
30160 
30161   public static class scannerGetList_result implements TBase<scannerGetList_result._Fields>, java.io.Serializable, Cloneable   {
30162     private static final TStruct STRUCT_DESC = new TStruct("scannerGetList_result");
30163 
30164     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
30165     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
30166     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
30167 
30168     public List<TRowResult> success;
30169     public IOError io;
30170     public IllegalArgument ia;
30171 
30172     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
30173     public enum _Fields implements TFieldIdEnum {
30174       SUCCESS((short)0, "success"),
30175       IO((short)1, "io"),
30176       IA((short)2, "ia");
30177 
30178       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30179       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30180 
30181       static {
30182         for (_Fields field : EnumSet.allOf(_Fields.class)) {
30183           byId.put((int)field._thriftId, field);
30184           byName.put(field.getFieldName(), field);
30185         }
30186       }
30187 
30188       /**
30189        * Find the _Fields constant that matches fieldId, or null if its not found.
30190        */
30191       public static _Fields findByThriftId(int fieldId) {
30192         return byId.get(fieldId);
30193       }
30194 
30195       /**
30196        * Find the _Fields constant that matches fieldId, throwing an exception
30197        * if it is not found.
30198        */
30199       public static _Fields findByThriftIdOrThrow(int fieldId) {
30200         _Fields fields = findByThriftId(fieldId);
30201         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30202         return fields;
30203       }
30204 
30205       /**
30206        * Find the _Fields constant that matches name, or null if its not found.
30207        */
30208       public static _Fields findByName(String name) {
30209         return byName.get(name);
30210       }
30211 
30212       private final short _thriftId;
30213       private final String _fieldName;
30214 
30215       _Fields(short thriftId, String fieldName) {
30216         _thriftId = thriftId;
30217         _fieldName = fieldName;
30218       }
30219 
30220       public short getThriftFieldId() {
30221         return _thriftId;
30222       }
30223 
30224       public String getFieldName() {
30225         return _fieldName;
30226       }
30227     }
30228 
30229     // isset id assignments
30230 
30231     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30232       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
30233           new ListMetaData(TType.LIST,
30234               new StructMetaData(TType.STRUCT, TRowResult.class))));
30235       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
30236           new FieldValueMetaData(TType.STRUCT)));
30237       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
30238           new FieldValueMetaData(TType.STRUCT)));
30239     }});
30240 
30241     static {
30242       FieldMetaData.addStructMetaDataMap(scannerGetList_result.class, metaDataMap);
30243     }
30244 
30245     public scannerGetList_result() {
30246     }
30247 
30248     public scannerGetList_result(
30249       List<TRowResult> success,
30250       IOError io,
30251       IllegalArgument ia)
30252     {
30253       this();
30254       this.success = success;
30255       this.io = io;
30256       this.ia = ia;
30257     }
30258 
30259     /**
30260      * Performs a deep copy on <i>other</i>.
30261      */
30262     public scannerGetList_result(scannerGetList_result other) {
30263       if (other.isSetSuccess()) {
30264         List<TRowResult> __this__success = new ArrayList<TRowResult>();
30265         for (TRowResult other_element : other.success) {
30266           __this__success.add(new TRowResult(other_element));
30267         }
30268         this.success = __this__success;
30269       }
30270       if (other.isSetIo()) {
30271         this.io = new IOError(other.io);
30272       }
30273       if (other.isSetIa()) {
30274         this.ia = new IllegalArgument(other.ia);
30275       }
30276     }
30277 
30278     public scannerGetList_result deepCopy() {
30279       return new scannerGetList_result(this);
30280     }
30281 
30282     @Deprecated
30283     public scannerGetList_result clone() {
30284       return new scannerGetList_result(this);
30285     }
30286 
30287     public int getSuccessSize() {
30288       return (this.success == null) ? 0 : this.success.size();
30289     }
30290 
30291     public java.util.Iterator<TRowResult> getSuccessIterator() {
30292       return (this.success == null) ? null : this.success.iterator();
30293     }
30294 
30295     public void addToSuccess(TRowResult elem) {
30296       if (this.success == null) {
30297         this.success = new ArrayList<TRowResult>();
30298       }
30299       this.success.add(elem);
30300     }
30301 
30302     public List<TRowResult> getSuccess() {
30303       return this.success;
30304     }
30305 
30306     public scannerGetList_result setSuccess(List<TRowResult> success) {
30307       this.success = success;
30308       return this;
30309     }
30310 
30311     public void unsetSuccess() {
30312       this.success = null;
30313     }
30314 
30315     /** Returns true if field success is set (has been asigned a value) and false otherwise */
30316     public boolean isSetSuccess() {
30317       return this.success != null;
30318     }
30319 
30320     public void setSuccessIsSet(boolean value) {
30321       if (!value) {
30322         this.success = null;
30323       }
30324     }
30325 
30326     public IOError getIo() {
30327       return this.io;
30328     }
30329 
30330     public scannerGetList_result setIo(IOError io) {
30331       this.io = io;
30332       return this;
30333     }
30334 
30335     public void unsetIo() {
30336       this.io = null;
30337     }
30338 
30339     /** Returns true if field io is set (has been asigned a value) and false otherwise */
30340     public boolean isSetIo() {
30341       return this.io != null;
30342     }
30343 
30344     public void setIoIsSet(boolean value) {
30345       if (!value) {
30346         this.io = null;
30347       }
30348     }
30349 
30350     public IllegalArgument getIa() {
30351       return this.ia;
30352     }
30353 
30354     public scannerGetList_result setIa(IllegalArgument ia) {
30355       this.ia = ia;
30356       return this;
30357     }
30358 
30359     public void unsetIa() {
30360       this.ia = null;
30361     }
30362 
30363     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
30364     public boolean isSetIa() {
30365       return this.ia != null;
30366     }
30367 
30368     public void setIaIsSet(boolean value) {
30369       if (!value) {
30370         this.ia = null;
30371       }
30372     }
30373 
30374     public void setFieldValue(_Fields field, Object value) {
30375       switch (field) {
30376       case SUCCESS:
30377         if (value == null) {
30378           unsetSuccess();
30379         } else {
30380           setSuccess((List<TRowResult>)value);
30381         }
30382         break;
30383 
30384       case IO:
30385         if (value == null) {
30386           unsetIo();
30387         } else {
30388           setIo((IOError)value);
30389         }
30390         break;
30391 
30392       case IA:
30393         if (value == null) {
30394           unsetIa();
30395         } else {
30396           setIa((IllegalArgument)value);
30397         }
30398         break;
30399 
30400       }
30401     }
30402 
30403     public void setFieldValue(int fieldID, Object value) {
30404       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
30405     }
30406 
30407     public Object getFieldValue(_Fields field) {
30408       switch (field) {
30409       case SUCCESS:
30410         return getSuccess();
30411 
30412       case IO:
30413         return getIo();
30414 
30415       case IA:
30416         return getIa();
30417 
30418       }
30419       throw new IllegalStateException();
30420     }
30421 
30422     public Object getFieldValue(int fieldId) {
30423       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
30424     }
30425 
30426     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
30427     public boolean isSet(_Fields field) {
30428       switch (field) {
30429       case SUCCESS:
30430         return isSetSuccess();
30431       case IO:
30432         return isSetIo();
30433       case IA:
30434         return isSetIa();
30435       }
30436       throw new IllegalStateException();
30437     }
30438 
30439     public boolean isSet(int fieldID) {
30440       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30441     }
30442 
30443     @Override
30444     public boolean equals(Object that) {
30445       if (that == null)
30446         return false;
30447       if (that instanceof scannerGetList_result)
30448         return this.equals((scannerGetList_result)that);
30449       return false;
30450     }
30451 
30452     public boolean equals(scannerGetList_result that) {
30453       if (that == null)
30454         return false;
30455 
30456       boolean this_present_success = true && this.isSetSuccess();
30457       boolean that_present_success = true && that.isSetSuccess();
30458       if (this_present_success || that_present_success) {
30459         if (!(this_present_success && that_present_success))
30460           return false;
30461         if (!this.success.equals(that.success))
30462           return false;
30463       }
30464 
30465       boolean this_present_io = true && this.isSetIo();
30466       boolean that_present_io = true && that.isSetIo();
30467       if (this_present_io || that_present_io) {
30468         if (!(this_present_io && that_present_io))
30469           return false;
30470         if (!this.io.equals(that.io))
30471           return false;
30472       }
30473 
30474       boolean this_present_ia = true && this.isSetIa();
30475       boolean that_present_ia = true && that.isSetIa();
30476       if (this_present_ia || that_present_ia) {
30477         if (!(this_present_ia && that_present_ia))
30478           return false;
30479         if (!this.ia.equals(that.ia))
30480           return false;
30481       }
30482 
30483       return true;
30484     }
30485 
30486     @Override
30487     public int hashCode() {
30488       HashCodeBuilder builder = new HashCodeBuilder();
30489 
30490       boolean present_success = true && (isSetSuccess());
30491       builder.append(present_success);
30492       if (present_success)
30493         builder.append(success);
30494 
30495       boolean present_io = true && (isSetIo());
30496       builder.append(present_io);
30497       if (present_io)
30498         builder.append(io);
30499 
30500       boolean present_ia = true && (isSetIa());
30501       builder.append(present_ia);
30502       if (present_ia)
30503         builder.append(ia);
30504 
30505       return builder.toHashCode();
30506     }
30507 
30508     public void read(TProtocol iprot) throws TException {
30509       TField field;
30510       iprot.readStructBegin();
30511       while (true)
30512       {
30513         field = iprot.readFieldBegin();
30514         if (field.type == TType.STOP) {
30515           break;
30516         }
30517         _Fields fieldId = _Fields.findByThriftId(field.id);
30518         if (fieldId == null) {
30519           TProtocolUtil.skip(iprot, field.type);
30520         } else {
30521           switch (fieldId) {
30522             case SUCCESS:
30523               if (field.type == TType.LIST) {
30524                 {
30525                   TList _list102 = iprot.readListBegin();
30526                   this.success = new ArrayList<TRowResult>(_list102.size);
30527                   for (int _i103 = 0; _i103 < _list102.size; ++_i103)
30528                   {
30529                     TRowResult _elem104;
30530                     _elem104 = new TRowResult();
30531                     _elem104.read(iprot);
30532                     this.success.add(_elem104);
30533                   }
30534                   iprot.readListEnd();
30535                 }
30536               } else {
30537                 TProtocolUtil.skip(iprot, field.type);
30538               }
30539               break;
30540             case IO:
30541               if (field.type == TType.STRUCT) {
30542                 this.io = new IOError();
30543                 this.io.read(iprot);
30544               } else {
30545                 TProtocolUtil.skip(iprot, field.type);
30546               }
30547               break;
30548             case IA:
30549               if (field.type == TType.STRUCT) {
30550                 this.ia = new IllegalArgument();
30551                 this.ia.read(iprot);
30552               } else {
30553                 TProtocolUtil.skip(iprot, field.type);
30554               }
30555               break;
30556           }
30557           iprot.readFieldEnd();
30558         }
30559       }
30560       iprot.readStructEnd();
30561 
30562       // check for required fields of primitive type, which can't be checked in the validate method
30563       validate();
30564     }
30565 
30566     public void write(TProtocol oprot) throws TException {
30567       oprot.writeStructBegin(STRUCT_DESC);
30568 
30569       if (this.isSetSuccess()) {
30570         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30571         {
30572           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
30573           for (TRowResult _iter105 : this.success)
30574           {
30575             _iter105.write(oprot);
30576           }
30577           oprot.writeListEnd();
30578         }
30579         oprot.writeFieldEnd();
30580       } else if (this.isSetIo()) {
30581         oprot.writeFieldBegin(IO_FIELD_DESC);
30582         this.io.write(oprot);
30583         oprot.writeFieldEnd();
30584       } else if (this.isSetIa()) {
30585         oprot.writeFieldBegin(IA_FIELD_DESC);
30586         this.ia.write(oprot);
30587         oprot.writeFieldEnd();
30588       }
30589       oprot.writeFieldStop();
30590       oprot.writeStructEnd();
30591     }
30592 
30593     @Override
30594     public String toString() {
30595       StringBuilder sb = new StringBuilder("scannerGetList_result(");
30596       boolean first = true;
30597 
30598       sb.append("success:");
30599       if (this.success == null) {
30600         sb.append("null");
30601       } else {
30602         sb.append(this.success);
30603       }
30604       first = false;
30605       if (!first) sb.append(", ");
30606       sb.append("io:");
30607       if (this.io == null) {
30608         sb.append("null");
30609       } else {
30610         sb.append(this.io);
30611       }
30612       first = false;
30613       if (!first) sb.append(", ");
30614       sb.append("ia:");
30615       if (this.ia == null) {
30616         sb.append("null");
30617       } else {
30618         sb.append(this.ia);
30619       }
30620       first = false;
30621       sb.append(")");
30622       return sb.toString();
30623     }
30624 
30625     public void validate() throws TException {
30626       // check for required fields
30627     }
30628 
30629   }
30630 
30631   public static class scannerClose_args implements TBase<scannerClose_args._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_args>   {
30632     private static final TStruct STRUCT_DESC = new TStruct("scannerClose_args");
30633 
30634     private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)1);
30635 
30636     /**
30637      * id of a scanner returned by scannerOpen
30638      */
30639     public int id;
30640 
30641     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
30642     public enum _Fields implements TFieldIdEnum {
30643       /**
30644        * id of a scanner returned by scannerOpen
30645        */
30646       ID((short)1, "id");
30647 
30648       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30649       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30650 
30651       static {
30652         for (_Fields field : EnumSet.allOf(_Fields.class)) {
30653           byId.put((int)field._thriftId, field);
30654           byName.put(field.getFieldName(), field);
30655         }
30656       }
30657 
30658       /**
30659        * Find the _Fields constant that matches fieldId, or null if its not found.
30660        */
30661       public static _Fields findByThriftId(int fieldId) {
30662         return byId.get(fieldId);
30663       }
30664 
30665       /**
30666        * Find the _Fields constant that matches fieldId, throwing an exception
30667        * if it is not found.
30668        */
30669       public static _Fields findByThriftIdOrThrow(int fieldId) {
30670         _Fields fields = findByThriftId(fieldId);
30671         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30672         return fields;
30673       }
30674 
30675       /**
30676        * Find the _Fields constant that matches name, or null if its not found.
30677        */
30678       public static _Fields findByName(String name) {
30679         return byName.get(name);
30680       }
30681 
30682       private final short _thriftId;
30683       private final String _fieldName;
30684 
30685       _Fields(short thriftId, String fieldName) {
30686         _thriftId = thriftId;
30687         _fieldName = fieldName;
30688       }
30689 
30690       public short getThriftFieldId() {
30691         return _thriftId;
30692       }
30693 
30694       public String getFieldName() {
30695         return _fieldName;
30696       }
30697     }
30698 
30699     // isset id assignments
30700     private static final int __ID_ISSET_ID = 0;
30701     private BitSet __isset_bit_vector = new BitSet(1);
30702 
30703     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30704       put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
30705           new FieldValueMetaData(TType.I32)));
30706     }});
30707 
30708     static {
30709       FieldMetaData.addStructMetaDataMap(scannerClose_args.class, metaDataMap);
30710     }
30711 
30712     public scannerClose_args() {
30713     }
30714 
30715     public scannerClose_args(
30716       int id)
30717     {
30718       this();
30719       this.id = id;
30720       setIdIsSet(true);
30721     }
30722 
30723     /**
30724      * Performs a deep copy on <i>other</i>.
30725      */
30726     public scannerClose_args(scannerClose_args other) {
30727       __isset_bit_vector.clear();
30728       __isset_bit_vector.or(other.__isset_bit_vector);
30729       this.id = other.id;
30730     }
30731 
30732     public scannerClose_args deepCopy() {
30733       return new scannerClose_args(this);
30734     }
30735 
30736     @Deprecated
30737     public scannerClose_args clone() {
30738       return new scannerClose_args(this);
30739     }
30740 
30741     /**
30742      * id of a scanner returned by scannerOpen
30743      */
30744     public int getId() {
30745       return this.id;
30746     }
30747 
30748     /**
30749      * id of a scanner returned by scannerOpen
30750      */
30751     public scannerClose_args setId(int id) {
30752       this.id = id;
30753       setIdIsSet(true);
30754       return this;
30755     }
30756 
30757     public void unsetId() {
30758       __isset_bit_vector.clear(__ID_ISSET_ID);
30759     }
30760 
30761     /** Returns true if field id is set (has been asigned a value) and false otherwise */
30762     public boolean isSetId() {
30763       return __isset_bit_vector.get(__ID_ISSET_ID);
30764     }
30765 
30766     public void setIdIsSet(boolean value) {
30767       __isset_bit_vector.set(__ID_ISSET_ID, value);
30768     }
30769 
30770     public void setFieldValue(_Fields field, Object value) {
30771       switch (field) {
30772       case ID:
30773         if (value == null) {
30774           unsetId();
30775         } else {
30776           setId((Integer)value);
30777         }
30778         break;
30779 
30780       }
30781     }
30782 
30783     public void setFieldValue(int fieldID, Object value) {
30784       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
30785     }
30786 
30787     public Object getFieldValue(_Fields field) {
30788       switch (field) {
30789       case ID:
30790         return new Integer(getId());
30791 
30792       }
30793       throw new IllegalStateException();
30794     }
30795 
30796     public Object getFieldValue(int fieldId) {
30797       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
30798     }
30799 
30800     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
30801     public boolean isSet(_Fields field) {
30802       switch (field) {
30803       case ID:
30804         return isSetId();
30805       }
30806       throw new IllegalStateException();
30807     }
30808 
30809     public boolean isSet(int fieldID) {
30810       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
30811     }
30812 
30813     @Override
30814     public boolean equals(Object that) {
30815       if (that == null)
30816         return false;
30817       if (that instanceof scannerClose_args)
30818         return this.equals((scannerClose_args)that);
30819       return false;
30820     }
30821 
30822     public boolean equals(scannerClose_args that) {
30823       if (that == null)
30824         return false;
30825 
30826       boolean this_present_id = true;
30827       boolean that_present_id = true;
30828       if (this_present_id || that_present_id) {
30829         if (!(this_present_id && that_present_id))
30830           return false;
30831         if (this.id != that.id)
30832           return false;
30833       }
30834 
30835       return true;
30836     }
30837 
30838     @Override
30839     public int hashCode() {
30840       HashCodeBuilder builder = new HashCodeBuilder();
30841 
30842       boolean present_id = true;
30843       builder.append(present_id);
30844       if (present_id)
30845         builder.append(id);
30846 
30847       return builder.toHashCode();
30848     }
30849 
30850     public int compareTo(scannerClose_args other) {
30851       if (!getClass().equals(other.getClass())) {
30852         return getClass().getName().compareTo(other.getClass().getName());
30853       }
30854 
30855       int lastComparison = 0;
30856       scannerClose_args typedOther = (scannerClose_args)other;
30857 
30858       lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
30859       if (lastComparison != 0) {
30860         return lastComparison;
30861       }
30862       lastComparison = TBaseHelper.compareTo(id, typedOther.id);
30863       if (lastComparison != 0) {
30864         return lastComparison;
30865       }
30866       return 0;
30867     }
30868 
30869     public void read(TProtocol iprot) throws TException {
30870       TField field;
30871       iprot.readStructBegin();
30872       while (true)
30873       {
30874         field = iprot.readFieldBegin();
30875         if (field.type == TType.STOP) {
30876           break;
30877         }
30878         _Fields fieldId = _Fields.findByThriftId(field.id);
30879         if (fieldId == null) {
30880           TProtocolUtil.skip(iprot, field.type);
30881         } else {
30882           switch (fieldId) {
30883             case ID:
30884               if (field.type == TType.I32) {
30885                 this.id = iprot.readI32();
30886                 setIdIsSet(true);
30887               } else {
30888                 TProtocolUtil.skip(iprot, field.type);
30889               }
30890               break;
30891           }
30892           iprot.readFieldEnd();
30893         }
30894       }
30895       iprot.readStructEnd();
30896 
30897       // check for required fields of primitive type, which can't be checked in the validate method
30898       validate();
30899     }
30900 
30901     public void write(TProtocol oprot) throws TException {
30902       validate();
30903 
30904       oprot.writeStructBegin(STRUCT_DESC);
30905       oprot.writeFieldBegin(ID_FIELD_DESC);
30906       oprot.writeI32(this.id);
30907       oprot.writeFieldEnd();
30908       oprot.writeFieldStop();
30909       oprot.writeStructEnd();
30910     }
30911 
30912     @Override
30913     public String toString() {
30914       StringBuilder sb = new StringBuilder("scannerClose_args(");
30915       boolean first = true;
30916 
30917       sb.append("id:");
30918       sb.append(this.id);
30919       first = false;
30920       sb.append(")");
30921       return sb.toString();
30922     }
30923 
30924     public void validate() throws TException {
30925       // check for required fields
30926     }
30927 
30928   }
30929 
30930   public static class scannerClose_result implements TBase<scannerClose_result._Fields>, java.io.Serializable, Cloneable, Comparable<scannerClose_result>   {
30931     private static final TStruct STRUCT_DESC = new TStruct("scannerClose_result");
30932 
30933     private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
30934     private static final TField IA_FIELD_DESC = new TField("ia", TType.STRUCT, (short)2);
30935 
30936     public IOError io;
30937     public IllegalArgument ia;
30938 
30939     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
30940     public enum _Fields implements TFieldIdEnum {
30941       IO((short)1, "io"),
30942       IA((short)2, "ia");
30943 
30944       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
30945       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
30946 
30947       static {
30948         for (_Fields field : EnumSet.allOf(_Fields.class)) {
30949           byId.put((int)field._thriftId, field);
30950           byName.put(field.getFieldName(), field);
30951         }
30952       }
30953 
30954       /**
30955        * Find the _Fields constant that matches fieldId, or null if its not found.
30956        */
30957       public static _Fields findByThriftId(int fieldId) {
30958         return byId.get(fieldId);
30959       }
30960 
30961       /**
30962        * Find the _Fields constant that matches fieldId, throwing an exception
30963        * if it is not found.
30964        */
30965       public static _Fields findByThriftIdOrThrow(int fieldId) {
30966         _Fields fields = findByThriftId(fieldId);
30967         if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
30968         return fields;
30969       }
30970 
30971       /**
30972        * Find the _Fields constant that matches name, or null if its not found.
30973        */
30974       public static _Fields findByName(String name) {
30975         return byName.get(name);
30976       }
30977 
30978       private final short _thriftId;
30979       private final String _fieldName;
30980 
30981       _Fields(short thriftId, String fieldName) {
30982         _thriftId = thriftId;
30983         _fieldName = fieldName;
30984       }
30985 
30986       public short getThriftFieldId() {
30987         return _thriftId;
30988       }
30989 
30990       public String getFieldName() {
30991         return _fieldName;
30992       }
30993     }
30994 
30995     // isset id assignments
30996 
30997     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
30998       put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
30999           new FieldValueMetaData(TType.STRUCT)));
31000       put(_Fields.IA, new FieldMetaData("ia", TFieldRequirementType.DEFAULT,
31001           new FieldValueMetaData(TType.STRUCT)));
31002     }});
31003 
31004     static {
31005       FieldMetaData.addStructMetaDataMap(scannerClose_result.class, metaDataMap);
31006     }
31007 
31008     public scannerClose_result() {
31009     }
31010 
31011     public scannerClose_result(
31012       IOError io,
31013       IllegalArgument ia)
31014     {
31015       this();
31016       this.io = io;
31017       this.ia = ia;
31018     }
31019 
31020     /**
31021      * Performs a deep copy on <i>other</i>.
31022      */
31023     public scannerClose_result(scannerClose_result other) {
31024       if (other.isSetIo()) {
31025         this.io = new IOError(other.io);
31026       }
31027       if (other.isSetIa()) {
31028         this.ia = new IllegalArgument(other.ia);
31029       }
31030     }
31031 
31032     public scannerClose_result deepCopy() {
31033       return new scannerClose_result(this);
31034     }
31035 
31036     @Deprecated
31037     public scannerClose_result clone() {
31038       return new scannerClose_result(this);
31039     }
31040 
31041     public IOError getIo() {
31042       return this.io;
31043     }
31044 
31045     public scannerClose_result setIo(IOError io) {
31046       this.io = io;
31047       return this;
31048     }
31049 
31050     public void unsetIo() {
31051       this.io = null;
31052     }
31053 
31054     /** Returns true if field io is set (has been asigned a value) and false otherwise */
31055     public boolean isSetIo() {
31056       return this.io != null;
31057     }
31058 
31059     public void setIoIsSet(boolean value) {
31060       if (!value) {
31061         this.io = null;
31062       }
31063     }
31064 
31065     public IllegalArgument getIa() {
31066       return this.ia;
31067     }
31068 
31069     public scannerClose_result setIa(IllegalArgument ia) {
31070       this.ia = ia;
31071       return this;
31072     }
31073 
31074     public void unsetIa() {
31075       this.ia = null;
31076     }
31077 
31078     /** Returns true if field ia is set (has been asigned a value) and false otherwise */
31079     public boolean isSetIa() {
31080       return this.ia != null;
31081     }
31082 
31083     public void setIaIsSet(boolean value) {
31084       if (!value) {
31085         this.ia = null;
31086       }
31087     }
31088 
31089     public void setFieldValue(_Fields field, Object value) {
31090       switch (field) {
31091       case IO:
31092         if (value == null) {
31093           unsetIo();
31094         } else {
31095           setIo((IOError)value);
31096         }
31097         break;
31098 
31099       case IA:
31100         if (value == null) {
31101           unsetIa();
31102         } else {
31103           setIa((IllegalArgument)value);
31104         }
31105         break;
31106 
31107       }
31108     }
31109 
31110     public void setFieldValue(int fieldID, Object value) {
31111       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
31112     }
31113 
31114     public Object getFieldValue(_Fields field) {
31115       switch (field) {
31116       case IO:
31117         return getIo();
31118 
31119       case IA:
31120         return getIa();
31121 
31122       }
31123       throw new IllegalStateException();
31124     }
31125 
31126     public Object getFieldValue(int fieldId) {
31127       return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
31128     }
31129 
31130     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
31131     public boolean isSet(_Fields field) {
31132       switch (field) {
31133       case IO:
31134         return isSetIo();
31135       case IA:
31136         return isSetIa();
31137       }
31138       throw new IllegalStateException();
31139     }
31140 
31141     public boolean isSet(int fieldID) {
31142       return isSet(_Fields.findByThriftIdOrThrow(fieldID));
31143     }
31144 
31145     @Override
31146     public boolean equals(Object that) {
31147       if (that == null)
31148         return false;
31149       if (that instanceof scannerClose_result)
31150         return this.equals((scannerClose_result)that);
31151       return false;
31152     }
31153 
31154     public boolean equals(scannerClose_result that) {
31155       if (that == null)
31156         return false;
31157 
31158       boolean this_present_io = true && this.isSetIo();
31159       boolean that_present_io = true && that.isSetIo();
31160       if (this_present_io || that_present_io) {
31161         if (!(this_present_io && that_present_io))
31162           return false;
31163         if (!this.io.equals(that.io))
31164           return false;
31165       }
31166 
31167       boolean this_present_ia = true && this.isSetIa();
31168       boolean that_present_ia = true && that.isSetIa();
31169       if (this_present_ia || that_present_ia) {
31170         if (!(this_present_ia && that_present_ia))
31171           return false;
31172         if (!this.ia.equals(that.ia))
31173           return false;
31174       }
31175 
31176       return true;
31177     }
31178 
31179     @Override
31180     public int hashCode() {
31181       HashCodeBuilder builder = new HashCodeBuilder();
31182 
31183       boolean present_io = true && (isSetIo());
31184       builder.append(present_io);
31185       if (present_io)
31186         builder.append(io);
31187 
31188       boolean present_ia = true && (isSetIa());
31189       builder.append(present_ia);
31190       if (present_ia)
31191         builder.append(ia);
31192 
31193       return builder.toHashCode();
31194     }
31195 
31196     public int compareTo(scannerClose_result other) {
31197       if (!getClass().equals(other.getClass())) {
31198         return getClass().getName().compareTo(other.getClass().getName());
31199       }
31200 
31201       int lastComparison = 0;
31202       scannerClose_result typedOther = (scannerClose_result)other;
31203 
31204       lastComparison = Boolean.valueOf(isSetIo()).compareTo(isSetIo());
31205       if (lastComparison != 0) {
31206         return lastComparison;
31207       }
31208       lastComparison = TBaseHelper.compareTo(io, typedOther.io);
31209       if (lastComparison != 0) {
31210         return lastComparison;
31211       }
31212       lastComparison = Boolean.valueOf(isSetIa()).compareTo(isSetIa());
31213       if (lastComparison != 0) {
31214         return lastComparison;
31215       }
31216       lastComparison = TBaseHelper.compareTo(ia, typedOther.ia);
31217       if (lastComparison != 0) {
31218         return lastComparison;
31219       }
31220       return 0;
31221     }
31222 
31223     public void read(TProtocol iprot) throws TException {
31224       TField field;
31225       iprot.readStructBegin();
31226       while (true)
31227       {
31228         field = iprot.readFieldBegin();
31229         if (field.type == TType.STOP) {
31230           break;
31231         }
31232         _Fields fieldId = _Fields.findByThriftId(field.id);
31233         if (fieldId == null) {
31234           TProtocolUtil.skip(iprot, field.type);
31235         } else {
31236           switch (fieldId) {
31237             case IO:
31238               if (field.type == TType.STRUCT) {
31239                 this.io = new IOError();
31240                 this.io.read(iprot);
31241               } else {
31242                 TProtocolUtil.skip(iprot, field.type);
31243               }
31244               break;
31245             case IA:
31246               if (field.type == TType.STRUCT) {
31247                 this.ia = new IllegalArgument();
31248                 this.ia.read(iprot);
31249               } else {
31250                 TProtocolUtil.skip(iprot, field.type);
31251               }
31252               break;
31253           }
31254           iprot.readFieldEnd();
31255         }
31256       }
31257       iprot.readStructEnd();
31258 
31259       // check for required fields of primitive type, which can't be checked in the validate method
31260       validate();
31261     }
31262 
31263     public void write(TProtocol oprot) throws TException {
31264       oprot.writeStructBegin(STRUCT_DESC);
31265 
31266       if (this.isSetIo()) {
31267         oprot.writeFieldBegin(IO_FIELD_DESC);
31268         this.io.write(oprot);
31269         oprot.writeFieldEnd();
31270       } else if (this.isSetIa()) {
31271         oprot.writeFieldBegin(IA_FIELD_DESC);
31272         this.ia.write(oprot);
31273         oprot.writeFieldEnd();
31274       }
31275       oprot.writeFieldStop();
31276       oprot.writeStructEnd();
31277     }
31278 
31279     @Override
31280     public String toString() {
31281       StringBuilder sb = new StringBuilder("scannerClose_result(");
31282       boolean first = true;
31283 
31284       sb.append("io:");
31285       if (this.io == null) {
31286         sb.append("null");
31287       } else {
31288         sb.append(this.io);
31289       }
31290       first = false;
31291       if (!first) sb.append(", ");
31292       sb.append("ia:");
31293       if (this.ia == null) {
31294         sb.append("null");
31295       } else {
31296         sb.append(this.ia);
31297       }
31298       first = false;
31299       sb.append(")");
31300       return sb.toString();
31301     }
31302 
31303     public void validate() throws TException {
31304       // check for required fields
31305     }
31306 
31307   }
31308 
31309 }