hbase-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From raw...@apache.org
Subject svn commit: r1078228 [2/3] - in /hbase/trunk: ./ src/main/java/org/apache/hadoop/hbase/thrift/ src/main/java/org/apache/hadoop/hbase/thrift/generated/ src/main/java/org/apache/hadoop/hbase/util/ src/test/java/org/apache/hadoop/hbase/thrift/
Date Sat, 05 Mar 2011 01:34:24 GMT
Modified: hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java
URL: http://svn.apache.org/viewvc/hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java?rev=1078228&r1=1078227&r2=1078228&view=diff
==============================================================================
--- hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java (original)
+++ hbase/trunk/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java Sat Mar  5 01:34:24 2011
@@ -17,7 +17,6 @@
  */
 package org.apache.hadoop.hbase.thrift.generated;
 
-import org.apache.commons.lang.builder.HashCodeBuilder;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.Map;
@@ -28,12 +27,15 @@ import java.util.HashSet;
 import java.util.EnumSet;
 import java.util.Collections;
 import java.util.BitSet;
+import java.nio.ByteBuffer;
 import java.util.Arrays;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import org.apache.thrift.*;
+import org.apache.thrift.async.*;
 import org.apache.thrift.meta_data.*;
+import org.apache.thrift.transport.*;
 import org.apache.thrift.protocol.*;
 
 public class Hbase {
@@ -45,7 +47,7 @@ public class Hbase {
      *
      * @param tableName name of the table
      */
-    public void enableTable(byte[] tableName) throws IOError, TException;
+    public void enableTable(ByteBuffer tableName) throws IOError, TException;
 
     /**
      * Disables a table (takes it off-line) If it is being served, the master
@@ -53,25 +55,25 @@ public class Hbase {
      *
      * @param tableName name of the table
      */
-    public void disableTable(byte[] tableName) throws IOError, TException;
+    public void disableTable(ByteBuffer tableName) throws IOError, TException;
 
     /**
      * @return true if table is on-line
      *
      * @param tableName name of the table to check
      */
-    public boolean isTableEnabled(byte[] tableName) throws IOError, TException;
+    public boolean isTableEnabled(ByteBuffer tableName) throws IOError, TException;
 
-    public void compact(byte[] tableNameOrRegionName) throws IOError, TException;
+    public void compact(ByteBuffer tableNameOrRegionName) throws IOError, TException;
 
-    public void majorCompact(byte[] tableNameOrRegionName) throws IOError, TException;
+    public void majorCompact(ByteBuffer tableNameOrRegionName) throws IOError, TException;
 
     /**
      * List all the userspace tables.
      *
      * @return returns a list of names
      */
-    public List<byte[]> getTableNames() throws IOError, TException;
+    public List<ByteBuffer> getTableNames() throws IOError, TException;
 
     /**
      * List all the column families assoicated with a table.
@@ -80,7 +82,7 @@ public class Hbase {
      *
      * @param tableName table name
      */
-    public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException;
+    public Map<ByteBuffer,ColumnDescriptor> getColumnDescriptors(ByteBuffer tableName) throws IOError, TException;
 
     /**
      * List the regions associated with a table.
@@ -89,7 +91,7 @@ public class Hbase {
      *
      * @param tableName table name
      */
-    public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException;
+    public List<TRegionInfo> getTableRegions(ByteBuffer tableName) throws IOError, TException;
 
     /**
      * Create a table with the specified column families.  The name
@@ -105,7 +107,7 @@ public class Hbase {
      *
      * @param columnFamilies list of column family descriptors
      */
-    public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException;
+    public void createTable(ByteBuffer tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException;
 
     /**
      * Deletes a table
@@ -115,7 +117,7 @@ public class Hbase {
      *
      * @param tableName name of table to delete
      */
-    public void deleteTable(byte[] tableName) throws IOError, TException;
+    public void deleteTable(ByteBuffer tableName) throws IOError, TException;
 
     /**
      * Get a single TCell for the specified table, row, and column at the
@@ -129,7 +131,7 @@ public class Hbase {
      *
      * @param column column name
      */
-    public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
+    public List<TCell> get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, TException;
 
     /**
      * Get the specified number of versions for the specified table,
@@ -145,7 +147,7 @@ public class Hbase {
      *
      * @param numVersions number of versions to retrieve
      */
-    public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException;
+    public List<TCell> getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions) throws IOError, TException;
 
     /**
      * Get the specified number of versions for the specified table,
@@ -164,7 +166,7 @@ public class Hbase {
      *
      * @param numVersions number of versions to retrieve
      */
-    public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException;
+    public List<TCell> getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions) throws IOError, TException;
 
     /**
      * Get all the data for the specified table and row at the latest
@@ -176,7 +178,7 @@ public class Hbase {
      *
      * @param row row key
      */
-    public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException;
+    public List<TRowResult> getRow(ByteBuffer tableName, ByteBuffer row) throws IOError, TException;
 
     /**
      * Get the specified columns for the specified table and row at the latest
@@ -190,7 +192,7 @@ public class Hbase {
      *
      * @param columns List of columns to return, null for all columns
      */
-    public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException;
+    public List<TRowResult> getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List<ByteBuffer> columns) throws IOError, TException;
 
     /**
      * Get all the data for the specified table and row at the specified
@@ -204,7 +206,7 @@ public class Hbase {
      *
      * @param timestamp timestamp
      */
-    public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
+    public List<TRowResult> getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, TException;
 
     /**
      * Get the specified columns for the specified table and row at the specified
@@ -220,7 +222,7 @@ public class Hbase {
      *
      * @param timestamp
      */
-    public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException;
+    public List<TRowResult> getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List<ByteBuffer> columns, long timestamp) throws IOError, TException;
 
     /**
      * Get all the data for the specified table and rows at the latest
@@ -232,7 +234,7 @@ public class Hbase {
      *
      * @param rows row keys
      */
-    public List<TRowResult> getRows(byte[] tableName, List<byte[]> rows) throws IOError, TException;
+    public List<TRowResult> getRows(ByteBuffer tableName, List<ByteBuffer> rows) throws IOError, TException;
 
     /**
      * Get the specified columns for the specified table and rows at the latest
@@ -246,7 +248,7 @@ public class Hbase {
      *
      * @param columns List of columns to return, null for all columns
      */
-    public List<TRowResult> getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns) throws IOError, TException;
+    public List<TRowResult> getRowsWithColumns(ByteBuffer tableName, List<ByteBuffer> rows, List<ByteBuffer> columns) throws IOError, TException;
 
     /**
      * Get all the data for the specified table and rows at the specified
@@ -260,7 +262,7 @@ public class Hbase {
      *
      * @param timestamp timestamp
      */
-    public List<TRowResult> getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws IOError, TException;
+    public List<TRowResult> getRowsTs(ByteBuffer tableName, List<ByteBuffer> rows, long timestamp) throws IOError, TException;
 
     /**
      * Get the specified columns for the specified table and rows at the specified
@@ -276,7 +278,7 @@ public class Hbase {
      *
      * @param timestamp
      */
-    public List<TRowResult> getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp) throws IOError, TException;
+    public List<TRowResult> getRowsWithColumnsTs(ByteBuffer tableName, List<ByteBuffer> rows, List<ByteBuffer> columns, long timestamp) throws IOError, TException;
 
     /**
      * Apply a series of mutations (updates/deletes) to a row in a
@@ -290,7 +292,7 @@ public class Hbase {
      *
      * @param mutations list of mutation commands
      */
-    public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException;
+    public void mutateRow(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations) throws IOError, IllegalArgument, TException;
 
     /**
      * Apply a series of mutations (updates/deletes) to a row in a
@@ -306,7 +308,7 @@ public class Hbase {
      *
      * @param timestamp timestamp
      */
-    public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException;
+    public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException;
 
     /**
      * Apply a series of batches (each a series of mutations on a single row)
@@ -318,7 +320,7 @@ public class Hbase {
      *
      * @param rowBatches list of row batches
      */
-    public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException;
+    public void mutateRows(ByteBuffer tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException;
 
     /**
      * Apply a series of batches (each a series of mutations on a single row)
@@ -332,7 +334,7 @@ public class Hbase {
      *
      * @param timestamp timestamp
      */
-    public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException;
+    public void mutateRowsTs(ByteBuffer tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException;
 
     /**
      * Atomically increment the column value specified.  Returns the next value post increment.
@@ -345,7 +347,7 @@ public class Hbase {
      *
      * @param value amount to increment by
      */
-    public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException;
+    public long atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value) throws IOError, IllegalArgument, TException;
 
     /**
      * Delete all cells that match the passed row and column.
@@ -356,7 +358,7 @@ public class Hbase {
      *
      * @param column name of column whose value is to be deleted
      */
-    public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException;
+    public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, TException;
 
     /**
      * Delete all cells that match the passed row and column and whose
@@ -370,7 +372,7 @@ public class Hbase {
      *
      * @param timestamp timestamp
      */
-    public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException;
+    public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp) throws IOError, TException;
 
     /**
      * Completely delete the row's cells.
@@ -379,7 +381,7 @@ public class Hbase {
      *
      * @param row key of the row to be completely deleted.
      */
-    public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException;
+    public void deleteAllRow(ByteBuffer tableName, ByteBuffer row) throws IOError, TException;
 
     /**
      * Completely delete the row's cells marked with a timestamp
@@ -391,7 +393,7 @@ public class Hbase {
      *
      * @param timestamp timestamp
      */
-    public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException;
+    public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, TException;
 
     /**
      * Get a scanner on the current table starting at the specified row and
@@ -408,7 +410,7 @@ public class Hbase {
      * columns of the specified column family are returned. It's also possible
      * to pass a regex in the column qualifier.
      */
-    public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException;
+    public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns) throws IOError, TException;
 
     /**
      * Get a scanner on the current table starting and stopping at the
@@ -429,7 +431,7 @@ public class Hbase {
      * columns of the specified column family are returned. It's also possible
      * to pass a regex in the column qualifier.
      */
-    public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException;
+    public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List<ByteBuffer> columns) throws IOError, TException;
 
     /**
      * Open a scanner for a given prefix.  That is all rows will have the specified
@@ -443,7 +445,7 @@ public class Hbase {
      *
      * @param columns the columns you want returned
      */
-    public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException;
+    public int scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List<ByteBuffer> columns) throws IOError, TException;
 
     /**
      * Get a scanner on the current table starting at the specified row and
@@ -463,7 +465,7 @@ public class Hbase {
      *
      * @param timestamp timestamp
      */
-    public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException;
+    public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns, long timestamp) throws IOError, TException;
 
     /**
      * Get a scanner on the current table starting and stopping at the
@@ -487,7 +489,7 @@ public class Hbase {
      *
      * @param timestamp timestamp
      */
-    public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException;
+    public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List<ByteBuffer> columns, long timestamp) throws IOError, TException;
 
     /**
      * Returns the scanner's current row value and advances to the next
@@ -534,7 +536,97 @@ public class Hbase {
 
   }
 
-  public static class Client implements Iface {
+  public interface AsyncIface {
+
+    public void enableTable(ByteBuffer tableName, AsyncMethodCallback<AsyncClient.enableTable_call> resultHandler) throws TException;
+
+    public void disableTable(ByteBuffer tableName, AsyncMethodCallback<AsyncClient.disableTable_call> resultHandler) throws TException;
+
+    public void isTableEnabled(ByteBuffer tableName, AsyncMethodCallback<AsyncClient.isTableEnabled_call> resultHandler) throws TException;
+
+    public void compact(ByteBuffer tableNameOrRegionName, AsyncMethodCallback<AsyncClient.compact_call> resultHandler) throws TException;
+
+    public void majorCompact(ByteBuffer tableNameOrRegionName, AsyncMethodCallback<AsyncClient.majorCompact_call> resultHandler) throws TException;
+
+    public void getTableNames(AsyncMethodCallback<AsyncClient.getTableNames_call> resultHandler) throws TException;
+
+    public void getColumnDescriptors(ByteBuffer tableName, AsyncMethodCallback<AsyncClient.getColumnDescriptors_call> resultHandler) throws TException;
+
+    public void getTableRegions(ByteBuffer tableName, AsyncMethodCallback<AsyncClient.getTableRegions_call> resultHandler) throws TException;
+
+    public void createTable(ByteBuffer tableName, List<ColumnDescriptor> columnFamilies, AsyncMethodCallback<AsyncClient.createTable_call> resultHandler) throws TException;
+
+    public void deleteTable(ByteBuffer tableName, AsyncMethodCallback<AsyncClient.deleteTable_call> resultHandler) throws TException;
+
+    public void get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, AsyncMethodCallback<AsyncClient.get_call> resultHandler) throws TException;
+
+    public void getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions, AsyncMethodCallback<AsyncClient.getVer_call> resultHandler) throws TException;
+
+    public void getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions, AsyncMethodCallback<AsyncClient.getVerTs_call> resultHandler) throws TException;
+
+    public void getRow(ByteBuffer tableName, ByteBuffer row, AsyncMethodCallback<AsyncClient.getRow_call> resultHandler) throws TException;
+
+    public void getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List<ByteBuffer> columns, AsyncMethodCallback<AsyncClient.getRowWithColumns_call> resultHandler) throws TException;
+
+    public void getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, AsyncMethodCallback<AsyncClient.getRowTs_call> resultHandler) throws TException;
+
+    public void getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List<ByteBuffer> columns, long timestamp, AsyncMethodCallback<AsyncClient.getRowWithColumnsTs_call> resultHandler) throws TException;
+
+    public void getRows(ByteBuffer tableName, List<ByteBuffer> rows, AsyncMethodCallback<AsyncClient.getRows_call> resultHandler) throws TException;
+
+    public void getRowsWithColumns(ByteBuffer tableName, List<ByteBuffer> rows, List<ByteBuffer> columns, AsyncMethodCallback<AsyncClient.getRowsWithColumns_call> resultHandler) throws TException;
+
+    public void getRowsTs(ByteBuffer tableName, List<ByteBuffer> rows, long timestamp, AsyncMethodCallback<AsyncClient.getRowsTs_call> resultHandler) throws TException;
+
+    public void getRowsWithColumnsTs(ByteBuffer tableName, List<ByteBuffer> rows, List<ByteBuffer> columns, long timestamp, AsyncMethodCallback<AsyncClient.getRowsWithColumnsTs_call> resultHandler) throws TException;
+
+    public void mutateRow(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations, AsyncMethodCallback<AsyncClient.mutateRow_call> resultHandler) throws TException;
+
+    public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations, long timestamp, AsyncMethodCallback<AsyncClient.mutateRowTs_call> resultHandler) throws TException;
+
+    public void mutateRows(ByteBuffer tableName, List<BatchMutation> rowBatches, AsyncMethodCallback<AsyncClient.mutateRows_call> resultHandler) throws TException;
+
+    public void mutateRowsTs(ByteBuffer tableName, List<BatchMutation> rowBatches, long timestamp, AsyncMethodCallback<AsyncClient.mutateRowsTs_call> resultHandler) throws TException;
+
+    public void atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value, AsyncMethodCallback<AsyncClient.atomicIncrement_call> resultHandler) throws TException;
+
+    public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, AsyncMethodCallback<AsyncClient.deleteAll_call> resultHandler) throws TException;
+
+    public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, AsyncMethodCallback<AsyncClient.deleteAllTs_call> resultHandler) throws TException;
+
+    public void deleteAllRow(ByteBuffer tableName, ByteBuffer row, AsyncMethodCallback<AsyncClient.deleteAllRow_call> resultHandler) throws TException;
+
+    public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, AsyncMethodCallback<AsyncClient.deleteAllRowTs_call> resultHandler) throws TException;
+
+    public void scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns, AsyncMethodCallback<AsyncClient.scannerOpen_call> resultHandler) throws TException;
+
+    public void scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List<ByteBuffer> columns, AsyncMethodCallback<AsyncClient.scannerOpenWithStop_call> resultHandler) throws TException;
+
+    public void scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List<ByteBuffer> columns, AsyncMethodCallback<AsyncClient.scannerOpenWithPrefix_call> resultHandler) throws TException;
+
+    public void scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns, long timestamp, AsyncMethodCallback<AsyncClient.scannerOpenTs_call> resultHandler) throws TException;
+
+    public void scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List<ByteBuffer> columns, long timestamp, AsyncMethodCallback<AsyncClient.scannerOpenWithStopTs_call> resultHandler) throws TException;
+
+    public void scannerGet(int id, AsyncMethodCallback<AsyncClient.scannerGet_call> resultHandler) throws TException;
+
+    public void scannerGetList(int id, int nbRows, AsyncMethodCallback<AsyncClient.scannerGetList_call> resultHandler) throws TException;
+
+    public void scannerClose(int id, AsyncMethodCallback<AsyncClient.scannerClose_call> resultHandler) throws TException;
+
+  }
+
+  public static class Client implements TServiceClient, Iface {
+    public static class Factory implements TServiceClientFactory<Client> {
+      public Factory() {}
+      public Client getClient(TProtocol prot) {
+        return new Client(prot);
+      }
+      public Client getClient(TProtocol iprot, TProtocol oprot) {
+        return new Client(iprot, oprot);
+      }
+    }
+
     public Client(TProtocol prot)
     {
       this(prot, prot);
@@ -561,17 +653,17 @@ public class Hbase {
       return this.oprot_;
     }
 
-    public void enableTable(byte[] tableName) throws IOError, TException
+    public void enableTable(ByteBuffer tableName) throws IOError, TException
     {
       send_enableTable(tableName);
       recv_enableTable();
     }
 
-    public void send_enableTable(byte[] tableName) throws TException
+    public void send_enableTable(ByteBuffer tableName) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("enableTable", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("enableTable", TMessageType.CALL, ++seqid_));
       enableTable_args args = new enableTable_args();
-      args.tableName = tableName;
+      args.setTableName(tableName);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -585,6 +677,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "enableTable failed: out of sequence response");
+      }
       enableTable_result result = new enableTable_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -594,17 +689,17 @@ public class Hbase {
       return;
     }
 
-    public void disableTable(byte[] tableName) throws IOError, TException
+    public void disableTable(ByteBuffer tableName) throws IOError, TException
     {
       send_disableTable(tableName);
       recv_disableTable();
     }
 
-    public void send_disableTable(byte[] tableName) throws TException
+    public void send_disableTable(ByteBuffer tableName) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("disableTable", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("disableTable", TMessageType.CALL, ++seqid_));
       disableTable_args args = new disableTable_args();
-      args.tableName = tableName;
+      args.setTableName(tableName);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -618,6 +713,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "disableTable failed: out of sequence response");
+      }
       disableTable_result result = new disableTable_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -627,17 +725,17 @@ public class Hbase {
       return;
     }
 
-    public boolean isTableEnabled(byte[] tableName) throws IOError, TException
+    public boolean isTableEnabled(ByteBuffer tableName) throws IOError, TException
     {
       send_isTableEnabled(tableName);
       return recv_isTableEnabled();
     }
 
-    public void send_isTableEnabled(byte[] tableName) throws TException
+    public void send_isTableEnabled(ByteBuffer tableName) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("isTableEnabled", TMessageType.CALL, ++seqid_));
       isTableEnabled_args args = new isTableEnabled_args();
-      args.tableName = tableName;
+      args.setTableName(tableName);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -651,6 +749,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "isTableEnabled failed: out of sequence response");
+      }
       isTableEnabled_result result = new isTableEnabled_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -663,17 +764,17 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result");
     }
 
-    public void compact(byte[] tableNameOrRegionName) throws IOError, TException
+    public void compact(ByteBuffer tableNameOrRegionName) throws IOError, TException
     {
       send_compact(tableNameOrRegionName);
       recv_compact();
     }
 
-    public void send_compact(byte[] tableNameOrRegionName) throws TException
+    public void send_compact(ByteBuffer tableNameOrRegionName) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("compact", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("compact", TMessageType.CALL, ++seqid_));
       compact_args args = new compact_args();
-      args.tableNameOrRegionName = tableNameOrRegionName;
+      args.setTableNameOrRegionName(tableNameOrRegionName);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -687,6 +788,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "compact failed: out of sequence response");
+      }
       compact_result result = new compact_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -696,17 +800,17 @@ public class Hbase {
       return;
     }
 
-    public void majorCompact(byte[] tableNameOrRegionName) throws IOError, TException
+    public void majorCompact(ByteBuffer tableNameOrRegionName) throws IOError, TException
     {
       send_majorCompact(tableNameOrRegionName);
       recv_majorCompact();
     }
 
-    public void send_majorCompact(byte[] tableNameOrRegionName) throws TException
+    public void send_majorCompact(ByteBuffer tableNameOrRegionName) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("majorCompact", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("majorCompact", TMessageType.CALL, ++seqid_));
       majorCompact_args args = new majorCompact_args();
-      args.tableNameOrRegionName = tableNameOrRegionName;
+      args.setTableNameOrRegionName(tableNameOrRegionName);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -720,6 +824,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "majorCompact failed: out of sequence response");
+      }
       majorCompact_result result = new majorCompact_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -729,7 +836,7 @@ public class Hbase {
       return;
     }
 
-    public List<byte[]> getTableNames() throws IOError, TException
+    public List<ByteBuffer> getTableNames() throws IOError, TException
     {
       send_getTableNames();
       return recv_getTableNames();
@@ -737,14 +844,14 @@ public class Hbase {
 
     public void send_getTableNames() throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getTableNames", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getTableNames", TMessageType.CALL, ++seqid_));
       getTableNames_args args = new getTableNames_args();
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
     }
 
-    public List<byte[]> recv_getTableNames() throws IOError, TException
+    public List<ByteBuffer> recv_getTableNames() throws IOError, TException
     {
       TMessage msg = iprot_.readMessageBegin();
       if (msg.type == TMessageType.EXCEPTION) {
@@ -752,6 +859,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getTableNames failed: out of sequence response");
+      }
       getTableNames_result result = new getTableNames_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -764,23 +874,23 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result");
     }
 
-    public Map<byte[],ColumnDescriptor> getColumnDescriptors(byte[] tableName) throws IOError, TException
+    public Map<ByteBuffer,ColumnDescriptor> getColumnDescriptors(ByteBuffer tableName) throws IOError, TException
     {
       send_getColumnDescriptors(tableName);
       return recv_getColumnDescriptors();
     }
 
-    public void send_getColumnDescriptors(byte[] tableName) throws TException
+    public void send_getColumnDescriptors(ByteBuffer tableName) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getColumnDescriptors", TMessageType.CALL, ++seqid_));
       getColumnDescriptors_args args = new getColumnDescriptors_args();
-      args.tableName = tableName;
+      args.setTableName(tableName);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
     }
 
-    public Map<byte[],ColumnDescriptor> recv_getColumnDescriptors() throws IOError, TException
+    public Map<ByteBuffer,ColumnDescriptor> recv_getColumnDescriptors() throws IOError, TException
     {
       TMessage msg = iprot_.readMessageBegin();
       if (msg.type == TMessageType.EXCEPTION) {
@@ -788,6 +898,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getColumnDescriptors failed: out of sequence response");
+      }
       getColumnDescriptors_result result = new getColumnDescriptors_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -800,17 +913,17 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result");
     }
 
-    public List<TRegionInfo> getTableRegions(byte[] tableName) throws IOError, TException
+    public List<TRegionInfo> getTableRegions(ByteBuffer tableName) throws IOError, TException
     {
       send_getTableRegions(tableName);
       return recv_getTableRegions();
     }
 
-    public void send_getTableRegions(byte[] tableName) throws TException
+    public void send_getTableRegions(ByteBuffer tableName) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getTableRegions", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getTableRegions", TMessageType.CALL, ++seqid_));
       getTableRegions_args args = new getTableRegions_args();
-      args.tableName = tableName;
+      args.setTableName(tableName);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -824,6 +937,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getTableRegions failed: out of sequence response");
+      }
       getTableRegions_result result = new getTableRegions_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -836,18 +952,18 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result");
     }
 
-    public void createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException
+    public void createTable(ByteBuffer tableName, List<ColumnDescriptor> columnFamilies) throws IOError, IllegalArgument, AlreadyExists, TException
     {
       send_createTable(tableName, columnFamilies);
       recv_createTable();
     }
 
-    public void send_createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies) throws TException
+    public void send_createTable(ByteBuffer tableName, List<ColumnDescriptor> columnFamilies) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("createTable", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("createTable", TMessageType.CALL, ++seqid_));
       createTable_args args = new createTable_args();
-      args.tableName = tableName;
-      args.columnFamilies = columnFamilies;
+      args.setTableName(tableName);
+      args.setColumnFamilies(columnFamilies);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -861,6 +977,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "createTable failed: out of sequence response");
+      }
       createTable_result result = new createTable_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -876,17 +995,17 @@ public class Hbase {
       return;
     }
 
-    public void deleteTable(byte[] tableName) throws IOError, TException
+    public void deleteTable(ByteBuffer tableName) throws IOError, TException
     {
       send_deleteTable(tableName);
       recv_deleteTable();
     }
 
-    public void send_deleteTable(byte[] tableName) throws TException
+    public void send_deleteTable(ByteBuffer tableName) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("deleteTable", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("deleteTable", TMessageType.CALL, ++seqid_));
       deleteTable_args args = new deleteTable_args();
-      args.tableName = tableName;
+      args.setTableName(tableName);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -900,6 +1019,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteTable failed: out of sequence response");
+      }
       deleteTable_result result = new deleteTable_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -909,19 +1031,19 @@ public class Hbase {
       return;
     }
 
-    public List<TCell> get(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
+    public List<TCell> get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, TException
     {
       send_get(tableName, row, column);
       return recv_get();
     }
 
-    public void send_get(byte[] tableName, byte[] row, byte[] column) throws TException
+    public void send_get(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("get", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("get", TMessageType.CALL, ++seqid_));
       get_args args = new get_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.column = column;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setColumn(column);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -935,6 +1057,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "get failed: out of sequence response");
+      }
       get_result result = new get_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -947,20 +1072,20 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result");
     }
 
-    public List<TCell> getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws IOError, TException
+    public List<TCell> getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions) throws IOError, TException
     {
       send_getVer(tableName, row, column, numVersions);
       return recv_getVer();
     }
 
-    public void send_getVer(byte[] tableName, byte[] row, byte[] column, int numVersions) throws TException
+    public void send_getVer(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, int numVersions) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getVer", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getVer", TMessageType.CALL, ++seqid_));
       getVer_args args = new getVer_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.column = column;
-      args.numVersions = numVersions;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setColumn(column);
+      args.setNumVersions(numVersions);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -974,6 +1099,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getVer failed: out of sequence response");
+      }
       getVer_result result = new getVer_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -986,21 +1114,21 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVer failed: unknown result");
     }
 
-    public List<TCell> getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws IOError, TException
+    public List<TCell> getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions) throws IOError, TException
     {
       send_getVerTs(tableName, row, column, timestamp, numVersions);
       return recv_getVerTs();
     }
 
-    public void send_getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions) throws TException
+    public void send_getVerTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp, int numVersions) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getVerTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getVerTs", TMessageType.CALL, ++seqid_));
       getVerTs_args args = new getVerTs_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.column = column;
-      args.timestamp = timestamp;
-      args.numVersions = numVersions;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setColumn(column);
+      args.setTimestamp(timestamp);
+      args.setNumVersions(numVersions);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1014,6 +1142,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getVerTs failed: out of sequence response");
+      }
       getVerTs_result result = new getVerTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1026,18 +1157,18 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result");
     }
 
-    public List<TRowResult> getRow(byte[] tableName, byte[] row) throws IOError, TException
+    public List<TRowResult> getRow(ByteBuffer tableName, ByteBuffer row) throws IOError, TException
     {
       send_getRow(tableName, row);
       return recv_getRow();
     }
 
-    public void send_getRow(byte[] tableName, byte[] row) throws TException
+    public void send_getRow(ByteBuffer tableName, ByteBuffer row) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getRow", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getRow", TMessageType.CALL, ++seqid_));
       getRow_args args = new getRow_args();
-      args.tableName = tableName;
-      args.row = row;
+      args.setTableName(tableName);
+      args.setRow(row);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1051,6 +1182,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRow failed: out of sequence response");
+      }
       getRow_result result = new getRow_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1063,19 +1197,19 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRow failed: unknown result");
     }
 
-    public List<TRowResult> getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws IOError, TException
+    public List<TRowResult> getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List<ByteBuffer> columns) throws IOError, TException
     {
       send_getRowWithColumns(tableName, row, columns);
       return recv_getRowWithColumns();
     }
 
-    public void send_getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns) throws TException
+    public void send_getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List<ByteBuffer> columns) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getRowWithColumns", TMessageType.CALL, ++seqid_));
       getRowWithColumns_args args = new getRowWithColumns_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.columns = columns;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setColumns(columns);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1089,6 +1223,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowWithColumns failed: out of sequence response");
+      }
       getRowWithColumns_result result = new getRowWithColumns_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1101,19 +1238,19 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result");
     }
 
-    public List<TRowResult> getRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
+    public List<TRowResult> getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, TException
     {
       send_getRowTs(tableName, row, timestamp);
       return recv_getRowTs();
     }
 
-    public void send_getRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
+    public void send_getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getRowTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getRowTs", TMessageType.CALL, ++seqid_));
       getRowTs_args args = new getRowTs_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1127,6 +1264,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowTs failed: out of sequence response");
+      }
       getRowTs_result result = new getRowTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1139,20 +1279,20 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result");
     }
 
-    public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException
+    public List<TRowResult> getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List<ByteBuffer> columns, long timestamp) throws IOError, TException
     {
       send_getRowWithColumnsTs(tableName, row, columns, timestamp);
       return recv_getRowWithColumnsTs();
     }
 
-    public void send_getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws TException
+    public void send_getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List<ByteBuffer> columns, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getRowWithColumnsTs", TMessageType.CALL, ++seqid_));
       getRowWithColumnsTs_args args = new getRowWithColumnsTs_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.columns = columns;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setColumns(columns);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1166,6 +1306,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowWithColumnsTs failed: out of sequence response");
+      }
       getRowWithColumnsTs_result result = new getRowWithColumnsTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1178,18 +1321,18 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
     }
 
-    public List<TRowResult> getRows(byte[] tableName, List<byte[]> rows) throws IOError, TException
+    public List<TRowResult> getRows(ByteBuffer tableName, List<ByteBuffer> rows) throws IOError, TException
     {
       send_getRows(tableName, rows);
       return recv_getRows();
     }
 
-    public void send_getRows(byte[] tableName, List<byte[]> rows) throws TException
+    public void send_getRows(ByteBuffer tableName, List<ByteBuffer> rows) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getRows", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getRows", TMessageType.CALL, ++seqid_));
       getRows_args args = new getRows_args();
-      args.tableName = tableName;
-      args.rows = rows;
+      args.setTableName(tableName);
+      args.setRows(rows);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1203,6 +1346,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRows failed: out of sequence response");
+      }
       getRows_result result = new getRows_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1215,19 +1361,19 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRows failed: unknown result");
     }
 
-    public List<TRowResult> getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns) throws IOError, TException
+    public List<TRowResult> getRowsWithColumns(ByteBuffer tableName, List<ByteBuffer> rows, List<ByteBuffer> columns) throws IOError, TException
     {
       send_getRowsWithColumns(tableName, rows, columns);
       return recv_getRowsWithColumns();
     }
 
-    public void send_getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns) throws TException
+    public void send_getRowsWithColumns(ByteBuffer tableName, List<ByteBuffer> rows, List<ByteBuffer> columns) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.CALL, ++seqid_));
       getRowsWithColumns_args args = new getRowsWithColumns_args();
-      args.tableName = tableName;
-      args.rows = rows;
-      args.columns = columns;
+      args.setTableName(tableName);
+      args.setRows(rows);
+      args.setColumns(columns);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1241,6 +1387,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowsWithColumns failed: out of sequence response");
+      }
       getRowsWithColumns_result result = new getRowsWithColumns_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1253,19 +1402,19 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumns failed: unknown result");
     }
 
-    public List<TRowResult> getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws IOError, TException
+    public List<TRowResult> getRowsTs(ByteBuffer tableName, List<ByteBuffer> rows, long timestamp) throws IOError, TException
     {
       send_getRowsTs(tableName, rows, timestamp);
       return recv_getRowsTs();
     }
 
-    public void send_getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws TException
+    public void send_getRowsTs(ByteBuffer tableName, List<ByteBuffer> rows, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getRowsTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getRowsTs", TMessageType.CALL, ++seqid_));
       getRowsTs_args args = new getRowsTs_args();
-      args.tableName = tableName;
-      args.rows = rows;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setRows(rows);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1279,6 +1428,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowsTs failed: out of sequence response");
+      }
       getRowsTs_result result = new getRowsTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1291,20 +1443,20 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsTs failed: unknown result");
     }
 
-    public List<TRowResult> getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp) throws IOError, TException
+    public List<TRowResult> getRowsWithColumnsTs(ByteBuffer tableName, List<ByteBuffer> rows, List<ByteBuffer> columns, long timestamp) throws IOError, TException
     {
       send_getRowsWithColumnsTs(tableName, rows, columns, timestamp);
       return recv_getRowsWithColumnsTs();
     }
 
-    public void send_getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp) throws TException
+    public void send_getRowsWithColumnsTs(ByteBuffer tableName, List<ByteBuffer> rows, List<ByteBuffer> columns, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.CALL, ++seqid_));
       getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args();
-      args.tableName = tableName;
-      args.rows = rows;
-      args.columns = columns;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setRows(rows);
+      args.setColumns(columns);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1318,6 +1470,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getRowsWithColumnsTs failed: out of sequence response");
+      }
       getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1330,19 +1485,19 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result");
     }
 
-    public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException
+    public void mutateRow(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations) throws IOError, IllegalArgument, TException
     {
       send_mutateRow(tableName, row, mutations);
       recv_mutateRow();
     }
 
-    public void send_mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws TException
+    public void send_mutateRow(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("mutateRow", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("mutateRow", TMessageType.CALL, ++seqid_));
       mutateRow_args args = new mutateRow_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.mutations = mutations;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setMutations(mutations);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1356,6 +1511,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "mutateRow failed: out of sequence response");
+      }
       mutateRow_result result = new mutateRow_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1368,20 +1526,20 @@ public class Hbase {
       return;
     }
 
-    public void mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException
+    public void mutateRowTs(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException
     {
       send_mutateRowTs(tableName, row, mutations, timestamp);
       recv_mutateRowTs();
     }
 
-    public void send_mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp) throws TException
+    public void send_mutateRowTs(ByteBuffer tableName, ByteBuffer row, List<Mutation> mutations, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("mutateRowTs", TMessageType.CALL, ++seqid_));
       mutateRowTs_args args = new mutateRowTs_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.mutations = mutations;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setMutations(mutations);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1395,6 +1553,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "mutateRowTs failed: out of sequence response");
+      }
       mutateRowTs_result result = new mutateRowTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1407,18 +1568,18 @@ public class Hbase {
       return;
     }
 
-    public void mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException
+    public void mutateRows(ByteBuffer tableName, List<BatchMutation> rowBatches) throws IOError, IllegalArgument, TException
     {
       send_mutateRows(tableName, rowBatches);
       recv_mutateRows();
     }
 
-    public void send_mutateRows(byte[] tableName, List<BatchMutation> rowBatches) throws TException
+    public void send_mutateRows(ByteBuffer tableName, List<BatchMutation> rowBatches) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("mutateRows", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("mutateRows", TMessageType.CALL, ++seqid_));
       mutateRows_args args = new mutateRows_args();
-      args.tableName = tableName;
-      args.rowBatches = rowBatches;
+      args.setTableName(tableName);
+      args.setRowBatches(rowBatches);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1432,6 +1593,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "mutateRows failed: out of sequence response");
+      }
       mutateRows_result result = new mutateRows_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1444,19 +1608,19 @@ public class Hbase {
       return;
     }
 
-    public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException
+    public void mutateRowsTs(ByteBuffer tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException
     {
       send_mutateRowsTs(tableName, rowBatches, timestamp);
       recv_mutateRowsTs();
     }
 
-    public void send_mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws TException
+    public void send_mutateRowsTs(ByteBuffer tableName, List<BatchMutation> rowBatches, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("mutateRowsTs", TMessageType.CALL, ++seqid_));
       mutateRowsTs_args args = new mutateRowsTs_args();
-      args.tableName = tableName;
-      args.rowBatches = rowBatches;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setRowBatches(rowBatches);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1470,6 +1634,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "mutateRowsTs failed: out of sequence response");
+      }
       mutateRowsTs_result result = new mutateRowsTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1482,20 +1649,20 @@ public class Hbase {
       return;
     }
 
-    public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException
+    public long atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value) throws IOError, IllegalArgument, TException
     {
       send_atomicIncrement(tableName, row, column, value);
       return recv_atomicIncrement();
     }
 
-    public void send_atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws TException
+    public void send_atomicIncrement(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long value) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("atomicIncrement", TMessageType.CALL, ++seqid_));
       atomicIncrement_args args = new atomicIncrement_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.column = column;
-      args.value = value;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setColumn(column);
+      args.setValue(value);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1509,6 +1676,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "atomicIncrement failed: out of sequence response");
+      }
       atomicIncrement_result result = new atomicIncrement_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1524,19 +1694,19 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "atomicIncrement failed: unknown result");
     }
 
-    public void deleteAll(byte[] tableName, byte[] row, byte[] column) throws IOError, TException
+    public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError, TException
     {
       send_deleteAll(tableName, row, column);
       recv_deleteAll();
     }
 
-    public void send_deleteAll(byte[] tableName, byte[] row, byte[] column) throws TException
+    public void send_deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("deleteAll", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("deleteAll", TMessageType.CALL, ++seqid_));
       deleteAll_args args = new deleteAll_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.column = column;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setColumn(column);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1550,6 +1720,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteAll failed: out of sequence response");
+      }
       deleteAll_result result = new deleteAll_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1559,20 +1732,20 @@ public class Hbase {
       return;
     }
 
-    public void deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws IOError, TException
+    public void deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp) throws IOError, TException
     {
       send_deleteAllTs(tableName, row, column, timestamp);
       recv_deleteAllTs();
     }
 
-    public void send_deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp) throws TException
+    public void send_deleteAllTs(ByteBuffer tableName, ByteBuffer row, ByteBuffer column, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("deleteAllTs", TMessageType.CALL, ++seqid_));
       deleteAllTs_args args = new deleteAllTs_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.column = column;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setColumn(column);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1586,6 +1759,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteAllTs failed: out of sequence response");
+      }
       deleteAllTs_result result = new deleteAllTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1595,18 +1771,18 @@ public class Hbase {
       return;
     }
 
-    public void deleteAllRow(byte[] tableName, byte[] row) throws IOError, TException
+    public void deleteAllRow(ByteBuffer tableName, ByteBuffer row) throws IOError, TException
     {
       send_deleteAllRow(tableName, row);
       recv_deleteAllRow();
     }
 
-    public void send_deleteAllRow(byte[] tableName, byte[] row) throws TException
+    public void send_deleteAllRow(ByteBuffer tableName, ByteBuffer row) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("deleteAllRow", TMessageType.CALL, ++seqid_));
       deleteAllRow_args args = new deleteAllRow_args();
-      args.tableName = tableName;
-      args.row = row;
+      args.setTableName(tableName);
+      args.setRow(row);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1620,6 +1796,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteAllRow failed: out of sequence response");
+      }
       deleteAllRow_result result = new deleteAllRow_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1629,19 +1808,19 @@ public class Hbase {
       return;
     }
 
-    public void deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws IOError, TException
+    public void deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, TException
     {
       send_deleteAllRowTs(tableName, row, timestamp);
       recv_deleteAllRowTs();
     }
 
-    public void send_deleteAllRowTs(byte[] tableName, byte[] row, long timestamp) throws TException
+    public void send_deleteAllRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("deleteAllRowTs", TMessageType.CALL, ++seqid_));
       deleteAllRowTs_args args = new deleteAllRowTs_args();
-      args.tableName = tableName;
-      args.row = row;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setRow(row);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1655,6 +1834,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteAllRowTs failed: out of sequence response");
+      }
       deleteAllRowTs_result result = new deleteAllRowTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1664,19 +1846,19 @@ public class Hbase {
       return;
     }
 
-    public int scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws IOError, TException
+    public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns) throws IOError, TException
     {
       send_scannerOpen(tableName, startRow, columns);
       return recv_scannerOpen();
     }
 
-    public void send_scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns) throws TException
+    public void send_scannerOpen(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("scannerOpen", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("scannerOpen", TMessageType.CALL, ++seqid_));
       scannerOpen_args args = new scannerOpen_args();
-      args.tableName = tableName;
-      args.startRow = startRow;
-      args.columns = columns;
+      args.setTableName(tableName);
+      args.setStartRow(startRow);
+      args.setColumns(columns);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1690,6 +1872,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpen failed: out of sequence response");
+      }
       scannerOpen_result result = new scannerOpen_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1702,20 +1887,20 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result");
     }
 
-    public int scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws IOError, TException
+    public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List<ByteBuffer> columns) throws IOError, TException
     {
       send_scannerOpenWithStop(tableName, startRow, stopRow, columns);
       return recv_scannerOpenWithStop();
     }
 
-    public void send_scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns) throws TException
+    public void send_scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List<ByteBuffer> columns) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("scannerOpenWithStop", TMessageType.CALL, ++seqid_));
       scannerOpenWithStop_args args = new scannerOpenWithStop_args();
-      args.tableName = tableName;
-      args.startRow = startRow;
-      args.stopRow = stopRow;
-      args.columns = columns;
+      args.setTableName(tableName);
+      args.setStartRow(startRow);
+      args.setStopRow(stopRow);
+      args.setColumns(columns);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1729,6 +1914,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithStop failed: out of sequence response");
+      }
       scannerOpenWithStop_result result = new scannerOpenWithStop_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1741,19 +1929,19 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
     }
 
-    public int scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws IOError, TException
+    public int scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List<ByteBuffer> columns) throws IOError, TException
     {
       send_scannerOpenWithPrefix(tableName, startAndPrefix, columns);
       return recv_scannerOpenWithPrefix();
     }
 
-    public void send_scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns) throws TException
+    public void send_scannerOpenWithPrefix(ByteBuffer tableName, ByteBuffer startAndPrefix, List<ByteBuffer> columns) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("scannerOpenWithPrefix", TMessageType.CALL, ++seqid_));
       scannerOpenWithPrefix_args args = new scannerOpenWithPrefix_args();
-      args.tableName = tableName;
-      args.startAndPrefix = startAndPrefix;
-      args.columns = columns;
+      args.setTableName(tableName);
+      args.setStartAndPrefix(startAndPrefix);
+      args.setColumns(columns);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1767,6 +1955,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithPrefix failed: out of sequence response");
+      }
       scannerOpenWithPrefix_result result = new scannerOpenWithPrefix_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1779,20 +1970,20 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
     }
 
-    public int scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws IOError, TException
+    public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns, long timestamp) throws IOError, TException
     {
       send_scannerOpenTs(tableName, startRow, columns, timestamp);
       return recv_scannerOpenTs();
     }
 
-    public void send_scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp) throws TException
+    public void send_scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow, List<ByteBuffer> columns, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("scannerOpenTs", TMessageType.CALL, ++seqid_));
       scannerOpenTs_args args = new scannerOpenTs_args();
-      args.tableName = tableName;
-      args.startRow = startRow;
-      args.columns = columns;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setStartRow(startRow);
+      args.setColumns(columns);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1806,6 +1997,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpenTs failed: out of sequence response");
+      }
       scannerOpenTs_result result = new scannerOpenTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1818,21 +2012,21 @@ public class Hbase {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result");
     }
 
-    public int scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws IOError, TException
+    public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List<ByteBuffer> columns, long timestamp) throws IOError, TException
     {
       send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
       return recv_scannerOpenWithStopTs();
     }
 
-    public void send_scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp) throws TException
+    public void send_scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow, ByteBuffer stopRow, List<ByteBuffer> columns, long timestamp) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("scannerOpenWithStopTs", TMessageType.CALL, ++seqid_));
       scannerOpenWithStopTs_args args = new scannerOpenWithStopTs_args();
-      args.tableName = tableName;
-      args.startRow = startRow;
-      args.stopRow = stopRow;
-      args.columns = columns;
-      args.timestamp = timestamp;
+      args.setTableName(tableName);
+      args.setStartRow(startRow);
+      args.setStopRow(stopRow);
+      args.setColumns(columns);
+      args.setTimestamp(timestamp);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1846,6 +2040,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerOpenWithStopTs failed: out of sequence response");
+      }
       scannerOpenWithStopTs_result result = new scannerOpenWithStopTs_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1866,9 +2063,9 @@ public class Hbase {
 
     public void send_scannerGet(int id) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("scannerGet", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("scannerGet", TMessageType.CALL, ++seqid_));
       scannerGet_args args = new scannerGet_args();
-      args.id = id;
+      args.setId(id);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1882,6 +2079,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerGet failed: out of sequence response");
+      }
       scannerGet_result result = new scannerGet_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1905,10 +2105,10 @@ public class Hbase {
 
     public void send_scannerGetList(int id, int nbRows) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("scannerGetList", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("scannerGetList", TMessageType.CALL, ++seqid_));
       scannerGetList_args args = new scannerGetList_args();
-      args.id = id;
-      args.nbRows = nbRows;
+      args.setId(id);
+      args.setNbRows(nbRows);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1922,6 +2122,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerGetList failed: out of sequence response");
+      }
       scannerGetList_result result = new scannerGetList_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1945,9 +2148,9 @@ public class Hbase {
 
     public void send_scannerClose(int id) throws TException
     {
-      oprot_.writeMessageBegin(new TMessage("scannerClose", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("scannerClose", TMessageType.CALL, ++seqid_));
       scannerClose_args args = new scannerClose_args();
-      args.id = id;
+      args.setId(id);
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
@@ -1961,6 +2164,9 @@ public class Hbase {
         iprot_.readMessageEnd();
         throw x;
       }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "scannerClose failed: out of sequence response");
+      }
       scannerClose_result result = new scannerClose_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
@@ -1974,194 +2180,1618 @@ public class Hbase {
     }
 
   }
-  public static class Processor implements TProcessor {
-    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
-    public Processor(Iface iface)
-    {
-      iface_ = iface;
-      processMap_.put("enableTable", new enableTable());
-      processMap_.put("disableTable", new disableTable());
-      processMap_.put("isTableEnabled", new isTableEnabled());
-      processMap_.put("compact", new compact());
-      processMap_.put("majorCompact", new majorCompact());
-      processMap_.put("getTableNames", new getTableNames());
-      processMap_.put("getColumnDescriptors", new getColumnDescriptors());
-      processMap_.put("getTableRegions", new getTableRegions());
-      processMap_.put("createTable", new createTable());
-      processMap_.put("deleteTable", new deleteTable());
-      processMap_.put("get", new get());
-      processMap_.put("getVer", new getVer());
-      processMap_.put("getVerTs", new getVerTs());
-      processMap_.put("getRow", new getRow());
-      processMap_.put("getRowWithColumns", new getRowWithColumns());
-      processMap_.put("getRowTs", new getRowTs());
-      processMap_.put("getRowWithColumnsTs", new getRowWithColumnsTs());
-      processMap_.put("getRows", new getRows());
-      processMap_.put("getRowsWithColumns", new getRowsWithColumns());
-      processMap_.put("getRowsTs", new getRowsTs());
-      processMap_.put("getRowsWithColumnsTs", new getRowsWithColumnsTs());
-      processMap_.put("mutateRow", new mutateRow());
-      processMap_.put("mutateRowTs", new mutateRowTs());
-      processMap_.put("mutateRows", new mutateRows());
-      processMap_.put("mutateRowsTs", new mutateRowsTs());
-      processMap_.put("atomicIncrement", new atomicIncrement());
-      processMap_.put("deleteAll", new deleteAll());
-      processMap_.put("deleteAllTs", new deleteAllTs());
-      processMap_.put("deleteAllRow", new deleteAllRow());
-      processMap_.put("deleteAllRowTs", new deleteAllRowTs());
-      processMap_.put("scannerOpen", new scannerOpen());
-      processMap_.put("scannerOpenWithStop", new scannerOpenWithStop());
-      processMap_.put("scannerOpenWithPrefix", new scannerOpenWithPrefix());
-      processMap_.put("scannerOpenTs", new scannerOpenTs());
-      processMap_.put("scannerOpenWithStopTs", new scannerOpenWithStopTs());
-      processMap_.put("scannerGet", new scannerGet());
-      processMap_.put("scannerGetList", new scannerGetList());
-      processMap_.put("scannerClose", new scannerClose());
+  public static class AsyncClient extends TAsyncClient implements AsyncIface {
+    public static class Factory implements TAsyncClientFactory<AsyncClient> {
+      private TAsyncClientManager clientManager;
+      private TProtocolFactory protocolFactory;
+      public Factory(TAsyncClientManager clientManager, TProtocolFactory protocolFactory) {
+        this.clientManager = clientManager;
+        this.protocolFactory = protocolFactory;
+      }
+      public AsyncClient getAsyncClient(TNonblockingTransport transport) {
+        return new AsyncClient(protocolFactory, clientManager, transport);
+      }
     }
 
-    protected static interface ProcessFunction {
-      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException;
+    public AsyncClient(TProtocolFactory protocolFactory, TAsyncClientManager clientManager, TNonblockingTransport transport) {
+      super(protocolFactory, clientManager, transport);
     }
 
-    private Iface iface_;
-    protected final HashMap<String,ProcessFunction> processMap_ = new HashMap<String,ProcessFunction>();
+    public void enableTable(ByteBuffer tableName, AsyncMethodCallback<enableTable_call> resultHandler) throws TException {
+      checkReady();
+      enableTable_call method_call = new enableTable_call(tableName, resultHandler, this, protocolFactory, transport);
+      manager.call(method_call);
+    }
 
-    public boolean process(TProtocol iprot, TProtocol oprot) throws TException
-    {
-      TMessage msg = iprot.readMessageBegin();
-      ProcessFunction fn = processMap_.get(msg.name);
-      if (fn == null) {
-        TProtocolUtil.skip(iprot, TType.STRUCT);
-        iprot.readMessageEnd();
-        TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'");
-        oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));
-        x.write(oprot);
-        oprot.writeMessageEnd();
-        oprot.getTransport().flush();
-        return true;
+    public static class enableTable_call extends TAsyncMethodCall {
+      private ByteBuffer tableName;
+      public enableTable_call(ByteBuffer tableName, AsyncMethodCallback<enableTable_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+        super(client, protocolFactory, transport, resultHandler, false);
+        this.tableName = tableName;
       }
-      fn.process(msg.seqid, iprot, oprot);
-      return true;
-    }
 
-    private class enableTable implements ProcessFunction {
-      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
-      {
+      public void write_args(TProtocol prot) throws TException {
+        prot.writeMessageBegin(new TMessage("enableTable", TMessageType.CALL, 0));
         enableTable_args args = new enableTable_args();
-        args.read(iprot);
-        iprot.readMessageEnd();
-        enableTable_result result = new enableTable_result();
-        try {
-          iface_.enableTable(args.tableName);
-        } catch (IOError io) {
-          result.io = io;
-        } catch (Throwable th) {
-          LOGGER.error("Internal error processing enableTable", th);
-          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing enableTable");
-          oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.EXCEPTION, seqid));
-          x.write(oprot);
-          oprot.writeMessageEnd();
-          oprot.getTransport().flush();
-          return;
+        args.setTableName(tableName);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+
+      public void getResult() throws IOError, TException {
+        if (getState() != State.RESPONSE_READ) {
+          throw new IllegalStateException("Method call not finished!");
         }
-        oprot.writeMessageBegin(new TMessage("enableTable", TMessageType.REPLY, seqid));
-        result.write(oprot);
-        oprot.writeMessageEnd();
-        oprot.getTransport().flush();
+        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
+        TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+        (new Client(prot)).recv_enableTable();
       }
+    }
 
+    public void disableTable(ByteBuffer tableName, AsyncMethodCallback<disableTable_call> resultHandler) throws TException {
+      checkReady();
+      disableTable_call method_call = new disableTable_call(tableName, resultHandler, this, protocolFactory, transport);
+      manager.call(method_call);
     }
 
-    private class disableTable implements ProcessFunction {
-      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
-      {
+    public static class disableTable_call extends TAsyncMethodCall {
+      private ByteBuffer tableName;
+      public disableTable_call(ByteBuffer tableName, AsyncMethodCallback<disableTable_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+        super(client, protocolFactory, transport, resultHandler, false);
+        this.tableName = tableName;
+      }
+
+      public void write_args(TProtocol prot) throws TException {
+        prot.writeMessageBegin(new TMessage("disableTable", TMessageType.CALL, 0));

[... 24958 lines stripped ...]


Mime
View raw message