From 864ed4593e9fca0286b78cc20148aeb5b052e1dc Mon Sep 17 00:00:00 2001 From: Matthew Ward Date: Mon, 23 May 2011 17:34:41 -0700 Subject: [PATCH] Added thrift functionality for column pagination --- .../apache/hadoop/hbase/thrift/ThriftServer.java | 88 + .../hadoop/hbase/thrift/generated/Hbase.java | 7422 ++++++++++++++++---- .../org/apache/hadoop/hbase/thrift/Hbase.thrift | 67 + 3 files changed, 6322 insertions(+), 1255 deletions(-) diff --git a/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java b/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java index cedf538..bb9e319 100644 --- a/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java +++ b/src/main/java/org/apache/hadoop/hbase/thrift/ThriftServer.java @@ -55,6 +55,8 @@ import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.ResultScanner; import org.apache.hadoop.hbase.client.Scan; +import org.apache.hadoop.hbase.filter.ColumnCountGetFilter; +import org.apache.hadoop.hbase.filter.ColumnPaginationFilter; import org.apache.hadoop.hbase.filter.Filter; import org.apache.hadoop.hbase.filter.PrefixFilter; import org.apache.hadoop.hbase.filter.WhileMatchFilter; @@ -392,6 +394,14 @@ public class ThriftServer { return getRowWithColumnsTs(tableName, row, columns, HConstants.LATEST_TIMESTAMP); } + + @Override + public List getRowWithColumnsPaginated(ByteBuffer tableName, + ByteBuffer row, + List columns, int limit, int offset) throws IOError { + return getRowWithColumnsPaginatedTs(tableName, row, columns, + HConstants.LATEST_TIMESTAMP, limit, offset); + } @Override public List getRowTs(ByteBuffer tableName, ByteBuffer row, @@ -427,6 +437,46 @@ public class ThriftServer { throw new IOError(e.getMessage()); } } + + @Override + public List getRowWithColumnsPaginatedTs( + ByteBuffer tableName, + ByteBuffer row, + List columns, + long timestamp, + int limit, + int offset) throws IOError { + try { + + HTable table = getTable(tableName); + if (limit < 0) { + throw new IOException("limit cannot be less than 0"); + } + if (offset < 0) { + throw new IOException("offset cannot be less than 0"); + } + Filter filter = new ColumnPaginationFilter(limit, offset); + + Get get = new Get(getBytes(row)); + get.setTimeRange(Long.MIN_VALUE, timestamp); + get.setFilter(filter); + + if (columns != null) { + for(ByteBuffer column : columns) { + byte [][] famAndQf = KeyValue.parseColumn(getBytes(column)); + if (famAndQf.length == 1) { + get.addFamily(famAndQf[0]); + } else { + get.addColumn(famAndQf[0], famAndQf[1]); + } + } + } + Result result = table.get(get); + return ThriftUtilities.rowResultFromHBase(result); + } catch (IOException e) { + throw new IOError(e.getMessage()); + } + } @Override public List getRows(ByteBuffer tableName, @@ -483,6 +533,44 @@ public class ThriftServer { } @Override + public int countRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) + throws IOError + { + return countRowWithColumnsTs(tableName, row, columns, HConstants.LATEST_TIMESTAMP); + } + + @Override + public int countRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) + throws IOError + { + try{ + HTable table = getTable(tableName); + + Get get = new Get(getBytes(row)); + get.setTimeRange(Long.MIN_VALUE, timestamp); + int count = 0; + if (columns != null) { + for(ByteBuffer column : columns) { + byte [][] famAndQf = KeyValue.parseColumn(getBytes(column)); + if (famAndQf.length == 1) { + get.addFamily(famAndQf[0]); + } else { + get.addColumn(famAndQf[0], famAndQf[1]); + } + } + } + Result result = table.get(get); + if (result == null) return count; + for (KeyValue kv : result.sorted()) { + count++; + } + return count; + } catch (IOException e) { + throw new IOError(e.getMessage()); + } + } + + @Override public void deleteAll(ByteBuffer tableName, ByteBuffer row, ByteBuffer column) throws IOError { deleteAllTs(tableName, row, column, HConstants.LATEST_TIMESTAMP); diff --git a/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java b/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java index 48e0c3f..a4325ba 100644 --- a/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java +++ b/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java @@ -177,6 +177,24 @@ public class Hbase { public List getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws IOError, org.apache.thrift.TException; /** + * Get the specified columns for the specified table and row at the latest + * timestamp, paginated by specified limit and offset. Returns an empty list + * if no rows exist. + * + * @return TRowResult containing the rows and map of columns to TCells + * + * @param tableName name of table + * + * @param rows row keys + * + * @param columns List of columns to return, null for all columns + * + * @param limit + * @param offset + */ + public List getRowWithColumnsPaginated(ByteBuffer tableName, ByteBuffer rows, List columns, int limit, int offset) throws IOError, org.apache.thrift.TException; + + /** * Get all the data for the specified table and row at the specified * timestamp. Returns an empty list if the row does not exist. * @@ -207,6 +225,49 @@ public class Hbase { public List getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws IOError, org.apache.thrift.TException; /** + * Get the specified columns for the specified table and row at the specified + * timestamp, paginated by specified limit and offset. Returns an empty list + * if the row does not exist. + * + * @return TRowResult containing the row and map of columns to TCells + * + * @param tableName name of table + * + * @param row row key + * + * @param columns List of columns to return, null for all columns + * + * @param timestamp + * @param limit + * @param offset + */ + public List getRowWithColumnsPaginatedTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, int limit, int offset) throws IOError, org.apache.thrift.TException; + + /** + * Counts specified columns for the specified table and row. + * + * @return int + * + * @param tableName + * @param row + * @param columns + */ + public int countRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws IOError, org.apache.thrift.TException; + + /** + * Counts specified columns for the specified table and row at the specified + * timestamp. + * + * @return int + * + * @param tableName + * @param row + * @param columns + * @param timestamp + */ + public int countRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws IOError, org.apache.thrift.TException; + + /** * Get all the data for the specified table and rows at the latest * timestamp. Returns an empty list if no rows exist. * @@ -550,10 +611,18 @@ public class Hbase { public void getRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRowWithColumnsPaginated(ByteBuffer tableName, ByteBuffer rows, List columns, int limit, int offset, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void getRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRowWithColumnsPaginatedTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, int limit, int offset, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void countRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void countRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getRows(ByteBuffer tableName, List rows, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void getRowsWithColumns(ByteBuffer tableName, List rows, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -1220,6 +1289,49 @@ public class Hbase { throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result"); } + public List getRowWithColumnsPaginated(ByteBuffer tableName, ByteBuffer rows, List columns, int limit, int offset) throws IOError, org.apache.thrift.TException + { + send_getRowWithColumnsPaginated(tableName, rows, columns, limit, offset); + return recv_getRowWithColumnsPaginated(); + } + + public void send_getRowWithColumnsPaginated(ByteBuffer tableName, ByteBuffer rows, List columns, int limit, int offset) throws org.apache.thrift.TException + { + oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginated", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + getRowWithColumnsPaginated_args args = new getRowWithColumnsPaginated_args(); + args.setTableName(tableName); + args.setRows(rows); + args.setColumns(columns); + args.setLimit(limit); + args.setOffset(offset); + args.write(oprot_); + oprot_.writeMessageEnd(); + oprot_.getTransport().flush(); + } + + public List recv_getRowWithColumnsPaginated() throws IOError, org.apache.thrift.TException + { + org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); + if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { + org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + iprot_.readMessageEnd(); + throw x; + } + if (msg.seqid != seqid_) { + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRowWithColumnsPaginated failed: out of sequence response"); + } + getRowWithColumnsPaginated_result result = new getRowWithColumnsPaginated_result(); + result.read(iprot_); + iprot_.readMessageEnd(); + if (result.isSetSuccess()) { + return result.success; + } + if (result.io != null) { + throw result.io; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowWithColumnsPaginated failed: unknown result"); + } + public List getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp) throws IOError, org.apache.thrift.TException { send_getRowTs(tableName, row, timestamp); @@ -1303,6 +1415,133 @@ public class Hbase { throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result"); } + public List getRowWithColumnsPaginatedTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, int limit, int offset) throws IOError, org.apache.thrift.TException + { + send_getRowWithColumnsPaginatedTs(tableName, row, columns, timestamp, limit, offset); + return recv_getRowWithColumnsPaginatedTs(); + } + + public void send_getRowWithColumnsPaginatedTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, int limit, int offset) throws org.apache.thrift.TException + { + oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginatedTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + getRowWithColumnsPaginatedTs_args args = new getRowWithColumnsPaginatedTs_args(); + args.setTableName(tableName); + args.setRow(row); + args.setColumns(columns); + args.setTimestamp(timestamp); + args.setLimit(limit); + args.setOffset(offset); + args.write(oprot_); + oprot_.writeMessageEnd(); + oprot_.getTransport().flush(); + } + + public List recv_getRowWithColumnsPaginatedTs() throws IOError, org.apache.thrift.TException + { + org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); + if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { + org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + iprot_.readMessageEnd(); + throw x; + } + if (msg.seqid != seqid_) { + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "getRowWithColumnsPaginatedTs failed: out of sequence response"); + } + getRowWithColumnsPaginatedTs_result result = new getRowWithColumnsPaginatedTs_result(); + result.read(iprot_); + iprot_.readMessageEnd(); + if (result.isSetSuccess()) { + return result.success; + } + if (result.io != null) { + throw result.io; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRowWithColumnsPaginatedTs failed: unknown result"); + } + + public int countRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws IOError, org.apache.thrift.TException + { + send_countRowWithColumns(tableName, row, columns); + return recv_countRowWithColumns(); + } + + public void send_countRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns) throws org.apache.thrift.TException + { + oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumns", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + countRowWithColumns_args args = new countRowWithColumns_args(); + args.setTableName(tableName); + args.setRow(row); + args.setColumns(columns); + args.write(oprot_); + oprot_.writeMessageEnd(); + oprot_.getTransport().flush(); + } + + public int recv_countRowWithColumns() throws IOError, org.apache.thrift.TException + { + org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); + if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { + org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + iprot_.readMessageEnd(); + throw x; + } + if (msg.seqid != seqid_) { + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "countRowWithColumns failed: out of sequence response"); + } + countRowWithColumns_result result = new countRowWithColumns_result(); + result.read(iprot_); + iprot_.readMessageEnd(); + if (result.isSetSuccess()) { + return result.success; + } + if (result.io != null) { + throw result.io; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "countRowWithColumns failed: unknown result"); + } + + public int countRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws IOError, org.apache.thrift.TException + { + send_countRowWithColumnsTs(tableName, row, columns, timestamp); + return recv_countRowWithColumnsTs(); + } + + public void send_countRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp) throws org.apache.thrift.TException + { + oprot_.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.CALL, ++seqid_)); + countRowWithColumnsTs_args args = new countRowWithColumnsTs_args(); + args.setTableName(tableName); + args.setRow(row); + args.setColumns(columns); + args.setTimestamp(timestamp); + args.write(oprot_); + oprot_.writeMessageEnd(); + oprot_.getTransport().flush(); + } + + public int recv_countRowWithColumnsTs() throws IOError, org.apache.thrift.TException + { + org.apache.thrift.protocol.TMessage msg = iprot_.readMessageBegin(); + if (msg.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) { + org.apache.thrift.TApplicationException x = org.apache.thrift.TApplicationException.read(iprot_); + iprot_.readMessageEnd(); + throw x; + } + if (msg.seqid != seqid_) { + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID, "countRowWithColumnsTs failed: out of sequence response"); + } + countRowWithColumnsTs_result result = new countRowWithColumnsTs_result(); + result.read(iprot_); + iprot_.readMessageEnd(); + if (result.isSetSuccess()) { + return result.success; + } + if (result.io != null) { + throw result.io; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "countRowWithColumnsTs failed: unknown result"); + } + public List getRows(ByteBuffer tableName, List rows) throws IOError, org.apache.thrift.TException { send_getRows(tableName, rows); @@ -2695,6 +2934,50 @@ public class Hbase { } } + public void getRowWithColumnsPaginated(ByteBuffer tableName, ByteBuffer rows, List columns, int limit, int offset, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getRowWithColumnsPaginated_call method_call = new getRowWithColumnsPaginated_call(tableName, rows, columns, limit, offset, resultHandler, this, protocolFactory, transport); + this.currentMethod = method_call; + manager.call(method_call); + } + + public static class getRowWithColumnsPaginated_call extends org.apache.thrift.async.TAsyncMethodCall { + private ByteBuffer tableName; + private ByteBuffer rows; + private List columns; + private int limit; + private int offset; + public getRowWithColumnsPaginated_call(ByteBuffer tableName, ByteBuffer rows, List columns, int limit, int offset, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.tableName = tableName; + this.rows = rows; + this.columns = columns; + this.limit = limit; + this.offset = offset; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginated", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getRowWithColumnsPaginated_args args = new getRowWithColumnsPaginated_args(); + args.setTableName(tableName); + args.setRows(rows); + args.setColumns(columns); + args.setLimit(limit); + args.setOffset(offset); + args.write(prot); + prot.writeMessageEnd(); + } + + public List getResult() throws IOError, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getRowWithColumnsPaginated(); + } + } + public void getRowTs(ByteBuffer tableName, ByteBuffer row, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); getRowTs_call method_call = new getRowTs_call(tableName, row, timestamp, resultHandler, this, protocolFactory, transport); @@ -2774,6 +3057,132 @@ public class Hbase { } } + public void getRowWithColumnsPaginatedTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, int limit, int offset, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getRowWithColumnsPaginatedTs_call method_call = new getRowWithColumnsPaginatedTs_call(tableName, row, columns, timestamp, limit, offset, resultHandler, this, protocolFactory, transport); + this.currentMethod = method_call; + manager.call(method_call); + } + + public static class getRowWithColumnsPaginatedTs_call extends org.apache.thrift.async.TAsyncMethodCall { + private ByteBuffer tableName; + private ByteBuffer row; + private List columns; + private long timestamp; + private int limit; + private int offset; + public getRowWithColumnsPaginatedTs_call(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, int limit, int offset, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.tableName = tableName; + this.row = row; + this.columns = columns; + this.timestamp = timestamp; + this.limit = limit; + this.offset = offset; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginatedTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getRowWithColumnsPaginatedTs_args args = new getRowWithColumnsPaginatedTs_args(); + args.setTableName(tableName); + args.setRow(row); + args.setColumns(columns); + args.setTimestamp(timestamp); + args.setLimit(limit); + args.setOffset(offset); + args.write(prot); + prot.writeMessageEnd(); + } + + public List getResult() throws IOError, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getRowWithColumnsPaginatedTs(); + } + } + + public void countRowWithColumns(ByteBuffer tableName, ByteBuffer row, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + countRowWithColumns_call method_call = new countRowWithColumns_call(tableName, row, columns, resultHandler, this, protocolFactory, transport); + this.currentMethod = method_call; + manager.call(method_call); + } + + public static class countRowWithColumns_call extends org.apache.thrift.async.TAsyncMethodCall { + private ByteBuffer tableName; + private ByteBuffer row; + private List columns; + public countRowWithColumns_call(ByteBuffer tableName, ByteBuffer row, List columns, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.tableName = tableName; + this.row = row; + this.columns = columns; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumns", org.apache.thrift.protocol.TMessageType.CALL, 0)); + countRowWithColumns_args args = new countRowWithColumns_args(); + args.setTableName(tableName); + args.setRow(row); + args.setColumns(columns); + args.write(prot); + prot.writeMessageEnd(); + } + + public int getResult() throws IOError, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_countRowWithColumns(); + } + } + + public void countRowWithColumnsTs(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + countRowWithColumnsTs_call method_call = new countRowWithColumnsTs_call(tableName, row, columns, timestamp, resultHandler, this, protocolFactory, transport); + this.currentMethod = method_call; + manager.call(method_call); + } + + public static class countRowWithColumnsTs_call extends org.apache.thrift.async.TAsyncMethodCall { + private ByteBuffer tableName; + private ByteBuffer row; + private List columns; + private long timestamp; + public countRowWithColumnsTs_call(ByteBuffer tableName, ByteBuffer row, List columns, long timestamp, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.tableName = tableName; + this.row = row; + this.columns = columns; + this.timestamp = timestamp; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + countRowWithColumnsTs_args args = new countRowWithColumnsTs_args(); + args.setTableName(tableName); + args.setRow(row); + args.setColumns(columns); + args.setTimestamp(timestamp); + args.write(prot); + prot.writeMessageEnd(); + } + + public int getResult() throws IOError, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_countRowWithColumnsTs(); + } + } + public void getRows(ByteBuffer tableName, List rows, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); getRows_call method_call = new getRows_call(tableName, rows, resultHandler, this, protocolFactory, transport); @@ -3594,8 +4003,12 @@ public class Hbase { processMap_.put("getVerTs", new getVerTs()); processMap_.put("getRow", new getRow()); processMap_.put("getRowWithColumns", new getRowWithColumns()); + processMap_.put("getRowWithColumnsPaginated", new getRowWithColumnsPaginated()); processMap_.put("getRowTs", new getRowTs()); processMap_.put("getRowWithColumnsTs", new getRowWithColumnsTs()); + processMap_.put("getRowWithColumnsPaginatedTs", new getRowWithColumnsPaginatedTs()); + processMap_.put("countRowWithColumns", new countRowWithColumns()); + processMap_.put("countRowWithColumnsTs", new countRowWithColumnsTs()); processMap_.put("getRows", new getRows()); processMap_.put("getRowsWithColumns", new getRowsWithColumns()); processMap_.put("getRowsTs", new getRowsTs()); @@ -4219,6 +4632,44 @@ public class Hbase { } + private class getRowWithColumnsPaginated implements ProcessFunction { + public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + { + getRowWithColumnsPaginated_args args = new getRowWithColumnsPaginated_args(); + try { + args.read(iprot); + } catch (org.apache.thrift.protocol.TProtocolException e) { + iprot.readMessageEnd(); + org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginated", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + x.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + return; + } + iprot.readMessageEnd(); + getRowWithColumnsPaginated_result result = new getRowWithColumnsPaginated_result(); + try { + result.success = iface_.getRowWithColumnsPaginated(args.tableName, args.rows, args.columns, args.limit, args.offset); + } catch (IOError io) { + result.io = io; + } catch (Throwable th) { + LOGGER.error("Internal error processing getRowWithColumnsPaginated", th); + org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumnsPaginated"); + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginated", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + x.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + return; + } + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginated", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + result.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + } + + } + private class getRowTs implements ProcessFunction { public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { @@ -4295,6 +4746,122 @@ public class Hbase { } + private class getRowWithColumnsPaginatedTs implements ProcessFunction { + public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + { + getRowWithColumnsPaginatedTs_args args = new getRowWithColumnsPaginatedTs_args(); + try { + args.read(iprot); + } catch (org.apache.thrift.protocol.TProtocolException e) { + iprot.readMessageEnd(); + org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginatedTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + x.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + return; + } + iprot.readMessageEnd(); + getRowWithColumnsPaginatedTs_result result = new getRowWithColumnsPaginatedTs_result(); + try { + result.success = iface_.getRowWithColumnsPaginatedTs(args.tableName, args.row, args.columns, args.timestamp, args.limit, args.offset); + } catch (IOError io) { + result.io = io; + } catch (Throwable th) { + LOGGER.error("Internal error processing getRowWithColumnsPaginatedTs", th); + org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing getRowWithColumnsPaginatedTs"); + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginatedTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + x.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + return; + } + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRowWithColumnsPaginatedTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + result.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + } + + } + + private class countRowWithColumns implements ProcessFunction { + public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + { + countRowWithColumns_args args = new countRowWithColumns_args(); + try { + args.read(iprot); + } catch (org.apache.thrift.protocol.TProtocolException e) { + iprot.readMessageEnd(); + org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumns", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + x.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + return; + } + iprot.readMessageEnd(); + countRowWithColumns_result result = new countRowWithColumns_result(); + try { + result.success = iface_.countRowWithColumns(args.tableName, args.row, args.columns); + result.setSuccessIsSet(true); + } catch (IOError io) { + result.io = io; + } catch (Throwable th) { + LOGGER.error("Internal error processing countRowWithColumns", th); + org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing countRowWithColumns"); + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumns", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + x.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + return; + } + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumns", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + result.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + } + + } + + private class countRowWithColumnsTs implements ProcessFunction { + public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException + { + countRowWithColumnsTs_args args = new countRowWithColumnsTs_args(); + try { + args.read(iprot); + } catch (org.apache.thrift.protocol.TProtocolException e) { + iprot.readMessageEnd(); + org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.PROTOCOL_ERROR, e.getMessage()); + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + x.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + return; + } + iprot.readMessageEnd(); + countRowWithColumnsTs_result result = new countRowWithColumnsTs_result(); + try { + result.success = iface_.countRowWithColumnsTs(args.tableName, args.row, args.columns, args.timestamp); + result.setSuccessIsSet(true); + } catch (IOError io) { + result.io = io; + } catch (Throwable th) { + LOGGER.error("Internal error processing countRowWithColumnsTs", th); + org.apache.thrift.TApplicationException x = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, "Internal error processing countRowWithColumnsTs"); + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.EXCEPTION, seqid)); + x.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + return; + } + oprot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("countRowWithColumnsTs", org.apache.thrift.protocol.TMessageType.REPLY, seqid)); + result.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + } + + } + private class getRows implements ProcessFunction { public void process(int seqid, org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { @@ -11389,39 +11956,3862 @@ public class Hbase { tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_args.class, metaDataMap); + } + + public deleteTable_args() { + } + + public deleteTable_args( + ByteBuffer tableName) + { + this(); + this.tableName = tableName; + } + + /** + * Performs a deep copy on other. + */ + public deleteTable_args(deleteTable_args other) { + if (other.isSetTableName()) { + this.tableName = other.tableName; + } + } + + public deleteTable_args deepCopy() { + return new deleteTable_args(this); + } + + @Override + public void clear() { + this.tableName = null; + } + + /** + * name of table to delete + */ + public byte[] getTableName() { + setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); + return tableName == null ? null : tableName.array(); + } + + public ByteBuffer bufferForTableName() { + return tableName; + } + + /** + * name of table to delete + */ + public deleteTable_args setTableName(byte[] tableName) { + setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + return this; + } + + public deleteTable_args setTableName(ByteBuffer tableName) { + this.tableName = tableName; + return this; + } + + public void unsetTableName() { + this.tableName = null; + } + + /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + public boolean isSetTableName() { + return this.tableName != null; + } + + public void setTableNameIsSet(boolean value) { + if (!value) { + this.tableName = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TABLE_NAME: + if (value == null) { + unsetTableName(); + } else { + setTableName((ByteBuffer)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TABLE_NAME: + return getTableName(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TABLE_NAME: + return isSetTableName(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof deleteTable_args) + return this.equals((deleteTable_args)that); + return false; + } + + public boolean equals(deleteTable_args that) { + if (that == null) + return false; + + boolean this_present_tableName = true && this.isSetTableName(); + boolean that_present_tableName = true && that.isSetTableName(); + if (this_present_tableName || that_present_tableName) { + if (!(this_present_tableName && that_present_tableName)) + return false; + if (!this.tableName.equals(that.tableName)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(deleteTable_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + deleteTable_args typedOther = (deleteTable_args)other; + + lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTableName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 1: // TABLE_NAME + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.tableName = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (this.tableName != null) { + oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC); + oprot.writeBinary(this.tableName); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("deleteTable_args("); + boolean first = true; + + sb.append("tableName:"); + if (this.tableName == null) { + sb.append("null"); + } else { + sb.append(this.tableName); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + } + + public static class deleteTable_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteTable_result"); + + private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + public IOError io; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + IO((short)1, "io"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // IO + return IO; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap); + } + + public deleteTable_result() { + } + + public deleteTable_result( + IOError io) + { + this(); + this.io = io; + } + + /** + * Performs a deep copy on other. + */ + public deleteTable_result(deleteTable_result other) { + if (other.isSetIo()) { + this.io = new IOError(other.io); + } + } + + public deleteTable_result deepCopy() { + return new deleteTable_result(this); + } + + @Override + public void clear() { + this.io = null; + } + + public IOError getIo() { + return this.io; + } + + public deleteTable_result setIo(IOError io) { + this.io = io; + return this; + } + + public void unsetIo() { + this.io = null; + } + + /** Returns true if field io is set (has been assigned a value) and false otherwise */ + public boolean isSetIo() { + return this.io != null; + } + + public void setIoIsSet(boolean value) { + if (!value) { + this.io = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case IO: + if (value == null) { + unsetIo(); + } else { + setIo((IOError)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case IO: + return getIo(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case IO: + return isSetIo(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof deleteTable_result) + return this.equals((deleteTable_result)that); + return false; + } + + public boolean equals(deleteTable_result that) { + if (that == null) + return false; + + boolean this_present_io = true && this.isSetIo(); + boolean that_present_io = true && that.isSetIo(); + if (this_present_io || that_present_io) { + if (!(this_present_io && that_present_io)) + return false; + if (!this.io.equals(that.io)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(deleteTable_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + deleteTable_result typedOther = (deleteTable_result)other; + + lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIo()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 1: // IO + if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + this.io = new IOError(); + this.io.read(iprot); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + oprot.writeStructBegin(STRUCT_DESC); + + if (this.isSetIo()) { + oprot.writeFieldBegin(IO_FIELD_DESC); + this.io.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("deleteTable_result("); + boolean first = true; + + sb.append("io:"); + if (this.io == null) { + sb.append("null"); + } else { + sb.append(this.io); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + } + + public static class get_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_args"); + + private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); + + /** + * name of table + */ + public ByteBuffer tableName; + /** + * row key + */ + public ByteBuffer row; + /** + * column name + */ + public ByteBuffer column; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + /** + * name of table + */ + TABLE_NAME((short)1, "tableName"), + /** + * row key + */ + ROW((short)2, "row"), + /** + * column name + */ + COLUMN((short)3, "column"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // TABLE_NAME + return TABLE_NAME; + case 2: // ROW + return ROW; + case 3: // COLUMN + return COLUMN; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap); + } + + public get_args() { + } + + public get_args( + ByteBuffer tableName, + ByteBuffer row, + ByteBuffer column) + { + this(); + this.tableName = tableName; + this.row = row; + this.column = column; + } + + /** + * Performs a deep copy on other. + */ + public get_args(get_args other) { + if (other.isSetTableName()) { + this.tableName = other.tableName; + } + if (other.isSetRow()) { + this.row = other.row; + } + if (other.isSetColumn()) { + this.column = other.column; + } + } + + public get_args deepCopy() { + return new get_args(this); + } + + @Override + public void clear() { + this.tableName = null; + this.row = null; + this.column = null; + } + + /** + * name of table + */ + public byte[] getTableName() { + setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); + return tableName == null ? null : tableName.array(); + } + + public ByteBuffer bufferForTableName() { + return tableName; + } + + /** + * name of table + */ + public get_args setTableName(byte[] tableName) { + setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + return this; + } + + public get_args setTableName(ByteBuffer tableName) { + this.tableName = tableName; + return this; + } + + public void unsetTableName() { + this.tableName = null; + } + + /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + public boolean isSetTableName() { + return this.tableName != null; + } + + public void setTableNameIsSet(boolean value) { + if (!value) { + this.tableName = null; + } + } + + /** + * row key + */ + public byte[] getRow() { + setRow(org.apache.thrift.TBaseHelper.rightSize(row)); + return row == null ? null : row.array(); + } + + public ByteBuffer bufferForRow() { + return row; + } + + /** + * row key + */ + public get_args setRow(byte[] row) { + setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + return this; + } + + public get_args setRow(ByteBuffer row) { + this.row = row; + return this; + } + + public void unsetRow() { + this.row = null; + } + + /** Returns true if field row is set (has been assigned a value) and false otherwise */ + public boolean isSetRow() { + return this.row != null; + } + + public void setRowIsSet(boolean value) { + if (!value) { + this.row = null; + } + } + + /** + * column name + */ + public byte[] getColumn() { + setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); + return column == null ? null : column.array(); + } + + public ByteBuffer bufferForColumn() { + return column; + } + + /** + * column name + */ + public get_args setColumn(byte[] column) { + setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); + return this; + } + + public get_args setColumn(ByteBuffer column) { + this.column = column; + return this; + } + + public void unsetColumn() { + this.column = null; + } + + /** Returns true if field column is set (has been assigned a value) and false otherwise */ + public boolean isSetColumn() { + return this.column != null; + } + + public void setColumnIsSet(boolean value) { + if (!value) { + this.column = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TABLE_NAME: + if (value == null) { + unsetTableName(); + } else { + setTableName((ByteBuffer)value); + } + break; + + case ROW: + if (value == null) { + unsetRow(); + } else { + setRow((ByteBuffer)value); + } + break; + + case COLUMN: + if (value == null) { + unsetColumn(); + } else { + setColumn((ByteBuffer)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TABLE_NAME: + return getTableName(); + + case ROW: + return getRow(); + + case COLUMN: + return getColumn(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TABLE_NAME: + return isSetTableName(); + case ROW: + return isSetRow(); + case COLUMN: + return isSetColumn(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof get_args) + return this.equals((get_args)that); + return false; + } + + public boolean equals(get_args that) { + if (that == null) + return false; + + boolean this_present_tableName = true && this.isSetTableName(); + boolean that_present_tableName = true && that.isSetTableName(); + if (this_present_tableName || that_present_tableName) { + if (!(this_present_tableName && that_present_tableName)) + return false; + if (!this.tableName.equals(that.tableName)) + return false; + } + + boolean this_present_row = true && this.isSetRow(); + boolean that_present_row = true && that.isSetRow(); + if (this_present_row || that_present_row) { + if (!(this_present_row && that_present_row)) + return false; + if (!this.row.equals(that.row)) + return false; + } + + boolean this_present_column = true && this.isSetColumn(); + boolean that_present_column = true && that.isSetColumn(); + if (this_present_column || that_present_column) { + if (!(this_present_column && that_present_column)) + return false; + if (!this.column.equals(that.column)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(get_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + get_args typedOther = (get_args)other; + + lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTableName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRow()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetColumn()).compareTo(typedOther.isSetColumn()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetColumn()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 1: // TABLE_NAME + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.tableName = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 2: // ROW + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.row = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 3: // COLUMN + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.column = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (this.tableName != null) { + oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC); + oprot.writeBinary(this.tableName); + oprot.writeFieldEnd(); + } + if (this.row != null) { + oprot.writeFieldBegin(ROW_FIELD_DESC); + oprot.writeBinary(this.row); + oprot.writeFieldEnd(); + } + if (this.column != null) { + oprot.writeFieldBegin(COLUMN_FIELD_DESC); + oprot.writeBinary(this.column); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("get_args("); + boolean first = true; + + sb.append("tableName:"); + if (this.tableName == null) { + sb.append("null"); + } else { + sb.append(this.tableName); + } + first = false; + if (!first) sb.append(", "); + sb.append("row:"); + if (this.row == null) { + sb.append("null"); + } else { + sb.append(this.row); + } + first = false; + if (!first) sb.append(", "); + sb.append("column:"); + if (this.column == null) { + sb.append("null"); + } else { + sb.append(this.column); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + } + + public static class get_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); + private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + public List success; + public IOError io; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + IO((short)1, "io"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // IO + return IO; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)))); + tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap); + } + + public get_result() { + } + + public get_result( + List success, + IOError io) + { + this(); + this.success = success; + this.io = io; + } + + /** + * Performs a deep copy on other. + */ + public get_result(get_result other) { + if (other.isSetSuccess()) { + List __this__success = new ArrayList(); + for (TCell other_element : other.success) { + __this__success.add(new TCell(other_element)); + } + this.success = __this__success; + } + if (other.isSetIo()) { + this.io = new IOError(other.io); + } + } + + public get_result deepCopy() { + return new get_result(this); + } + + @Override + public void clear() { + this.success = null; + this.io = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public java.util.Iterator getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } + + public void addToSuccess(TCell elem) { + if (this.success == null) { + this.success = new ArrayList(); + } + this.success.add(elem); + } + + public List getSuccess() { + return this.success; + } + + public get_result setSuccess(List success) { + this.success = success; + return this; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public IOError getIo() { + return this.io; + } + + public get_result setIo(IOError io) { + this.io = io; + return this; + } + + public void unsetIo() { + this.io = null; + } + + /** Returns true if field io is set (has been assigned a value) and false otherwise */ + public boolean isSetIo() { + return this.io != null; + } + + public void setIoIsSet(boolean value) { + if (!value) { + this.io = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List)value); + } + break; + + case IO: + if (value == null) { + unsetIo(); + } else { + setIo((IOError)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case IO: + return getIo(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case IO: + return isSetIo(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof get_result) + return this.equals((get_result)that); + return false; + } + + public boolean equals(get_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + boolean this_present_io = true && this.isSetIo(); + boolean that_present_io = true && that.isSetIo(); + if (this_present_io || that_present_io) { + if (!(this_present_io && that_present_io)) + return false; + if (!this.io.equals(that.io)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(get_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + get_result typedOther = (get_result)other; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIo()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 0: // SUCCESS + if (field.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list26 = iprot.readListBegin(); + this.success = new ArrayList(_list26.size); + for (int _i27 = 0; _i27 < _list26.size; ++_i27) + { + TCell _elem28; + _elem28 = new TCell(); + _elem28.read(iprot); + this.success.add(_elem28); + } + iprot.readListEnd(); + } + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 1: // IO + if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + this.io = new IOError(); + this.io.read(iprot); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + oprot.writeStructBegin(STRUCT_DESC); + + if (this.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + for (TCell _iter29 : this.success) + { + _iter29.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } else if (this.isSetIo()) { + oprot.writeFieldBegin(IO_FIELD_DESC); + this.io.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("get_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("io:"); + if (this.io == null) { + sb.append("null"); + } else { + sb.append(this.io); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + } + + public static class getVer_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVer_args"); + + private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField NUM_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("numVersions", org.apache.thrift.protocol.TType.I32, (short)4); + + /** + * name of table + */ + public ByteBuffer tableName; + /** + * row key + */ + public ByteBuffer row; + /** + * column name + */ + public ByteBuffer column; + /** + * number of versions to retrieve + */ + public int numVersions; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + /** + * name of table + */ + TABLE_NAME((short)1, "tableName"), + /** + * row key + */ + ROW((short)2, "row"), + /** + * column name + */ + COLUMN((short)3, "column"), + /** + * number of versions to retrieve + */ + NUM_VERSIONS((short)4, "numVersions"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // TABLE_NAME + return TABLE_NAME; + case 2: // ROW + return ROW; + case 3: // COLUMN + return COLUMN; + case 4: // NUM_VERSIONS + return NUM_VERSIONS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __NUMVERSIONS_ISSET_ID = 0; + private BitSet __isset_bit_vector = new BitSet(1); + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.NUM_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("numVersions", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVer_args.class, metaDataMap); + } + + public getVer_args() { + } + + public getVer_args( + ByteBuffer tableName, + ByteBuffer row, + ByteBuffer column, + int numVersions) + { + this(); + this.tableName = tableName; + this.row = row; + this.column = column; + this.numVersions = numVersions; + setNumVersionsIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public getVer_args(getVer_args other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + if (other.isSetTableName()) { + this.tableName = other.tableName; + } + if (other.isSetRow()) { + this.row = other.row; + } + if (other.isSetColumn()) { + this.column = other.column; + } + this.numVersions = other.numVersions; + } + + public getVer_args deepCopy() { + return new getVer_args(this); + } + + @Override + public void clear() { + this.tableName = null; + this.row = null; + this.column = null; + setNumVersionsIsSet(false); + this.numVersions = 0; + } + + /** + * name of table + */ + public byte[] getTableName() { + setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); + return tableName == null ? null : tableName.array(); + } + + public ByteBuffer bufferForTableName() { + return tableName; + } + + /** + * name of table + */ + public getVer_args setTableName(byte[] tableName) { + setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + return this; + } + + public getVer_args setTableName(ByteBuffer tableName) { + this.tableName = tableName; + return this; + } + + public void unsetTableName() { + this.tableName = null; + } + + /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + public boolean isSetTableName() { + return this.tableName != null; + } + + public void setTableNameIsSet(boolean value) { + if (!value) { + this.tableName = null; + } + } + + /** + * row key + */ + public byte[] getRow() { + setRow(org.apache.thrift.TBaseHelper.rightSize(row)); + return row == null ? null : row.array(); + } + + public ByteBuffer bufferForRow() { + return row; + } + + /** + * row key + */ + public getVer_args setRow(byte[] row) { + setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + return this; + } + + public getVer_args setRow(ByteBuffer row) { + this.row = row; + return this; + } + + public void unsetRow() { + this.row = null; + } + + /** Returns true if field row is set (has been assigned a value) and false otherwise */ + public boolean isSetRow() { + return this.row != null; + } + + public void setRowIsSet(boolean value) { + if (!value) { + this.row = null; + } + } + + /** + * column name + */ + public byte[] getColumn() { + setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); + return column == null ? null : column.array(); + } + + public ByteBuffer bufferForColumn() { + return column; + } + + /** + * column name + */ + public getVer_args setColumn(byte[] column) { + setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); + return this; + } + + public getVer_args setColumn(ByteBuffer column) { + this.column = column; + return this; + } + + public void unsetColumn() { + this.column = null; + } + + /** Returns true if field column is set (has been assigned a value) and false otherwise */ + public boolean isSetColumn() { + return this.column != null; + } + + public void setColumnIsSet(boolean value) { + if (!value) { + this.column = null; + } + } + + /** + * number of versions to retrieve + */ + public int getNumVersions() { + return this.numVersions; + } + + /** + * number of versions to retrieve + */ + public getVer_args setNumVersions(int numVersions) { + this.numVersions = numVersions; + setNumVersionsIsSet(true); + return this; + } + + public void unsetNumVersions() { + __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID); + } + + /** Returns true if field numVersions is set (has been assigned a value) and false otherwise */ + public boolean isSetNumVersions() { + return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID); + } + + public void setNumVersionsIsSet(boolean value) { + __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TABLE_NAME: + if (value == null) { + unsetTableName(); + } else { + setTableName((ByteBuffer)value); + } + break; + + case ROW: + if (value == null) { + unsetRow(); + } else { + setRow((ByteBuffer)value); + } + break; + + case COLUMN: + if (value == null) { + unsetColumn(); + } else { + setColumn((ByteBuffer)value); + } + break; + + case NUM_VERSIONS: + if (value == null) { + unsetNumVersions(); + } else { + setNumVersions((Integer)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TABLE_NAME: + return getTableName(); + + case ROW: + return getRow(); + + case COLUMN: + return getColumn(); + + case NUM_VERSIONS: + return new Integer(getNumVersions()); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TABLE_NAME: + return isSetTableName(); + case ROW: + return isSetRow(); + case COLUMN: + return isSetColumn(); + case NUM_VERSIONS: + return isSetNumVersions(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getVer_args) + return this.equals((getVer_args)that); + return false; + } + + public boolean equals(getVer_args that) { + if (that == null) + return false; + + boolean this_present_tableName = true && this.isSetTableName(); + boolean that_present_tableName = true && that.isSetTableName(); + if (this_present_tableName || that_present_tableName) { + if (!(this_present_tableName && that_present_tableName)) + return false; + if (!this.tableName.equals(that.tableName)) + return false; + } + + boolean this_present_row = true && this.isSetRow(); + boolean that_present_row = true && that.isSetRow(); + if (this_present_row || that_present_row) { + if (!(this_present_row && that_present_row)) + return false; + if (!this.row.equals(that.row)) + return false; + } + + boolean this_present_column = true && this.isSetColumn(); + boolean that_present_column = true && that.isSetColumn(); + if (this_present_column || that_present_column) { + if (!(this_present_column && that_present_column)) + return false; + if (!this.column.equals(that.column)) + return false; + } + + boolean this_present_numVersions = true; + boolean that_present_numVersions = true; + if (this_present_numVersions || that_present_numVersions) { + if (!(this_present_numVersions && that_present_numVersions)) + return false; + if (this.numVersions != that.numVersions) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(getVer_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + getVer_args typedOther = (getVer_args)other; + + lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTableName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRow()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetColumn()).compareTo(typedOther.isSetColumn()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetColumn()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(typedOther.isSetNumVersions()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNumVersions()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numVersions, typedOther.numVersions); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 1: // TABLE_NAME + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.tableName = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 2: // ROW + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.row = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 3: // COLUMN + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.column = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 4: // NUM_VERSIONS + if (field.type == org.apache.thrift.protocol.TType.I32) { + this.numVersions = iprot.readI32(); + setNumVersionsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (this.tableName != null) { + oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC); + oprot.writeBinary(this.tableName); + oprot.writeFieldEnd(); + } + if (this.row != null) { + oprot.writeFieldBegin(ROW_FIELD_DESC); + oprot.writeBinary(this.row); + oprot.writeFieldEnd(); + } + if (this.column != null) { + oprot.writeFieldBegin(COLUMN_FIELD_DESC); + oprot.writeBinary(this.column); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC); + oprot.writeI32(this.numVersions); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getVer_args("); + boolean first = true; + + sb.append("tableName:"); + if (this.tableName == null) { + sb.append("null"); + } else { + sb.append(this.tableName); + } + first = false; + if (!first) sb.append(", "); + sb.append("row:"); + if (this.row == null) { + sb.append("null"); + } else { + sb.append(this.row); + } + first = false; + if (!first) sb.append(", "); + sb.append("column:"); + if (this.column == null) { + sb.append("null"); + } else { + sb.append(this.column); + } + first = false; + if (!first) sb.append(", "); + sb.append("numVersions:"); + sb.append(this.numVersions); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + } + + public static class getVer_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVer_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); + private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + public List success; + public IOError io; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + IO((short)1, "io"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // IO + return IO; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)))); + tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVer_result.class, metaDataMap); + } + + public getVer_result() { + } + + public getVer_result( + List success, + IOError io) + { + this(); + this.success = success; + this.io = io; + } + + /** + * Performs a deep copy on other. + */ + public getVer_result(getVer_result other) { + if (other.isSetSuccess()) { + List __this__success = new ArrayList(); + for (TCell other_element : other.success) { + __this__success.add(new TCell(other_element)); + } + this.success = __this__success; + } + if (other.isSetIo()) { + this.io = new IOError(other.io); + } + } + + public getVer_result deepCopy() { + return new getVer_result(this); + } + + @Override + public void clear() { + this.success = null; + this.io = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public java.util.Iterator getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } + + public void addToSuccess(TCell elem) { + if (this.success == null) { + this.success = new ArrayList(); + } + this.success.add(elem); + } + + public List getSuccess() { + return this.success; + } + + public getVer_result setSuccess(List success) { + this.success = success; + return this; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public IOError getIo() { + return this.io; + } + + public getVer_result setIo(IOError io) { + this.io = io; + return this; + } + + public void unsetIo() { + this.io = null; + } + + /** Returns true if field io is set (has been assigned a value) and false otherwise */ + public boolean isSetIo() { + return this.io != null; + } + + public void setIoIsSet(boolean value) { + if (!value) { + this.io = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List)value); + } + break; + + case IO: + if (value == null) { + unsetIo(); + } else { + setIo((IOError)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case IO: + return getIo(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case IO: + return isSetIo(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getVer_result) + return this.equals((getVer_result)that); + return false; + } + + public boolean equals(getVer_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + boolean this_present_io = true && this.isSetIo(); + boolean that_present_io = true && that.isSetIo(); + if (this_present_io || that_present_io) { + if (!(this_present_io && that_present_io)) + return false; + if (!this.io.equals(that.io)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(getVer_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + getVer_result typedOther = (getVer_result)other; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIo()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 0: // SUCCESS + if (field.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list30 = iprot.readListBegin(); + this.success = new ArrayList(_list30.size); + for (int _i31 = 0; _i31 < _list30.size; ++_i31) + { + TCell _elem32; + _elem32 = new TCell(); + _elem32.read(iprot); + this.success.add(_elem32); + } + iprot.readListEnd(); + } + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 1: // IO + if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + this.io = new IOError(); + this.io.read(iprot); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + oprot.writeStructBegin(STRUCT_DESC); + + if (this.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + for (TCell _iter33 : this.success) + { + _iter33.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } else if (this.isSetIo()) { + oprot.writeFieldBegin(IO_FIELD_DESC); + this.io.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getVer_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("io:"); + if (this.io == null) { + sb.append("null"); + } else { + sb.append(this.io); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + } + + public static class getVerTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVerTs_args"); + + private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); + private static final org.apache.thrift.protocol.TField NUM_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("numVersions", org.apache.thrift.protocol.TType.I32, (short)5); + + /** + * name of table + */ + public ByteBuffer tableName; + /** + * row key + */ + public ByteBuffer row; + /** + * column name + */ + public ByteBuffer column; + /** + * timestamp + */ + public long timestamp; + /** + * number of versions to retrieve + */ + public int numVersions; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + /** + * name of table + */ + TABLE_NAME((short)1, "tableName"), + /** + * row key + */ + ROW((short)2, "row"), + /** + * column name + */ + COLUMN((short)3, "column"), + /** + * timestamp + */ + TIMESTAMP((short)4, "timestamp"), + /** + * number of versions to retrieve + */ + NUM_VERSIONS((short)5, "numVersions"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // TABLE_NAME + return TABLE_NAME; + case 2: // ROW + return ROW; + case 3: // COLUMN + return COLUMN; + case 4: // TIMESTAMP + return TIMESTAMP; + case 5: // NUM_VERSIONS + return NUM_VERSIONS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __TIMESTAMP_ISSET_ID = 0; + private static final int __NUMVERSIONS_ISSET_ID = 1; + private BitSet __isset_bit_vector = new BitSet(2); + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.NUM_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("numVersions", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVerTs_args.class, metaDataMap); + } + + public getVerTs_args() { + } + + public getVerTs_args( + ByteBuffer tableName, + ByteBuffer row, + ByteBuffer column, + long timestamp, + int numVersions) + { + this(); + this.tableName = tableName; + this.row = row; + this.column = column; + this.timestamp = timestamp; + setTimestampIsSet(true); + this.numVersions = numVersions; + setNumVersionsIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public getVerTs_args(getVerTs_args other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + if (other.isSetTableName()) { + this.tableName = other.tableName; + } + if (other.isSetRow()) { + this.row = other.row; + } + if (other.isSetColumn()) { + this.column = other.column; + } + this.timestamp = other.timestamp; + this.numVersions = other.numVersions; + } + + public getVerTs_args deepCopy() { + return new getVerTs_args(this); + } + + @Override + public void clear() { + this.tableName = null; + this.row = null; + this.column = null; + setTimestampIsSet(false); + this.timestamp = 0; + setNumVersionsIsSet(false); + this.numVersions = 0; + } + + /** + * name of table + */ + public byte[] getTableName() { + setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); + return tableName == null ? null : tableName.array(); + } + + public ByteBuffer bufferForTableName() { + return tableName; + } + + /** + * name of table + */ + public getVerTs_args setTableName(byte[] tableName) { + setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); + return this; + } + + public getVerTs_args setTableName(ByteBuffer tableName) { + this.tableName = tableName; + return this; + } + + public void unsetTableName() { + this.tableName = null; + } + + /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + public boolean isSetTableName() { + return this.tableName != null; + } + + public void setTableNameIsSet(boolean value) { + if (!value) { + this.tableName = null; + } + } + + /** + * row key + */ + public byte[] getRow() { + setRow(org.apache.thrift.TBaseHelper.rightSize(row)); + return row == null ? null : row.array(); + } + + public ByteBuffer bufferForRow() { + return row; + } + + /** + * row key + */ + public getVerTs_args setRow(byte[] row) { + setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + return this; + } + + public getVerTs_args setRow(ByteBuffer row) { + this.row = row; + return this; + } + + public void unsetRow() { + this.row = null; + } + + /** Returns true if field row is set (has been assigned a value) and false otherwise */ + public boolean isSetRow() { + return this.row != null; + } + + public void setRowIsSet(boolean value) { + if (!value) { + this.row = null; + } + } + + /** + * column name + */ + public byte[] getColumn() { + setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); + return column == null ? null : column.array(); + } + + public ByteBuffer bufferForColumn() { + return column; + } + + /** + * column name + */ + public getVerTs_args setColumn(byte[] column) { + setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); + return this; + } + + public getVerTs_args setColumn(ByteBuffer column) { + this.column = column; + return this; + } + + public void unsetColumn() { + this.column = null; + } + + /** Returns true if field column is set (has been assigned a value) and false otherwise */ + public boolean isSetColumn() { + return this.column != null; + } + + public void setColumnIsSet(boolean value) { + if (!value) { + this.column = null; + } + } + + /** + * timestamp + */ + public long getTimestamp() { + return this.timestamp; + } + + /** + * timestamp + */ + public getVerTs_args setTimestamp(long timestamp) { + this.timestamp = timestamp; + setTimestampIsSet(true); + return this; + } + + public void unsetTimestamp() { + __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); + } + + /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + public boolean isSetTimestamp() { + return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); + } + + public void setTimestampIsSet(boolean value) { + __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value); + } + + /** + * number of versions to retrieve + */ + public int getNumVersions() { + return this.numVersions; + } + + /** + * number of versions to retrieve + */ + public getVerTs_args setNumVersions(int numVersions) { + this.numVersions = numVersions; + setNumVersionsIsSet(true); + return this; + } + + public void unsetNumVersions() { + __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID); + } + + /** Returns true if field numVersions is set (has been assigned a value) and false otherwise */ + public boolean isSetNumVersions() { + return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID); + } + + public void setNumVersionsIsSet(boolean value) { + __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TABLE_NAME: + if (value == null) { + unsetTableName(); + } else { + setTableName((ByteBuffer)value); + } + break; + + case ROW: + if (value == null) { + unsetRow(); + } else { + setRow((ByteBuffer)value); + } + break; + + case COLUMN: + if (value == null) { + unsetColumn(); + } else { + setColumn((ByteBuffer)value); + } + break; + + case TIMESTAMP: + if (value == null) { + unsetTimestamp(); + } else { + setTimestamp((Long)value); + } + break; + + case NUM_VERSIONS: + if (value == null) { + unsetNumVersions(); + } else { + setNumVersions((Integer)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TABLE_NAME: + return getTableName(); + + case ROW: + return getRow(); + + case COLUMN: + return getColumn(); + + case TIMESTAMP: + return new Long(getTimestamp()); + + case NUM_VERSIONS: + return new Integer(getNumVersions()); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TABLE_NAME: + return isSetTableName(); + case ROW: + return isSetRow(); + case COLUMN: + return isSetColumn(); + case TIMESTAMP: + return isSetTimestamp(); + case NUM_VERSIONS: + return isSetNumVersions(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getVerTs_args) + return this.equals((getVerTs_args)that); + return false; + } + + public boolean equals(getVerTs_args that) { + if (that == null) + return false; + + boolean this_present_tableName = true && this.isSetTableName(); + boolean that_present_tableName = true && that.isSetTableName(); + if (this_present_tableName || that_present_tableName) { + if (!(this_present_tableName && that_present_tableName)) + return false; + if (!this.tableName.equals(that.tableName)) + return false; + } + + boolean this_present_row = true && this.isSetRow(); + boolean that_present_row = true && that.isSetRow(); + if (this_present_row || that_present_row) { + if (!(this_present_row && that_present_row)) + return false; + if (!this.row.equals(that.row)) + return false; + } + + boolean this_present_column = true && this.isSetColumn(); + boolean that_present_column = true && that.isSetColumn(); + if (this_present_column || that_present_column) { + if (!(this_present_column && that_present_column)) + return false; + if (!this.column.equals(that.column)) + return false; + } + + boolean this_present_timestamp = true; + boolean that_present_timestamp = true; + if (this_present_timestamp || that_present_timestamp) { + if (!(this_present_timestamp && that_present_timestamp)) + return false; + if (this.timestamp != that.timestamp) + return false; + } + + boolean this_present_numVersions = true; + boolean that_present_numVersions = true; + if (this_present_numVersions || that_present_numVersions) { + if (!(this_present_numVersions && that_present_numVersions)) + return false; + if (this.numVersions != that.numVersions) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(getVerTs_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + getVerTs_args typedOther = (getVerTs_args)other; + + lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTableName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRow()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetColumn()).compareTo(typedOther.isSetColumn()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetColumn()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(typedOther.isSetTimestamp()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTimestamp()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(typedOther.isSetNumVersions()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNumVersions()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numVersions, typedOther.numVersions); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 1: // TABLE_NAME + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.tableName = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 2: // ROW + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.row = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 3: // COLUMN + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.column = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 4: // TIMESTAMP + if (field.type == org.apache.thrift.protocol.TType.I64) { + this.timestamp = iprot.readI64(); + setTimestampIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 5: // NUM_VERSIONS + if (field.type == org.apache.thrift.protocol.TType.I32) { + this.numVersions = iprot.readI32(); + setNumVersionsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (this.tableName != null) { + oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC); + oprot.writeBinary(this.tableName); + oprot.writeFieldEnd(); + } + if (this.row != null) { + oprot.writeFieldBegin(ROW_FIELD_DESC); + oprot.writeBinary(this.row); + oprot.writeFieldEnd(); + } + if (this.column != null) { + oprot.writeFieldBegin(COLUMN_FIELD_DESC); + oprot.writeBinary(this.column); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC); + oprot.writeI64(this.timestamp); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC); + oprot.writeI32(this.numVersions); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getVerTs_args("); + boolean first = true; + + sb.append("tableName:"); + if (this.tableName == null) { + sb.append("null"); + } else { + sb.append(this.tableName); + } + first = false; + if (!first) sb.append(", "); + sb.append("row:"); + if (this.row == null) { + sb.append("null"); + } else { + sb.append(this.row); + } + first = false; + if (!first) sb.append(", "); + sb.append("column:"); + if (this.column == null) { + sb.append("null"); + } else { + sb.append(this.column); + } + first = false; + if (!first) sb.append(", "); + sb.append("timestamp:"); + sb.append(this.timestamp); + first = false; + if (!first) sb.append(", "); + sb.append("numVersions:"); + sb.append(this.numVersions); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + } + + public static class getVerTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVerTs_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); + private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + public List success; + public IOError io; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + IO((short)1, "io"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // IO + return IO; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)))); + tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVerTs_result.class, metaDataMap); + } + + public getVerTs_result() { + } + + public getVerTs_result( + List success, + IOError io) + { + this(); + this.success = success; + this.io = io; + } + + /** + * Performs a deep copy on other. + */ + public getVerTs_result(getVerTs_result other) { + if (other.isSetSuccess()) { + List __this__success = new ArrayList(); + for (TCell other_element : other.success) { + __this__success.add(new TCell(other_element)); + } + this.success = __this__success; + } + if (other.isSetIo()) { + this.io = new IOError(other.io); + } + } + + public getVerTs_result deepCopy() { + return new getVerTs_result(this); + } + + @Override + public void clear() { + this.success = null; + this.io = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public java.util.Iterator getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } + + public void addToSuccess(TCell elem) { + if (this.success == null) { + this.success = new ArrayList(); + } + this.success.add(elem); + } + + public List getSuccess() { + return this.success; + } + + public getVerTs_result setSuccess(List success) { + this.success = success; + return this; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public IOError getIo() { + return this.io; + } + + public getVerTs_result setIo(IOError io) { + this.io = io; + return this; + } + + public void unsetIo() { + this.io = null; + } + + /** Returns true if field io is set (has been assigned a value) and false otherwise */ + public boolean isSetIo() { + return this.io != null; + } + + public void setIoIsSet(boolean value) { + if (!value) { + this.io = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List)value); + } + break; + + case IO: + if (value == null) { + unsetIo(); + } else { + setIo((IOError)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case IO: + return getIo(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case IO: + return isSetIo(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getVerTs_result) + return this.equals((getVerTs_result)that); + return false; + } + + public boolean equals(getVerTs_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + boolean this_present_io = true && this.isSetIo(); + boolean that_present_io = true && that.isSetIo(); + if (this_present_io || that_present_io) { + if (!(this_present_io && that_present_io)) + return false; + if (!this.io.equals(that.io)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(getVerTs_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + getVerTs_result typedOther = (getVerTs_result)other; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIo()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.io, typedOther.io); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 0: // SUCCESS + if (field.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list34 = iprot.readListBegin(); + this.success = new ArrayList(_list34.size); + for (int _i35 = 0; _i35 < _list34.size; ++_i35) + { + TCell _elem36; + _elem36 = new TCell(); + _elem36.read(iprot); + this.success.add(_elem36); + } + iprot.readListEnd(); + } + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 1: // IO + if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + this.io = new IOError(); + this.io.read(iprot); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + oprot.writeStructBegin(STRUCT_DESC); + + if (this.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + for (TCell _iter37 : this.success) + { + _iter37.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } else if (this.isSetIo()) { + oprot.writeFieldBegin(IO_FIELD_DESC); + this.io.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getVerTs_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("io:"); + if (this.io == null) { + sb.append("null"); + } else { + sb.append(this.io); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + } + + public static class getRow_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRow_args"); + + private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); + + /** + * name of table + */ + public ByteBuffer tableName; + /** + * row key + */ + public ByteBuffer row; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + /** + * name of table + */ + TABLE_NAME((short)1, "tableName"), + /** + * row key + */ + ROW((short)2, "row"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // TABLE_NAME + return TABLE_NAME; + case 2: // ROW + return ROW; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRow_args.class, metaDataMap); } - public deleteTable_args() { + public getRow_args() { } - public deleteTable_args( - ByteBuffer tableName) + public getRow_args( + ByteBuffer tableName, + ByteBuffer row) { this(); this.tableName = tableName; + this.row = row; } /** * Performs a deep copy on other. */ - public deleteTable_args(deleteTable_args other) { + public getRow_args(getRow_args other) { if (other.isSetTableName()) { this.tableName = other.tableName; } + if (other.isSetRow()) { + this.row = other.row; + } } - public deleteTable_args deepCopy() { - return new deleteTable_args(this); + public getRow_args deepCopy() { + return new getRow_args(this); } @Override public void clear() { this.tableName = null; + this.row = null; } /** - * name of table to delete + * name of table */ public byte[] getTableName() { setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); @@ -11433,14 +15823,14 @@ public class Hbase { } /** - * name of table to delete + * name of table */ - public deleteTable_args setTableName(byte[] tableName) { + public getRow_args setTableName(byte[] tableName) { setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); return this; } - public deleteTable_args setTableName(ByteBuffer tableName) { + public getRow_args setTableName(ByteBuffer tableName) { this.tableName = tableName; return this; } @@ -11460,6 +15850,46 @@ public class Hbase { } } + /** + * row key + */ + public byte[] getRow() { + setRow(org.apache.thrift.TBaseHelper.rightSize(row)); + return row == null ? null : row.array(); + } + + public ByteBuffer bufferForRow() { + return row; + } + + /** + * row key + */ + public getRow_args setRow(byte[] row) { + setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + return this; + } + + public getRow_args setRow(ByteBuffer row) { + this.row = row; + return this; + } + + public void unsetRow() { + this.row = null; + } + + /** Returns true if field row is set (has been assigned a value) and false otherwise */ + public boolean isSetRow() { + return this.row != null; + } + + public void setRowIsSet(boolean value) { + if (!value) { + this.row = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TABLE_NAME: @@ -11470,6 +15900,14 @@ public class Hbase { } break; + case ROW: + if (value == null) { + unsetRow(); + } else { + setRow((ByteBuffer)value); + } + break; + } } @@ -11478,6 +15916,9 @@ public class Hbase { case TABLE_NAME: return getTableName(); + case ROW: + return getRow(); + } throw new IllegalStateException(); } @@ -11491,6 +15932,8 @@ public class Hbase { switch (field) { case TABLE_NAME: return isSetTableName(); + case ROW: + return isSetRow(); } throw new IllegalStateException(); } @@ -11499,12 +15942,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof deleteTable_args) - return this.equals((deleteTable_args)that); + if (that instanceof getRow_args) + return this.equals((getRow_args)that); return false; } - public boolean equals(deleteTable_args that) { + public boolean equals(getRow_args that) { if (that == null) return false; @@ -11517,6 +15960,15 @@ public class Hbase { return false; } + boolean this_present_row = true && this.isSetRow(); + boolean that_present_row = true && that.isSetRow(); + if (this_present_row || that_present_row) { + if (!(this_present_row && that_present_row)) + return false; + if (!this.row.equals(that.row)) + return false; + } + return true; } @@ -11525,13 +15977,13 @@ public class Hbase { return 0; } - public int compareTo(deleteTable_args other) { + public int compareTo(getRow_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - deleteTable_args typedOther = (deleteTable_args)other; + getRow_args typedOther = (getRow_args)other; lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); if (lastComparison != 0) { @@ -11543,6 +15995,16 @@ public class Hbase { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRow()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -11567,6 +16029,13 @@ public class Hbase { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; + case 2: // ROW + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.row = iprot.readBinary(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -11587,13 +16056,18 @@ public class Hbase { oprot.writeBinary(this.tableName); oprot.writeFieldEnd(); } + if (this.row != null) { + oprot.writeFieldBegin(ROW_FIELD_DESC); + oprot.writeBinary(this.row); + oprot.writeFieldEnd(); + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @Override public String toString() { - StringBuilder sb = new StringBuilder("deleteTable_args("); + StringBuilder sb = new StringBuilder("getRow_args("); boolean first = true; sb.append("tableName:"); @@ -11603,6 +16077,14 @@ public class Hbase { sb.append(this.tableName); } first = false; + if (!first) sb.append(", "); + sb.append("row:"); + if (this.row == null) { + sb.append("null"); + } else { + sb.append(this.row); + } + first = false; sb.append(")"); return sb.toString(); } @@ -11629,15 +16111,18 @@ public class Hbase { } - public static class deleteTable_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteTable_result"); + public static class getRow_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRow_result"); + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); + public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), IO((short)1, "io"); private static final Map byName = new HashMap(); @@ -11653,6 +16138,8 @@ public class Hbase { */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; case 1: // IO return IO; default: @@ -11699,45 +16186,97 @@ public class Hbase { public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteTable_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRow_result.class, metaDataMap); } - public deleteTable_result() { + public getRow_result() { } - public deleteTable_result( + public getRow_result( + List success, IOError io) { this(); + this.success = success; this.io = io; } /** * Performs a deep copy on other. */ - public deleteTable_result(deleteTable_result other) { + public getRow_result(getRow_result other) { + if (other.isSetSuccess()) { + List __this__success = new ArrayList(); + for (TRowResult other_element : other.success) { + __this__success.add(new TRowResult(other_element)); + } + this.success = __this__success; + } if (other.isSetIo()) { this.io = new IOError(other.io); } } - public deleteTable_result deepCopy() { - return new deleteTable_result(this); + public getRow_result deepCopy() { + return new getRow_result(this); } @Override public void clear() { + this.success = null; this.io = null; } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public java.util.Iterator getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } + + public void addToSuccess(TRowResult elem) { + if (this.success == null) { + this.success = new ArrayList(); + } + this.success.add(elem); + } + + public List getSuccess() { + return this.success; + } + + public getRow_result setSuccess(List success) { + this.success = success; + return this; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + public IOError getIo() { return this.io; } - public deleteTable_result setIo(IOError io) { + public getRow_result setIo(IOError io) { this.io = io; return this; } @@ -11759,6 +16298,14 @@ public class Hbase { public void setFieldValue(_Fields field, Object value) { switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List)value); + } + break; + case IO: if (value == null) { unsetIo(); @@ -11772,6 +16319,9 @@ public class Hbase { public Object getFieldValue(_Fields field) { switch (field) { + case SUCCESS: + return getSuccess(); + case IO: return getIo(); @@ -11786,6 +16336,8 @@ public class Hbase { } switch (field) { + case SUCCESS: + return isSetSuccess(); case IO: return isSetIo(); } @@ -11796,15 +16348,24 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof deleteTable_result) - return this.equals((deleteTable_result)that); + if (that instanceof getRow_result) + return this.equals((getRow_result)that); return false; } - public boolean equals(deleteTable_result that) { + public boolean equals(getRow_result that) { if (that == null) return false; + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + boolean this_present_io = true && this.isSetIo(); boolean that_present_io = true && that.isSetIo(); if (this_present_io || that_present_io) { @@ -11822,14 +16383,24 @@ public class Hbase { return 0; } - public int compareTo(deleteTable_result other) { + public int compareTo(getRow_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - deleteTable_result typedOther = (deleteTable_result)other; + getRow_result typedOther = (getRow_result)other; + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + if (lastComparison != 0) { + return lastComparison; + } + } lastComparison = Boolean.valueOf(isSetIo()).compareTo(typedOther.isSetIo()); if (lastComparison != 0) { return lastComparison; @@ -11857,6 +16428,24 @@ public class Hbase { break; } switch (field.id) { + case 0: // SUCCESS + if (field.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list38 = iprot.readListBegin(); + this.success = new ArrayList(_list38.size); + for (int _i39 = 0; _i39 < _list38.size; ++_i39) + { + TRowResult _elem40; + _elem40 = new TRowResult(); + _elem40.read(iprot); + this.success.add(_elem40); + } + iprot.readListEnd(); + } + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; case 1: // IO if (field.type == org.apache.thrift.protocol.TType.STRUCT) { this.io = new IOError(); @@ -11879,7 +16468,18 @@ public class Hbase { public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { oprot.writeStructBegin(STRUCT_DESC); - if (this.isSetIo()) { + if (this.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); + for (TRowResult _iter41 : this.success) + { + _iter41.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } else if (this.isSetIo()) { oprot.writeFieldBegin(IO_FIELD_DESC); this.io.write(oprot); oprot.writeFieldEnd(); @@ -11890,9 +16490,17 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("deleteTable_result("); + StringBuilder sb = new StringBuilder("getRow_result("); boolean first = true; + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); sb.append("io:"); if (this.io == null) { sb.append("null"); @@ -11926,12 +16534,12 @@ public class Hbase { } - public static class get_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_args"); + public static class getRowWithColumns_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumns_args"); private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); /** * name of table @@ -11942,9 +16550,9 @@ public class Hbase { */ public ByteBuffer row; /** - * column name + * List of columns to return, null for all columns */ - public ByteBuffer column; + public List columns; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -11957,9 +16565,9 @@ public class Hbase { */ ROW((short)2, "row"), /** - * column name + * List of columns to return, null for all columns */ - COLUMN((short)3, "column"); + COLUMNS((short)3, "columns"); private static final Map byName = new HashMap(); @@ -11978,8 +16586,8 @@ public class Hbase { return TABLE_NAME; case 2: // ROW return ROW; - case 3: // COLUMN - return COLUMN; + case 3: // COLUMNS + return COLUMNS; default: return null; } @@ -12028,50 +16636,55 @@ public class Hbase { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumns_args.class, metaDataMap); } - public get_args() { + public getRowWithColumns_args() { } - public get_args( + public getRowWithColumns_args( ByteBuffer tableName, ByteBuffer row, - ByteBuffer column) + List columns) { this(); this.tableName = tableName; this.row = row; - this.column = column; + this.columns = columns; } /** * Performs a deep copy on other. */ - public get_args(get_args other) { + public getRowWithColumns_args(getRowWithColumns_args other) { if (other.isSetTableName()) { this.tableName = other.tableName; } if (other.isSetRow()) { this.row = other.row; } - if (other.isSetColumn()) { - this.column = other.column; + if (other.isSetColumns()) { + List __this__columns = new ArrayList(); + for (ByteBuffer other_element : other.columns) { + __this__columns.add(other_element); + } + this.columns = __this__columns; } } - public get_args deepCopy() { - return new get_args(this); + public getRowWithColumns_args deepCopy() { + return new getRowWithColumns_args(this); } @Override public void clear() { this.tableName = null; this.row = null; - this.column = null; + this.columns = null; } /** @@ -12089,12 +16702,12 @@ public class Hbase { /** * name of table */ - public get_args setTableName(byte[] tableName) { + public getRowWithColumns_args setTableName(byte[] tableName) { setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); return this; } - public get_args setTableName(ByteBuffer tableName) { + public getRowWithColumns_args setTableName(ByteBuffer tableName) { this.tableName = tableName; return this; } @@ -12129,12 +16742,12 @@ public class Hbase { /** * row key */ - public get_args setRow(byte[] row) { + public getRowWithColumns_args setRow(byte[] row) { setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); return this; } - public get_args setRow(ByteBuffer row) { + public getRowWithColumns_args setRow(ByteBuffer row) { this.row = row; return this; } @@ -12154,43 +16767,48 @@ public class Hbase { } } - /** - * column name - */ - public byte[] getColumn() { - setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); - return column == null ? null : column.array(); + public int getColumnsSize() { + return (this.columns == null) ? 0 : this.columns.size(); } - public ByteBuffer bufferForColumn() { - return column; + public java.util.Iterator getColumnsIterator() { + return (this.columns == null) ? null : this.columns.iterator(); + } + + public void addToColumns(ByteBuffer elem) { + if (this.columns == null) { + this.columns = new ArrayList(); + } + this.columns.add(elem); } /** - * column name + * List of columns to return, null for all columns */ - public get_args setColumn(byte[] column) { - setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); - return this; + public List getColumns() { + return this.columns; } - public get_args setColumn(ByteBuffer column) { - this.column = column; + /** + * List of columns to return, null for all columns + */ + public getRowWithColumns_args setColumns(List columns) { + this.columns = columns; return this; } - public void unsetColumn() { - this.column = null; + public void unsetColumns() { + this.columns = null; } - /** Returns true if field column is set (has been assigned a value) and false otherwise */ - public boolean isSetColumn() { - return this.column != null; + /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + public boolean isSetColumns() { + return this.columns != null; } - public void setColumnIsSet(boolean value) { + public void setColumnsIsSet(boolean value) { if (!value) { - this.column = null; + this.columns = null; } } @@ -12212,11 +16830,11 @@ public class Hbase { } break; - case COLUMN: + case COLUMNS: if (value == null) { - unsetColumn(); + unsetColumns(); } else { - setColumn((ByteBuffer)value); + setColumns((List)value); } break; @@ -12231,8 +16849,8 @@ public class Hbase { case ROW: return getRow(); - case COLUMN: - return getColumn(); + case COLUMNS: + return getColumns(); } throw new IllegalStateException(); @@ -12249,8 +16867,8 @@ public class Hbase { return isSetTableName(); case ROW: return isSetRow(); - case COLUMN: - return isSetColumn(); + case COLUMNS: + return isSetColumns(); } throw new IllegalStateException(); } @@ -12259,12 +16877,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_args) - return this.equals((get_args)that); + if (that instanceof getRowWithColumns_args) + return this.equals((getRowWithColumns_args)that); return false; } - public boolean equals(get_args that) { + public boolean equals(getRowWithColumns_args that) { if (that == null) return false; @@ -12286,12 +16904,12 @@ public class Hbase { return false; } - boolean this_present_column = true && this.isSetColumn(); - boolean that_present_column = true && that.isSetColumn(); - if (this_present_column || that_present_column) { - if (!(this_present_column && that_present_column)) + boolean this_present_columns = true && this.isSetColumns(); + boolean that_present_columns = true && that.isSetColumns(); + if (this_present_columns || that_present_columns) { + if (!(this_present_columns && that_present_columns)) return false; - if (!this.column.equals(that.column)) + if (!this.columns.equals(that.columns)) return false; } @@ -12303,13 +16921,13 @@ public class Hbase { return 0; } - public int compareTo(get_args other) { + public int compareTo(getRowWithColumns_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - get_args typedOther = (get_args)other; + getRowWithColumns_args typedOther = (getRowWithColumns_args)other; lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); if (lastComparison != 0) { @@ -12331,12 +16949,12 @@ public class Hbase { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetColumn()).compareTo(typedOther.isSetColumn()); + lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns()); if (lastComparison != 0) { return lastComparison; } - if (isSetColumn()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + if (isSetColumns()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -12372,9 +16990,19 @@ public class Hbase { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; - case 3: // COLUMN - if (field.type == org.apache.thrift.protocol.TType.STRING) { - this.column = iprot.readBinary(); + case 3: // COLUMNS + if (field.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list42 = iprot.readListBegin(); + this.columns = new ArrayList(_list42.size); + for (int _i43 = 0; _i43 < _list42.size; ++_i43) + { + ByteBuffer _elem44; + _elem44 = iprot.readBinary(); + this.columns.add(_elem44); + } + iprot.readListEnd(); + } } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -12404,9 +17032,16 @@ public class Hbase { oprot.writeBinary(this.row); oprot.writeFieldEnd(); } - if (this.column != null) { - oprot.writeFieldBegin(COLUMN_FIELD_DESC); - oprot.writeBinary(this.column); + if (this.columns != null) { + oprot.writeFieldBegin(COLUMNS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + for (ByteBuffer _iter45 : this.columns) + { + oprot.writeBinary(_iter45); + } + oprot.writeListEnd(); + } oprot.writeFieldEnd(); } oprot.writeFieldStop(); @@ -12415,7 +17050,7 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("get_args("); + StringBuilder sb = new StringBuilder("getRowWithColumns_args("); boolean first = true; sb.append("tableName:"); @@ -12434,11 +17069,11 @@ public class Hbase { } first = false; if (!first) sb.append(", "); - sb.append("column:"); - if (this.column == null) { + sb.append("columns:"); + if (this.columns == null) { sb.append("null"); } else { - sb.append(this.column); + sb.append(this.columns); } first = false; sb.append(")"); @@ -12467,13 +17102,13 @@ public class Hbase { } - public static class get_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_result"); + public static class getRowWithColumns_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumns_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); - public List success; + public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -12544,18 +17179,18 @@ public class Hbase { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumns_result.class, metaDataMap); } - public get_result() { + public getRowWithColumns_result() { } - public get_result( - List success, + public getRowWithColumns_result( + List success, IOError io) { this(); @@ -12566,11 +17201,11 @@ public class Hbase { /** * Performs a deep copy on other. */ - public get_result(get_result other) { + public getRowWithColumns_result(getRowWithColumns_result other) { if (other.isSetSuccess()) { - List __this__success = new ArrayList(); - for (TCell other_element : other.success) { - __this__success.add(new TCell(other_element)); + List __this__success = new ArrayList(); + for (TRowResult other_element : other.success) { + __this__success.add(new TRowResult(other_element)); } this.success = __this__success; } @@ -12579,8 +17214,8 @@ public class Hbase { } } - public get_result deepCopy() { - return new get_result(this); + public getRowWithColumns_result deepCopy() { + return new getRowWithColumns_result(this); } @Override @@ -12593,22 +17228,22 @@ public class Hbase { return (this.success == null) ? 0 : this.success.size(); } - public java.util.Iterator getSuccessIterator() { + public java.util.Iterator getSuccessIterator() { return (this.success == null) ? null : this.success.iterator(); } - public void addToSuccess(TCell elem) { + public void addToSuccess(TRowResult elem) { if (this.success == null) { - this.success = new ArrayList(); + this.success = new ArrayList(); } this.success.add(elem); } - public List getSuccess() { + public List getSuccess() { return this.success; } - public get_result setSuccess(List success) { + public getRowWithColumns_result setSuccess(List success) { this.success = success; return this; } @@ -12632,7 +17267,7 @@ public class Hbase { return this.io; } - public get_result setIo(IOError io) { + public getRowWithColumns_result setIo(IOError io) { this.io = io; return this; } @@ -12658,7 +17293,7 @@ public class Hbase { if (value == null) { unsetSuccess(); } else { - setSuccess((List)value); + setSuccess((List)value); } break; @@ -12704,12 +17339,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_result) - return this.equals((get_result)that); + if (that instanceof getRowWithColumns_result) + return this.equals((getRowWithColumns_result)that); return false; } - public boolean equals(get_result that) { + public boolean equals(getRowWithColumns_result that) { if (that == null) return false; @@ -12739,13 +17374,13 @@ public class Hbase { return 0; } - public int compareTo(get_result other) { + public int compareTo(getRowWithColumns_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - get_result typedOther = (get_result)other; + getRowWithColumns_result typedOther = (getRowWithColumns_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -12787,14 +17422,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list26 = iprot.readListBegin(); - this.success = new ArrayList(_list26.size); - for (int _i27 = 0; _i27 < _list26.size; ++_i27) + org.apache.thrift.protocol.TList _list46 = iprot.readListBegin(); + this.success = new ArrayList(_list46.size); + for (int _i47 = 0; _i47 < _list46.size; ++_i47) { - TCell _elem28; - _elem28 = new TCell(); - _elem28.read(iprot); - this.success.add(_elem28); + TRowResult _elem48; + _elem48 = new TRowResult(); + _elem48.read(iprot); + this.success.add(_elem48); } iprot.readListEnd(); } @@ -12828,9 +17463,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TCell _iter29 : this.success) + for (TRowResult _iter49 : this.success) { - _iter29.write(oprot); + _iter49.write(oprot); } oprot.writeListEnd(); } @@ -12846,7 +17481,7 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("get_result("); + StringBuilder sb = new StringBuilder("getRowWithColumns_result("); boolean first = true; sb.append("success:"); @@ -12890,30 +17525,29 @@ public class Hbase { } - public static class getVer_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVer_args"); + public static class getRowWithColumnsPaginated_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsPaginated_args"); private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField NUM_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("numVersions", org.apache.thrift.protocol.TType.I32, (short)4); + private static final org.apache.thrift.protocol.TField ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("rows", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I32, (short)4); + private static final org.apache.thrift.protocol.TField OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("offset", org.apache.thrift.protocol.TType.I32, (short)5); /** * name of table */ public ByteBuffer tableName; /** - * row key - */ - public ByteBuffer row; - /** - * column name + * row keys */ - public ByteBuffer column; + public ByteBuffer rows; /** - * number of versions to retrieve + * List of columns to return, null for all columns */ - public int numVersions; + public List columns; + public int limit; + public int offset; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -12922,17 +17556,15 @@ public class Hbase { */ TABLE_NAME((short)1, "tableName"), /** - * row key - */ - ROW((short)2, "row"), - /** - * column name + * row keys */ - COLUMN((short)3, "column"), + ROWS((short)2, "rows"), /** - * number of versions to retrieve + * List of columns to return, null for all columns */ - NUM_VERSIONS((short)4, "numVersions"); + COLUMNS((short)3, "columns"), + LIMIT((short)4, "limit"), + OFFSET((short)5, "offset"); private static final Map byName = new HashMap(); @@ -12949,12 +17581,14 @@ public class Hbase { switch(fieldId) { case 1: // TABLE_NAME return TABLE_NAME; - case 2: // ROW - return ROW; - case 3: // COLUMN - return COLUMN; - case 4: // NUM_VERSIONS - return NUM_VERSIONS; + case 2: // ROWS + return ROWS; + case 3: // COLUMNS + return COLUMNS; + case 4: // LIMIT + return LIMIT; + case 5: // OFFSET + return OFFSET; default: return null; } @@ -12995,70 +17629,84 @@ public class Hbase { } // isset id assignments - private static final int __NUMVERSIONS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); + private static final int __LIMIT_ISSET_ID = 0; + private static final int __OFFSET_ISSET_ID = 1; + private BitSet __isset_bit_vector = new BitSet(2); public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, + tmpMap.put(_Fields.ROWS, new org.apache.thrift.meta_data.FieldMetaData("rows", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.NUM_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("numVersions", org.apache.thrift.TFieldRequirementType.DEFAULT, + tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); + tmpMap.put(_Fields.LIMIT, new org.apache.thrift.meta_data.FieldMetaData("limit", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.OFFSET, new org.apache.thrift.meta_data.FieldMetaData("offset", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVer_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsPaginated_args.class, metaDataMap); } - public getVer_args() { + public getRowWithColumnsPaginated_args() { } - public getVer_args( + public getRowWithColumnsPaginated_args( ByteBuffer tableName, - ByteBuffer row, - ByteBuffer column, - int numVersions) + ByteBuffer rows, + List columns, + int limit, + int offset) { this(); this.tableName = tableName; - this.row = row; - this.column = column; - this.numVersions = numVersions; - setNumVersionsIsSet(true); + this.rows = rows; + this.columns = columns; + this.limit = limit; + setLimitIsSet(true); + this.offset = offset; + setOffsetIsSet(true); } /** * Performs a deep copy on other. */ - public getVer_args(getVer_args other) { + public getRowWithColumnsPaginated_args(getRowWithColumnsPaginated_args other) { __isset_bit_vector.clear(); __isset_bit_vector.or(other.__isset_bit_vector); if (other.isSetTableName()) { this.tableName = other.tableName; } - if (other.isSetRow()) { - this.row = other.row; + if (other.isSetRows()) { + this.rows = other.rows; } - if (other.isSetColumn()) { - this.column = other.column; + if (other.isSetColumns()) { + List __this__columns = new ArrayList(); + for (ByteBuffer other_element : other.columns) { + __this__columns.add(other_element); + } + this.columns = __this__columns; } - this.numVersions = other.numVersions; + this.limit = other.limit; + this.offset = other.offset; } - public getVer_args deepCopy() { - return new getVer_args(this); + public getRowWithColumnsPaginated_args deepCopy() { + return new getRowWithColumnsPaginated_args(this); } @Override public void clear() { this.tableName = null; - this.row = null; - this.column = null; - setNumVersionsIsSet(false); - this.numVersions = 0; + this.rows = null; + this.columns = null; + setLimitIsSet(false); + this.limit = 0; + setOffsetIsSet(false); + this.offset = 0; } /** @@ -13076,12 +17724,12 @@ public class Hbase { /** * name of table */ - public getVer_args setTableName(byte[] tableName) { + public getRowWithColumnsPaginated_args setTableName(byte[] tableName) { setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); return this; } - public getVer_args setTableName(ByteBuffer tableName) { + public getRowWithColumnsPaginated_args setTableName(ByteBuffer tableName) { this.tableName = tableName; return this; } @@ -13102,112 +17750,134 @@ public class Hbase { } /** - * row key + * row keys */ - public byte[] getRow() { - setRow(org.apache.thrift.TBaseHelper.rightSize(row)); - return row == null ? null : row.array(); + public byte[] getRows() { + setRows(org.apache.thrift.TBaseHelper.rightSize(rows)); + return rows == null ? null : rows.array(); } - public ByteBuffer bufferForRow() { - return row; + public ByteBuffer bufferForRows() { + return rows; } /** - * row key + * row keys */ - public getVer_args setRow(byte[] row) { - setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); + public getRowWithColumnsPaginated_args setRows(byte[] rows) { + setRows(rows == null ? (ByteBuffer)null : ByteBuffer.wrap(rows)); return this; } - public getVer_args setRow(ByteBuffer row) { - this.row = row; + public getRowWithColumnsPaginated_args setRows(ByteBuffer rows) { + this.rows = rows; return this; } - public void unsetRow() { - this.row = null; + public void unsetRows() { + this.rows = null; } - /** Returns true if field row is set (has been assigned a value) and false otherwise */ - public boolean isSetRow() { - return this.row != null; + /** Returns true if field rows is set (has been assigned a value) and false otherwise */ + public boolean isSetRows() { + return this.rows != null; } - public void setRowIsSet(boolean value) { + public void setRowsIsSet(boolean value) { if (!value) { - this.row = null; + this.rows = null; } } - /** - * column name - */ - public byte[] getColumn() { - setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); - return column == null ? null : column.array(); + public int getColumnsSize() { + return (this.columns == null) ? 0 : this.columns.size(); } - public ByteBuffer bufferForColumn() { - return column; + public java.util.Iterator getColumnsIterator() { + return (this.columns == null) ? null : this.columns.iterator(); + } + + public void addToColumns(ByteBuffer elem) { + if (this.columns == null) { + this.columns = new ArrayList(); + } + this.columns.add(elem); } /** - * column name + * List of columns to return, null for all columns */ - public getVer_args setColumn(byte[] column) { - setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); - return this; + public List getColumns() { + return this.columns; } - public getVer_args setColumn(ByteBuffer column) { - this.column = column; + /** + * List of columns to return, null for all columns + */ + public getRowWithColumnsPaginated_args setColumns(List columns) { + this.columns = columns; return this; } - public void unsetColumn() { - this.column = null; + public void unsetColumns() { + this.columns = null; } - /** Returns true if field column is set (has been assigned a value) and false otherwise */ - public boolean isSetColumn() { - return this.column != null; + /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + public boolean isSetColumns() { + return this.columns != null; } - public void setColumnIsSet(boolean value) { + public void setColumnsIsSet(boolean value) { if (!value) { - this.column = null; + this.columns = null; } } - /** - * number of versions to retrieve - */ - public int getNumVersions() { - return this.numVersions; + public int getLimit() { + return this.limit; } - /** - * number of versions to retrieve - */ - public getVer_args setNumVersions(int numVersions) { - this.numVersions = numVersions; - setNumVersionsIsSet(true); + public getRowWithColumnsPaginated_args setLimit(int limit) { + this.limit = limit; + setLimitIsSet(true); return this; } - public void unsetNumVersions() { - __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID); + public void unsetLimit() { + __isset_bit_vector.clear(__LIMIT_ISSET_ID); } - /** Returns true if field numVersions is set (has been assigned a value) and false otherwise */ - public boolean isSetNumVersions() { - return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID); + /** Returns true if field limit is set (has been assigned a value) and false otherwise */ + public boolean isSetLimit() { + return __isset_bit_vector.get(__LIMIT_ISSET_ID); } - public void setNumVersionsIsSet(boolean value) { - __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value); + public void setLimitIsSet(boolean value) { + __isset_bit_vector.set(__LIMIT_ISSET_ID, value); + } + + public int getOffset() { + return this.offset; + } + + public getRowWithColumnsPaginated_args setOffset(int offset) { + this.offset = offset; + setOffsetIsSet(true); + return this; + } + + public void unsetOffset() { + __isset_bit_vector.clear(__OFFSET_ISSET_ID); + } + + /** Returns true if field offset is set (has been assigned a value) and false otherwise */ + public boolean isSetOffset() { + return __isset_bit_vector.get(__OFFSET_ISSET_ID); + } + + public void setOffsetIsSet(boolean value) { + __isset_bit_vector.set(__OFFSET_ISSET_ID, value); } public void setFieldValue(_Fields field, Object value) { @@ -13220,27 +17890,35 @@ public class Hbase { } break; - case ROW: + case ROWS: if (value == null) { - unsetRow(); + unsetRows(); } else { - setRow((ByteBuffer)value); + setRows((ByteBuffer)value); } break; - case COLUMN: + case COLUMNS: if (value == null) { - unsetColumn(); + unsetColumns(); } else { - setColumn((ByteBuffer)value); + setColumns((List)value); } break; - case NUM_VERSIONS: + case LIMIT: if (value == null) { - unsetNumVersions(); + unsetLimit(); } else { - setNumVersions((Integer)value); + setLimit((Integer)value); + } + break; + + case OFFSET: + if (value == null) { + unsetOffset(); + } else { + setOffset((Integer)value); } break; @@ -13252,14 +17930,17 @@ public class Hbase { case TABLE_NAME: return getTableName(); - case ROW: - return getRow(); + case ROWS: + return getRows(); - case COLUMN: - return getColumn(); + case COLUMNS: + return getColumns(); - case NUM_VERSIONS: - return new Integer(getNumVersions()); + case LIMIT: + return new Integer(getLimit()); + + case OFFSET: + return new Integer(getOffset()); } throw new IllegalStateException(); @@ -13274,12 +17955,14 @@ public class Hbase { switch (field) { case TABLE_NAME: return isSetTableName(); - case ROW: - return isSetRow(); - case COLUMN: - return isSetColumn(); - case NUM_VERSIONS: - return isSetNumVersions(); + case ROWS: + return isSetRows(); + case COLUMNS: + return isSetColumns(); + case LIMIT: + return isSetLimit(); + case OFFSET: + return isSetOffset(); } throw new IllegalStateException(); } @@ -13288,12 +17971,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getVer_args) - return this.equals((getVer_args)that); + if (that instanceof getRowWithColumnsPaginated_args) + return this.equals((getRowWithColumnsPaginated_args)that); return false; } - public boolean equals(getVer_args that) { + public boolean equals(getRowWithColumnsPaginated_args that) { if (that == null) return false; @@ -13306,30 +17989,39 @@ public class Hbase { return false; } - boolean this_present_row = true && this.isSetRow(); - boolean that_present_row = true && that.isSetRow(); - if (this_present_row || that_present_row) { - if (!(this_present_row && that_present_row)) + boolean this_present_rows = true && this.isSetRows(); + boolean that_present_rows = true && that.isSetRows(); + if (this_present_rows || that_present_rows) { + if (!(this_present_rows && that_present_rows)) return false; - if (!this.row.equals(that.row)) + if (!this.rows.equals(that.rows)) return false; } - boolean this_present_column = true && this.isSetColumn(); - boolean that_present_column = true && that.isSetColumn(); - if (this_present_column || that_present_column) { - if (!(this_present_column && that_present_column)) + boolean this_present_columns = true && this.isSetColumns(); + boolean that_present_columns = true && that.isSetColumns(); + if (this_present_columns || that_present_columns) { + if (!(this_present_columns && that_present_columns)) return false; - if (!this.column.equals(that.column)) + if (!this.columns.equals(that.columns)) return false; } - boolean this_present_numVersions = true; - boolean that_present_numVersions = true; - if (this_present_numVersions || that_present_numVersions) { - if (!(this_present_numVersions && that_present_numVersions)) + boolean this_present_limit = true; + boolean that_present_limit = true; + if (this_present_limit || that_present_limit) { + if (!(this_present_limit && that_present_limit)) return false; - if (this.numVersions != that.numVersions) + if (this.limit != that.limit) + return false; + } + + boolean this_present_offset = true; + boolean that_present_offset = true; + if (this_present_offset || that_present_offset) { + if (!(this_present_offset && that_present_offset)) + return false; + if (this.offset != that.offset) return false; } @@ -13341,13 +18033,13 @@ public class Hbase { return 0; } - public int compareTo(getVer_args other) { + public int compareTo(getRowWithColumnsPaginated_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getVer_args typedOther = (getVer_args)other; + getRowWithColumnsPaginated_args typedOther = (getRowWithColumnsPaginated_args)other; lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); if (lastComparison != 0) { @@ -13359,32 +18051,42 @@ public class Hbase { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow()); + lastComparison = Boolean.valueOf(isSetRows()).compareTo(typedOther.isSetRows()); if (lastComparison != 0) { return lastComparison; } - if (isSetRow()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row); + if (isSetRows()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rows, typedOther.rows); if (lastComparison != 0) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetColumn()).compareTo(typedOther.isSetColumn()); + lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns()); if (lastComparison != 0) { return lastComparison; } - if (isSetColumn()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); + if (isSetColumns()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(typedOther.isSetNumVersions()); + lastComparison = Boolean.valueOf(isSetLimit()).compareTo(typedOther.isSetLimit()); if (lastComparison != 0) { return lastComparison; } - if (isSetNumVersions()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numVersions, typedOther.numVersions); + if (isSetLimit()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.limit, typedOther.limit); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOffset()).compareTo(typedOther.isSetOffset()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOffset()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.offset, typedOther.offset); if (lastComparison != 0) { return lastComparison; } @@ -13413,24 +18115,42 @@ public class Hbase { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; - case 2: // ROW + case 2: // ROWS if (field.type == org.apache.thrift.protocol.TType.STRING) { - this.row = iprot.readBinary(); + this.rows = iprot.readBinary(); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; - case 3: // COLUMN - if (field.type == org.apache.thrift.protocol.TType.STRING) { - this.column = iprot.readBinary(); + case 3: // COLUMNS + if (field.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list50 = iprot.readListBegin(); + this.columns = new ArrayList(_list50.size); + for (int _i51 = 0; _i51 < _list50.size; ++_i51) + { + ByteBuffer _elem52; + _elem52 = iprot.readBinary(); + this.columns.add(_elem52); + } + iprot.readListEnd(); + } } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; - case 4: // NUM_VERSIONS + case 4: // LIMIT if (field.type == org.apache.thrift.protocol.TType.I32) { - this.numVersions = iprot.readI32(); - setNumVersionsIsSet(true); + this.limit = iprot.readI32(); + setLimitIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 5: // OFFSET + if (field.type == org.apache.thrift.protocol.TType.I32) { + this.offset = iprot.readI32(); + setOffsetIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -13455,18 +18175,28 @@ public class Hbase { oprot.writeBinary(this.tableName); oprot.writeFieldEnd(); } - if (this.row != null) { - oprot.writeFieldBegin(ROW_FIELD_DESC); - oprot.writeBinary(this.row); + if (this.rows != null) { + oprot.writeFieldBegin(ROWS_FIELD_DESC); + oprot.writeBinary(this.rows); oprot.writeFieldEnd(); } - if (this.column != null) { - oprot.writeFieldBegin(COLUMN_FIELD_DESC); - oprot.writeBinary(this.column); + if (this.columns != null) { + oprot.writeFieldBegin(COLUMNS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + for (ByteBuffer _iter53 : this.columns) + { + oprot.writeBinary(_iter53); + } + oprot.writeListEnd(); + } oprot.writeFieldEnd(); } - oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC); - oprot.writeI32(this.numVersions); + oprot.writeFieldBegin(LIMIT_FIELD_DESC); + oprot.writeI32(this.limit); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(OFFSET_FIELD_DESC); + oprot.writeI32(this.offset); oprot.writeFieldEnd(); oprot.writeFieldStop(); oprot.writeStructEnd(); @@ -13474,7 +18204,7 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("getVer_args("); + StringBuilder sb = new StringBuilder("getRowWithColumnsPaginated_args("); boolean first = true; sb.append("tableName:"); @@ -13485,24 +18215,28 @@ public class Hbase { } first = false; if (!first) sb.append(", "); - sb.append("row:"); - if (this.row == null) { + sb.append("rows:"); + if (this.rows == null) { sb.append("null"); } else { - sb.append(this.row); + sb.append(this.rows); } first = false; if (!first) sb.append(", "); - sb.append("column:"); - if (this.column == null) { + sb.append("columns:"); + if (this.columns == null) { sb.append("null"); } else { - sb.append(this.column); + sb.append(this.columns); } first = false; if (!first) sb.append(", "); - sb.append("numVersions:"); - sb.append(this.numVersions); + sb.append("limit:"); + sb.append(this.limit); + first = false; + if (!first) sb.append(", "); + sb.append("offset:"); + sb.append(this.offset); first = false; sb.append(")"); return sb.toString(); @@ -13522,6 +18256,8 @@ public class Hbase { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -13530,13 +18266,13 @@ public class Hbase { } - public static class getVer_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVer_result"); + public static class getRowWithColumnsPaginated_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsPaginated_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); - public List success; + public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -13607,18 +18343,18 @@ public class Hbase { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVer_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsPaginated_result.class, metaDataMap); } - public getVer_result() { + public getRowWithColumnsPaginated_result() { } - public getVer_result( - List success, + public getRowWithColumnsPaginated_result( + List success, IOError io) { this(); @@ -13629,11 +18365,11 @@ public class Hbase { /** * Performs a deep copy on other. */ - public getVer_result(getVer_result other) { + public getRowWithColumnsPaginated_result(getRowWithColumnsPaginated_result other) { if (other.isSetSuccess()) { - List __this__success = new ArrayList(); - for (TCell other_element : other.success) { - __this__success.add(new TCell(other_element)); + List __this__success = new ArrayList(); + for (TRowResult other_element : other.success) { + __this__success.add(new TRowResult(other_element)); } this.success = __this__success; } @@ -13642,8 +18378,8 @@ public class Hbase { } } - public getVer_result deepCopy() { - return new getVer_result(this); + public getRowWithColumnsPaginated_result deepCopy() { + return new getRowWithColumnsPaginated_result(this); } @Override @@ -13656,22 +18392,22 @@ public class Hbase { return (this.success == null) ? 0 : this.success.size(); } - public java.util.Iterator getSuccessIterator() { + public java.util.Iterator getSuccessIterator() { return (this.success == null) ? null : this.success.iterator(); } - public void addToSuccess(TCell elem) { + public void addToSuccess(TRowResult elem) { if (this.success == null) { - this.success = new ArrayList(); + this.success = new ArrayList(); } this.success.add(elem); } - public List getSuccess() { + public List getSuccess() { return this.success; } - public getVer_result setSuccess(List success) { + public getRowWithColumnsPaginated_result setSuccess(List success) { this.success = success; return this; } @@ -13695,7 +18431,7 @@ public class Hbase { return this.io; } - public getVer_result setIo(IOError io) { + public getRowWithColumnsPaginated_result setIo(IOError io) { this.io = io; return this; } @@ -13721,7 +18457,7 @@ public class Hbase { if (value == null) { unsetSuccess(); } else { - setSuccess((List)value); + setSuccess((List)value); } break; @@ -13767,12 +18503,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getVer_result) - return this.equals((getVer_result)that); + if (that instanceof getRowWithColumnsPaginated_result) + return this.equals((getRowWithColumnsPaginated_result)that); return false; } - public boolean equals(getVer_result that) { + public boolean equals(getRowWithColumnsPaginated_result that) { if (that == null) return false; @@ -13802,13 +18538,13 @@ public class Hbase { return 0; } - public int compareTo(getVer_result other) { + public int compareTo(getRowWithColumnsPaginated_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getVer_result typedOther = (getVer_result)other; + getRowWithColumnsPaginated_result typedOther = (getRowWithColumnsPaginated_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -13850,14 +18586,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list30 = iprot.readListBegin(); - this.success = new ArrayList(_list30.size); - for (int _i31 = 0; _i31 < _list30.size; ++_i31) + org.apache.thrift.protocol.TList _list54 = iprot.readListBegin(); + this.success = new ArrayList(_list54.size); + for (int _i55 = 0; _i55 < _list54.size; ++_i55) { - TCell _elem32; - _elem32 = new TCell(); - _elem32.read(iprot); - this.success.add(_elem32); + TRowResult _elem56; + _elem56 = new TRowResult(); + _elem56.read(iprot); + this.success.add(_elem56); } iprot.readListEnd(); } @@ -13891,9 +18627,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TCell _iter33 : this.success) + for (TRowResult _iter57 : this.success) { - _iter33.write(oprot); + _iter57.write(oprot); } oprot.writeListEnd(); } @@ -13909,7 +18645,7 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("getVer_result("); + StringBuilder sb = new StringBuilder("getRowWithColumnsPaginated_result("); boolean first = true; sb.append("success:"); @@ -13953,17 +18689,15 @@ public class Hbase { } - public static class getVerTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVerTs_args"); + public static class getRowTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowTs_args"); private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField COLUMN_FIELD_DESC = new org.apache.thrift.protocol.TField("column", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); - private static final org.apache.thrift.protocol.TField NUM_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("numVersions", org.apache.thrift.protocol.TType.I32, (short)5); + private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)3); /** - * name of table + * name of the table */ public ByteBuffer tableName; /** @@ -13971,22 +18705,14 @@ public class Hbase { */ public ByteBuffer row; /** - * column name - */ - public ByteBuffer column; - /** * timestamp */ public long timestamp; - /** - * number of versions to retrieve - */ - public int numVersions; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { /** - * name of table + * name of the table */ TABLE_NAME((short)1, "tableName"), /** @@ -13994,17 +18720,9 @@ public class Hbase { */ ROW((short)2, "row"), /** - * column name - */ - COLUMN((short)3, "column"), - /** * timestamp */ - TIMESTAMP((short)4, "timestamp"), - /** - * number of versions to retrieve - */ - NUM_VERSIONS((short)5, "numVersions"); + TIMESTAMP((short)3, "timestamp"); private static final Map byName = new HashMap(); @@ -14023,12 +18741,8 @@ public class Hbase { return TABLE_NAME; case 2: // ROW return ROW; - case 3: // COLUMN - return COLUMN; - case 4: // TIMESTAMP + case 3: // TIMESTAMP return TIMESTAMP; - case 5: // NUM_VERSIONS - return NUM_VERSIONS; default: return null; } @@ -14070,8 +18784,7 @@ public class Hbase { // isset id assignments private static final int __TIMESTAMP_ISSET_ID = 0; - private static final int __NUMVERSIONS_ISSET_ID = 1; - private BitSet __isset_bit_vector = new BitSet(2); + private BitSet __isset_bit_vector = new BitSet(1); public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { @@ -14080,40 +18793,31 @@ public class Hbase { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.COLUMN, new org.apache.thrift.meta_data.FieldMetaData("column", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.NUM_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("numVersions", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVerTs_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowTs_args.class, metaDataMap); } - public getVerTs_args() { + public getRowTs_args() { } - public getVerTs_args( + public getRowTs_args( ByteBuffer tableName, ByteBuffer row, - ByteBuffer column, - long timestamp, - int numVersions) + long timestamp) { this(); this.tableName = tableName; this.row = row; - this.column = column; this.timestamp = timestamp; setTimestampIsSet(true); - this.numVersions = numVersions; - setNumVersionsIsSet(true); } /** * Performs a deep copy on other. */ - public getVerTs_args(getVerTs_args other) { + public getRowTs_args(getRowTs_args other) { __isset_bit_vector.clear(); __isset_bit_vector.or(other.__isset_bit_vector); if (other.isSetTableName()) { @@ -14122,30 +18826,23 @@ public class Hbase { if (other.isSetRow()) { this.row = other.row; } - if (other.isSetColumn()) { - this.column = other.column; - } this.timestamp = other.timestamp; - this.numVersions = other.numVersions; } - public getVerTs_args deepCopy() { - return new getVerTs_args(this); + public getRowTs_args deepCopy() { + return new getRowTs_args(this); } @Override public void clear() { this.tableName = null; this.row = null; - this.column = null; setTimestampIsSet(false); this.timestamp = 0; - setNumVersionsIsSet(false); - this.numVersions = 0; } /** - * name of table + * name of the table */ public byte[] getTableName() { setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); @@ -14157,14 +18854,14 @@ public class Hbase { } /** - * name of table + * name of the table */ - public getVerTs_args setTableName(byte[] tableName) { + public getRowTs_args setTableName(byte[] tableName) { setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); return this; } - public getVerTs_args setTableName(ByteBuffer tableName) { + public getRowTs_args setTableName(ByteBuffer tableName) { this.tableName = tableName; return this; } @@ -14199,12 +18896,12 @@ public class Hbase { /** * row key */ - public getVerTs_args setRow(byte[] row) { + public getRowTs_args setRow(byte[] row) { setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); return this; } - public getVerTs_args setRow(ByteBuffer row) { + public getRowTs_args setRow(ByteBuffer row) { this.row = row; return this; } @@ -14225,46 +18922,6 @@ public class Hbase { } /** - * column name - */ - public byte[] getColumn() { - setColumn(org.apache.thrift.TBaseHelper.rightSize(column)); - return column == null ? null : column.array(); - } - - public ByteBuffer bufferForColumn() { - return column; - } - - /** - * column name - */ - public getVerTs_args setColumn(byte[] column) { - setColumn(column == null ? (ByteBuffer)null : ByteBuffer.wrap(column)); - return this; - } - - public getVerTs_args setColumn(ByteBuffer column) { - this.column = column; - return this; - } - - public void unsetColumn() { - this.column = null; - } - - /** Returns true if field column is set (has been assigned a value) and false otherwise */ - public boolean isSetColumn() { - return this.column != null; - } - - public void setColumnIsSet(boolean value) { - if (!value) { - this.column = null; - } - } - - /** * timestamp */ public long getTimestamp() { @@ -14274,7 +18931,7 @@ public class Hbase { /** * timestamp */ - public getVerTs_args setTimestamp(long timestamp) { + public getRowTs_args setTimestamp(long timestamp) { this.timestamp = timestamp; setTimestampIsSet(true); return this; @@ -14293,35 +18950,6 @@ public class Hbase { __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value); } - /** - * number of versions to retrieve - */ - public int getNumVersions() { - return this.numVersions; - } - - /** - * number of versions to retrieve - */ - public getVerTs_args setNumVersions(int numVersions) { - this.numVersions = numVersions; - setNumVersionsIsSet(true); - return this; - } - - public void unsetNumVersions() { - __isset_bit_vector.clear(__NUMVERSIONS_ISSET_ID); - } - - /** Returns true if field numVersions is set (has been assigned a value) and false otherwise */ - public boolean isSetNumVersions() { - return __isset_bit_vector.get(__NUMVERSIONS_ISSET_ID); - } - - public void setNumVersionsIsSet(boolean value) { - __isset_bit_vector.set(__NUMVERSIONS_ISSET_ID, value); - } - public void setFieldValue(_Fields field, Object value) { switch (field) { case TABLE_NAME: @@ -14340,14 +18968,6 @@ public class Hbase { } break; - case COLUMN: - if (value == null) { - unsetColumn(); - } else { - setColumn((ByteBuffer)value); - } - break; - case TIMESTAMP: if (value == null) { unsetTimestamp(); @@ -14356,14 +18976,6 @@ public class Hbase { } break; - case NUM_VERSIONS: - if (value == null) { - unsetNumVersions(); - } else { - setNumVersions((Integer)value); - } - break; - } } @@ -14375,15 +18987,9 @@ public class Hbase { case ROW: return getRow(); - case COLUMN: - return getColumn(); - case TIMESTAMP: return new Long(getTimestamp()); - case NUM_VERSIONS: - return new Integer(getNumVersions()); - } throw new IllegalStateException(); } @@ -14399,12 +19005,8 @@ public class Hbase { return isSetTableName(); case ROW: return isSetRow(); - case COLUMN: - return isSetColumn(); case TIMESTAMP: return isSetTimestamp(); - case NUM_VERSIONS: - return isSetNumVersions(); } throw new IllegalStateException(); } @@ -14413,12 +19015,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getVerTs_args) - return this.equals((getVerTs_args)that); + if (that instanceof getRowTs_args) + return this.equals((getRowTs_args)that); return false; } - public boolean equals(getVerTs_args that) { + public boolean equals(getRowTs_args that) { if (that == null) return false; @@ -14440,15 +19042,6 @@ public class Hbase { return false; } - boolean this_present_column = true && this.isSetColumn(); - boolean that_present_column = true && that.isSetColumn(); - if (this_present_column || that_present_column) { - if (!(this_present_column && that_present_column)) - return false; - if (!this.column.equals(that.column)) - return false; - } - boolean this_present_timestamp = true; boolean that_present_timestamp = true; if (this_present_timestamp || that_present_timestamp) { @@ -14458,15 +19051,6 @@ public class Hbase { return false; } - boolean this_present_numVersions = true; - boolean that_present_numVersions = true; - if (this_present_numVersions || that_present_numVersions) { - if (!(this_present_numVersions && that_present_numVersions)) - return false; - if (this.numVersions != that.numVersions) - return false; - } - return true; } @@ -14475,13 +19059,13 @@ public class Hbase { return 0; } - public int compareTo(getVerTs_args other) { + public int compareTo(getRowTs_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getVerTs_args typedOther = (getVerTs_args)other; + getRowTs_args typedOther = (getRowTs_args)other; lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); if (lastComparison != 0) { @@ -14503,16 +19087,6 @@ public class Hbase { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetColumn()).compareTo(typedOther.isSetColumn()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetColumn()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.column, typedOther.column); - if (lastComparison != 0) { - return lastComparison; - } - } lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(typedOther.isSetTimestamp()); if (lastComparison != 0) { return lastComparison; @@ -14523,16 +19097,6 @@ public class Hbase { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetNumVersions()).compareTo(typedOther.isSetNumVersions()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetNumVersions()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numVersions, typedOther.numVersions); - if (lastComparison != 0) { - return lastComparison; - } - } return 0; } @@ -14564,14 +19128,7 @@ public class Hbase { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; - case 3: // COLUMN - if (field.type == org.apache.thrift.protocol.TType.STRING) { - this.column = iprot.readBinary(); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); - } - break; - case 4: // TIMESTAMP + case 3: // TIMESTAMP if (field.type == org.apache.thrift.protocol.TType.I64) { this.timestamp = iprot.readI64(); setTimestampIsSet(true); @@ -14579,14 +19136,6 @@ public class Hbase { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; - case 5: // NUM_VERSIONS - if (field.type == org.apache.thrift.protocol.TType.I32) { - this.numVersions = iprot.readI32(); - setNumVersionsIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); - } - break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -14612,24 +19161,16 @@ public class Hbase { oprot.writeBinary(this.row); oprot.writeFieldEnd(); } - if (this.column != null) { - oprot.writeFieldBegin(COLUMN_FIELD_DESC); - oprot.writeBinary(this.column); - oprot.writeFieldEnd(); - } oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC); oprot.writeI64(this.timestamp); oprot.writeFieldEnd(); - oprot.writeFieldBegin(NUM_VERSIONS_FIELD_DESC); - oprot.writeI32(this.numVersions); - oprot.writeFieldEnd(); oprot.writeFieldStop(); oprot.writeStructEnd(); } @Override public String toString() { - StringBuilder sb = new StringBuilder("getVerTs_args("); + StringBuilder sb = new StringBuilder("getRowTs_args("); boolean first = true; sb.append("tableName:"); @@ -14648,21 +19189,9 @@ public class Hbase { } first = false; if (!first) sb.append(", "); - sb.append("column:"); - if (this.column == null) { - sb.append("null"); - } else { - sb.append(this.column); - } - first = false; - if (!first) sb.append(", "); sb.append("timestamp:"); sb.append(this.timestamp); first = false; - if (!first) sb.append(", "); - sb.append("numVersions:"); - sb.append(this.numVersions); - first = false; sb.append(")"); return sb.toString(); } @@ -14691,13 +19220,13 @@ public class Hbase { } - public static class getVerTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVerTs_result"); + public static class getRowTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowTs_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); - public List success; + public List success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -14768,18 +19297,18 @@ public class Hbase { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCell.class)))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVerTs_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowTs_result.class, metaDataMap); } - public getVerTs_result() { + public getRowTs_result() { } - public getVerTs_result( - List success, + public getRowTs_result( + List success, IOError io) { this(); @@ -14790,11 +19319,11 @@ public class Hbase { /** * Performs a deep copy on other. */ - public getVerTs_result(getVerTs_result other) { + public getRowTs_result(getRowTs_result other) { if (other.isSetSuccess()) { - List __this__success = new ArrayList(); - for (TCell other_element : other.success) { - __this__success.add(new TCell(other_element)); + List __this__success = new ArrayList(); + for (TRowResult other_element : other.success) { + __this__success.add(new TRowResult(other_element)); } this.success = __this__success; } @@ -14803,8 +19332,8 @@ public class Hbase { } } - public getVerTs_result deepCopy() { - return new getVerTs_result(this); + public getRowTs_result deepCopy() { + return new getRowTs_result(this); } @Override @@ -14817,22 +19346,22 @@ public class Hbase { return (this.success == null) ? 0 : this.success.size(); } - public java.util.Iterator getSuccessIterator() { + public java.util.Iterator getSuccessIterator() { return (this.success == null) ? null : this.success.iterator(); } - public void addToSuccess(TCell elem) { + public void addToSuccess(TRowResult elem) { if (this.success == null) { - this.success = new ArrayList(); + this.success = new ArrayList(); } this.success.add(elem); } - public List getSuccess() { + public List getSuccess() { return this.success; } - public getVerTs_result setSuccess(List success) { + public getRowTs_result setSuccess(List success) { this.success = success; return this; } @@ -14856,7 +19385,7 @@ public class Hbase { return this.io; } - public getVerTs_result setIo(IOError io) { + public getRowTs_result setIo(IOError io) { this.io = io; return this; } @@ -14882,7 +19411,7 @@ public class Hbase { if (value == null) { unsetSuccess(); } else { - setSuccess((List)value); + setSuccess((List)value); } break; @@ -14928,12 +19457,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getVerTs_result) - return this.equals((getVerTs_result)that); + if (that instanceof getRowTs_result) + return this.equals((getRowTs_result)that); return false; } - public boolean equals(getVerTs_result that) { + public boolean equals(getRowTs_result that) { if (that == null) return false; @@ -14963,13 +19492,13 @@ public class Hbase { return 0; } - public int compareTo(getVerTs_result other) { + public int compareTo(getRowTs_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getVerTs_result typedOther = (getVerTs_result)other; + getRowTs_result typedOther = (getRowTs_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -15011,14 +19540,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list34 = iprot.readListBegin(); - this.success = new ArrayList(_list34.size); - for (int _i35 = 0; _i35 < _list34.size; ++_i35) + org.apache.thrift.protocol.TList _list58 = iprot.readListBegin(); + this.success = new ArrayList(_list58.size); + for (int _i59 = 0; _i59 < _list58.size; ++_i59) { - TCell _elem36; - _elem36 = new TCell(); - _elem36.read(iprot); - this.success.add(_elem36); + TRowResult _elem60; + _elem60 = new TRowResult(); + _elem60.read(iprot); + this.success.add(_elem60); } iprot.readListEnd(); } @@ -15052,9 +19581,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TCell _iter37 : this.success) + for (TRowResult _iter61 : this.success) { - _iter37.write(oprot); + _iter61.write(oprot); } oprot.writeListEnd(); } @@ -15070,7 +19599,7 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("getVerTs_result("); + StringBuilder sb = new StringBuilder("getRowTs_result("); boolean first = true; sb.append("success:"); @@ -15114,11 +19643,13 @@ public class Hbase { } - public static class getRow_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRow_args"); + public static class getRowWithColumnsTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsTs_args"); private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); /** * name of table @@ -15128,6 +19659,11 @@ public class Hbase { * row key */ public ByteBuffer row; + /** + * List of columns to return, null for all columns + */ + public List columns; + public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -15138,7 +19674,12 @@ public class Hbase { /** * row key */ - ROW((short)2, "row"); + ROW((short)2, "row"), + /** + * List of columns to return, null for all columns + */ + COLUMNS((short)3, "columns"), + TIMESTAMP((short)4, "timestamp"); private static final Map byName = new HashMap(); @@ -15157,6 +19698,10 @@ public class Hbase { return TABLE_NAME; case 2: // ROW return ROW; + case 3: // COLUMNS + return COLUMNS; + case 4: // TIMESTAMP + return TIMESTAMP; default: return null; } @@ -15197,6 +19742,8 @@ public class Hbase { } // isset id assignments + private static final int __TIMESTAMP_ISSET_ID = 0; + private BitSet __isset_bit_vector = new BitSet(1); public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { @@ -15205,42 +19752,65 @@ public class Hbase { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); + tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); + tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRow_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_args.class, metaDataMap); } - public getRow_args() { + public getRowWithColumnsTs_args() { } - public getRow_args( + public getRowWithColumnsTs_args( ByteBuffer tableName, - ByteBuffer row) + ByteBuffer row, + List columns, + long timestamp) { this(); this.tableName = tableName; this.row = row; + this.columns = columns; + this.timestamp = timestamp; + setTimestampIsSet(true); } /** * Performs a deep copy on other. */ - public getRow_args(getRow_args other) { + public getRowWithColumnsTs_args(getRowWithColumnsTs_args other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); if (other.isSetTableName()) { this.tableName = other.tableName; } if (other.isSetRow()) { this.row = other.row; } + if (other.isSetColumns()) { + List __this__columns = new ArrayList(); + for (ByteBuffer other_element : other.columns) { + __this__columns.add(other_element); + } + this.columns = __this__columns; + } + this.timestamp = other.timestamp; } - public getRow_args deepCopy() { - return new getRow_args(this); + public getRowWithColumnsTs_args deepCopy() { + return new getRowWithColumnsTs_args(this); } @Override public void clear() { this.tableName = null; this.row = null; + this.columns = null; + setTimestampIsSet(false); + this.timestamp = 0; } /** @@ -15258,12 +19828,12 @@ public class Hbase { /** * name of table */ - public getRow_args setTableName(byte[] tableName) { + public getRowWithColumnsTs_args setTableName(byte[] tableName) { setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); return this; } - public getRow_args setTableName(ByteBuffer tableName) { + public getRowWithColumnsTs_args setTableName(ByteBuffer tableName) { this.tableName = tableName; return this; } @@ -15298,12 +19868,12 @@ public class Hbase { /** * row key */ - public getRow_args setRow(byte[] row) { + public getRowWithColumnsTs_args setRow(byte[] row) { setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); return this; } - public getRow_args setRow(ByteBuffer row) { + public getRowWithColumnsTs_args setRow(ByteBuffer row) { this.row = row; return this; } @@ -15323,6 +19893,74 @@ public class Hbase { } } + public int getColumnsSize() { + return (this.columns == null) ? 0 : this.columns.size(); + } + + public java.util.Iterator getColumnsIterator() { + return (this.columns == null) ? null : this.columns.iterator(); + } + + public void addToColumns(ByteBuffer elem) { + if (this.columns == null) { + this.columns = new ArrayList(); + } + this.columns.add(elem); + } + + /** + * List of columns to return, null for all columns + */ + public List getColumns() { + return this.columns; + } + + /** + * List of columns to return, null for all columns + */ + public getRowWithColumnsTs_args setColumns(List columns) { + this.columns = columns; + return this; + } + + public void unsetColumns() { + this.columns = null; + } + + /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + public boolean isSetColumns() { + return this.columns != null; + } + + public void setColumnsIsSet(boolean value) { + if (!value) { + this.columns = null; + } + } + + public long getTimestamp() { + return this.timestamp; + } + + public getRowWithColumnsTs_args setTimestamp(long timestamp) { + this.timestamp = timestamp; + setTimestampIsSet(true); + return this; + } + + public void unsetTimestamp() { + __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); + } + + /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + public boolean isSetTimestamp() { + return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); + } + + public void setTimestampIsSet(boolean value) { + __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value); + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TABLE_NAME: @@ -15341,6 +19979,22 @@ public class Hbase { } break; + case COLUMNS: + if (value == null) { + unsetColumns(); + } else { + setColumns((List)value); + } + break; + + case TIMESTAMP: + if (value == null) { + unsetTimestamp(); + } else { + setTimestamp((Long)value); + } + break; + } } @@ -15352,6 +20006,12 @@ public class Hbase { case ROW: return getRow(); + case COLUMNS: + return getColumns(); + + case TIMESTAMP: + return new Long(getTimestamp()); + } throw new IllegalStateException(); } @@ -15367,6 +20027,10 @@ public class Hbase { return isSetTableName(); case ROW: return isSetRow(); + case COLUMNS: + return isSetColumns(); + case TIMESTAMP: + return isSetTimestamp(); } throw new IllegalStateException(); } @@ -15375,12 +20039,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getRow_args) - return this.equals((getRow_args)that); + if (that instanceof getRowWithColumnsTs_args) + return this.equals((getRowWithColumnsTs_args)that); return false; } - public boolean equals(getRow_args that) { + public boolean equals(getRowWithColumnsTs_args that) { if (that == null) return false; @@ -15402,6 +20066,24 @@ public class Hbase { return false; } + boolean this_present_columns = true && this.isSetColumns(); + boolean that_present_columns = true && that.isSetColumns(); + if (this_present_columns || that_present_columns) { + if (!(this_present_columns && that_present_columns)) + return false; + if (!this.columns.equals(that.columns)) + return false; + } + + boolean this_present_timestamp = true; + boolean that_present_timestamp = true; + if (this_present_timestamp || that_present_timestamp) { + if (!(this_present_timestamp && that_present_timestamp)) + return false; + if (this.timestamp != that.timestamp) + return false; + } + return true; } @@ -15410,13 +20092,13 @@ public class Hbase { return 0; } - public int compareTo(getRow_args other) { + public int compareTo(getRowWithColumnsTs_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getRow_args typedOther = (getRow_args)other; + getRowWithColumnsTs_args typedOther = (getRowWithColumnsTs_args)other; lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); if (lastComparison != 0) { @@ -15438,6 +20120,26 @@ public class Hbase { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetColumns()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(typedOther.isSetTimestamp()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTimestamp()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -15469,6 +20171,31 @@ public class Hbase { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; + case 3: // COLUMNS + if (field.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list62 = iprot.readListBegin(); + this.columns = new ArrayList(_list62.size); + for (int _i63 = 0; _i63 < _list62.size; ++_i63) + { + ByteBuffer _elem64; + _elem64 = iprot.readBinary(); + this.columns.add(_elem64); + } + iprot.readListEnd(); + } + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 4: // TIMESTAMP + if (field.type == org.apache.thrift.protocol.TType.I64) { + this.timestamp = iprot.readI64(); + setTimestampIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -15494,13 +20221,28 @@ public class Hbase { oprot.writeBinary(this.row); oprot.writeFieldEnd(); } + if (this.columns != null) { + oprot.writeFieldBegin(COLUMNS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + for (ByteBuffer _iter65 : this.columns) + { + oprot.writeBinary(_iter65); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC); + oprot.writeI64(this.timestamp); + oprot.writeFieldEnd(); oprot.writeFieldStop(); oprot.writeStructEnd(); } @Override public String toString() { - StringBuilder sb = new StringBuilder("getRow_args("); + StringBuilder sb = new StringBuilder("getRowWithColumnsTs_args("); boolean first = true; sb.append("tableName:"); @@ -15518,6 +20260,18 @@ public class Hbase { sb.append(this.row); } first = false; + if (!first) sb.append(", "); + sb.append("columns:"); + if (this.columns == null) { + sb.append("null"); + } else { + sb.append(this.columns); + } + first = false; + if (!first) sb.append(", "); + sb.append("timestamp:"); + sb.append(this.timestamp); + first = false; sb.append(")"); return sb.toString(); } @@ -15536,6 +20290,8 @@ public class Hbase { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -15544,8 +20300,8 @@ public class Hbase { } - public static class getRow_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRow_result"); + public static class getRowWithColumnsTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsTs_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); @@ -15625,13 +20381,13 @@ public class Hbase { tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRow_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_result.class, metaDataMap); } - public getRow_result() { + public getRowWithColumnsTs_result() { } - public getRow_result( + public getRowWithColumnsTs_result( List success, IOError io) { @@ -15643,7 +20399,7 @@ public class Hbase { /** * Performs a deep copy on other. */ - public getRow_result(getRow_result other) { + public getRowWithColumnsTs_result(getRowWithColumnsTs_result other) { if (other.isSetSuccess()) { List __this__success = new ArrayList(); for (TRowResult other_element : other.success) { @@ -15656,8 +20412,8 @@ public class Hbase { } } - public getRow_result deepCopy() { - return new getRow_result(this); + public getRowWithColumnsTs_result deepCopy() { + return new getRowWithColumnsTs_result(this); } @Override @@ -15685,7 +20441,7 @@ public class Hbase { return this.success; } - public getRow_result setSuccess(List success) { + public getRowWithColumnsTs_result setSuccess(List success) { this.success = success; return this; } @@ -15709,7 +20465,7 @@ public class Hbase { return this.io; } - public getRow_result setIo(IOError io) { + public getRowWithColumnsTs_result setIo(IOError io) { this.io = io; return this; } @@ -15781,12 +20537,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getRow_result) - return this.equals((getRow_result)that); + if (that instanceof getRowWithColumnsTs_result) + return this.equals((getRowWithColumnsTs_result)that); return false; } - public boolean equals(getRow_result that) { + public boolean equals(getRowWithColumnsTs_result that) { if (that == null) return false; @@ -15816,13 +20572,13 @@ public class Hbase { return 0; } - public int compareTo(getRow_result other) { + public int compareTo(getRowWithColumnsTs_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getRow_result typedOther = (getRow_result)other; + getRowWithColumnsTs_result typedOther = (getRowWithColumnsTs_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -15864,14 +20620,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list38 = iprot.readListBegin(); - this.success = new ArrayList(_list38.size); - for (int _i39 = 0; _i39 < _list38.size; ++_i39) + org.apache.thrift.protocol.TList _list66 = iprot.readListBegin(); + this.success = new ArrayList(_list66.size); + for (int _i67 = 0; _i67 < _list66.size; ++_i67) { - TRowResult _elem40; - _elem40 = new TRowResult(); - _elem40.read(iprot); - this.success.add(_elem40); + TRowResult _elem68; + _elem68 = new TRowResult(); + _elem68.read(iprot); + this.success.add(_elem68); } iprot.readListEnd(); } @@ -15905,9 +20661,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter41 : this.success) + for (TRowResult _iter69 : this.success) { - _iter41.write(oprot); + _iter69.write(oprot); } oprot.writeListEnd(); } @@ -15923,7 +20679,7 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("getRow_result("); + StringBuilder sb = new StringBuilder("getRowWithColumnsTs_result("); boolean first = true; sb.append("success:"); @@ -15967,12 +20723,15 @@ public class Hbase { } - public static class getRowWithColumns_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumns_args"); + public static class getRowWithColumnsPaginatedTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsPaginatedTs_args"); private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); + private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I32, (short)5); + private static final org.apache.thrift.protocol.TField OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("offset", org.apache.thrift.protocol.TType.I32, (short)6); /** * name of table @@ -15986,6 +20745,9 @@ public class Hbase { * List of columns to return, null for all columns */ public List columns; + public long timestamp; + public int limit; + public int offset; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -16000,7 +20762,10 @@ public class Hbase { /** * List of columns to return, null for all columns */ - COLUMNS((short)3, "columns"); + COLUMNS((short)3, "columns"), + TIMESTAMP((short)4, "timestamp"), + LIMIT((short)5, "limit"), + OFFSET((short)6, "offset"); private static final Map byName = new HashMap(); @@ -16021,6 +20786,12 @@ public class Hbase { return ROW; case 3: // COLUMNS return COLUMNS; + case 4: // TIMESTAMP + return TIMESTAMP; + case 5: // LIMIT + return LIMIT; + case 6: // OFFSET + return OFFSET; default: return null; } @@ -16061,6 +20832,10 @@ public class Hbase { } // isset id assignments + private static final int __TIMESTAMP_ISSET_ID = 0; + private static final int __LIMIT_ISSET_ID = 1; + private static final int __OFFSET_ISSET_ID = 2; + private BitSet __isset_bit_vector = new BitSet(3); public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { @@ -16072,28 +20847,45 @@ public class Hbase { tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); + tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.LIMIT, new org.apache.thrift.meta_data.FieldMetaData("limit", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.OFFSET, new org.apache.thrift.meta_data.FieldMetaData("offset", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumns_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsPaginatedTs_args.class, metaDataMap); } - public getRowWithColumns_args() { + public getRowWithColumnsPaginatedTs_args() { } - public getRowWithColumns_args( + public getRowWithColumnsPaginatedTs_args( ByteBuffer tableName, ByteBuffer row, - List columns) + List columns, + long timestamp, + int limit, + int offset) { this(); this.tableName = tableName; this.row = row; this.columns = columns; + this.timestamp = timestamp; + setTimestampIsSet(true); + this.limit = limit; + setLimitIsSet(true); + this.offset = offset; + setOffsetIsSet(true); } /** * Performs a deep copy on other. */ - public getRowWithColumns_args(getRowWithColumns_args other) { + public getRowWithColumnsPaginatedTs_args(getRowWithColumnsPaginatedTs_args other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); if (other.isSetTableName()) { this.tableName = other.tableName; } @@ -16107,10 +20899,13 @@ public class Hbase { } this.columns = __this__columns; } + this.timestamp = other.timestamp; + this.limit = other.limit; + this.offset = other.offset; } - public getRowWithColumns_args deepCopy() { - return new getRowWithColumns_args(this); + public getRowWithColumnsPaginatedTs_args deepCopy() { + return new getRowWithColumnsPaginatedTs_args(this); } @Override @@ -16118,6 +20913,12 @@ public class Hbase { this.tableName = null; this.row = null; this.columns = null; + setTimestampIsSet(false); + this.timestamp = 0; + setLimitIsSet(false); + this.limit = 0; + setOffsetIsSet(false); + this.offset = 0; } /** @@ -16135,12 +20936,12 @@ public class Hbase { /** * name of table */ - public getRowWithColumns_args setTableName(byte[] tableName) { + public getRowWithColumnsPaginatedTs_args setTableName(byte[] tableName) { setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); return this; } - public getRowWithColumns_args setTableName(ByteBuffer tableName) { + public getRowWithColumnsPaginatedTs_args setTableName(ByteBuffer tableName) { this.tableName = tableName; return this; } @@ -16175,12 +20976,12 @@ public class Hbase { /** * row key */ - public getRowWithColumns_args setRow(byte[] row) { + public getRowWithColumnsPaginatedTs_args setRow(byte[] row) { setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); return this; } - public getRowWithColumns_args setRow(ByteBuffer row) { + public getRowWithColumnsPaginatedTs_args setRow(ByteBuffer row) { this.row = row; return this; } @@ -16225,7 +21026,7 @@ public class Hbase { /** * List of columns to return, null for all columns */ - public getRowWithColumns_args setColumns(List columns) { + public getRowWithColumnsPaginatedTs_args setColumns(List columns) { this.columns = columns; return this; } @@ -16245,6 +21046,75 @@ public class Hbase { } } + public long getTimestamp() { + return this.timestamp; + } + + public getRowWithColumnsPaginatedTs_args setTimestamp(long timestamp) { + this.timestamp = timestamp; + setTimestampIsSet(true); + return this; + } + + public void unsetTimestamp() { + __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); + } + + /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ + public boolean isSetTimestamp() { + return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); + } + + public void setTimestampIsSet(boolean value) { + __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value); + } + + public int getLimit() { + return this.limit; + } + + public getRowWithColumnsPaginatedTs_args setLimit(int limit) { + this.limit = limit; + setLimitIsSet(true); + return this; + } + + public void unsetLimit() { + __isset_bit_vector.clear(__LIMIT_ISSET_ID); + } + + /** Returns true if field limit is set (has been assigned a value) and false otherwise */ + public boolean isSetLimit() { + return __isset_bit_vector.get(__LIMIT_ISSET_ID); + } + + public void setLimitIsSet(boolean value) { + __isset_bit_vector.set(__LIMIT_ISSET_ID, value); + } + + public int getOffset() { + return this.offset; + } + + public getRowWithColumnsPaginatedTs_args setOffset(int offset) { + this.offset = offset; + setOffsetIsSet(true); + return this; + } + + public void unsetOffset() { + __isset_bit_vector.clear(__OFFSET_ISSET_ID); + } + + /** Returns true if field offset is set (has been assigned a value) and false otherwise */ + public boolean isSetOffset() { + return __isset_bit_vector.get(__OFFSET_ISSET_ID); + } + + public void setOffsetIsSet(boolean value) { + __isset_bit_vector.set(__OFFSET_ISSET_ID, value); + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TABLE_NAME: @@ -16271,6 +21141,30 @@ public class Hbase { } break; + case TIMESTAMP: + if (value == null) { + unsetTimestamp(); + } else { + setTimestamp((Long)value); + } + break; + + case LIMIT: + if (value == null) { + unsetLimit(); + } else { + setLimit((Integer)value); + } + break; + + case OFFSET: + if (value == null) { + unsetOffset(); + } else { + setOffset((Integer)value); + } + break; + } } @@ -16285,6 +21179,15 @@ public class Hbase { case COLUMNS: return getColumns(); + case TIMESTAMP: + return new Long(getTimestamp()); + + case LIMIT: + return new Integer(getLimit()); + + case OFFSET: + return new Integer(getOffset()); + } throw new IllegalStateException(); } @@ -16302,6 +21205,12 @@ public class Hbase { return isSetRow(); case COLUMNS: return isSetColumns(); + case TIMESTAMP: + return isSetTimestamp(); + case LIMIT: + return isSetLimit(); + case OFFSET: + return isSetOffset(); } throw new IllegalStateException(); } @@ -16310,12 +21219,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getRowWithColumns_args) - return this.equals((getRowWithColumns_args)that); + if (that instanceof getRowWithColumnsPaginatedTs_args) + return this.equals((getRowWithColumnsPaginatedTs_args)that); return false; } - public boolean equals(getRowWithColumns_args that) { + public boolean equals(getRowWithColumnsPaginatedTs_args that) { if (that == null) return false; @@ -16346,6 +21255,33 @@ public class Hbase { return false; } + boolean this_present_timestamp = true; + boolean that_present_timestamp = true; + if (this_present_timestamp || that_present_timestamp) { + if (!(this_present_timestamp && that_present_timestamp)) + return false; + if (this.timestamp != that.timestamp) + return false; + } + + boolean this_present_limit = true; + boolean that_present_limit = true; + if (this_present_limit || that_present_limit) { + if (!(this_present_limit && that_present_limit)) + return false; + if (this.limit != that.limit) + return false; + } + + boolean this_present_offset = true; + boolean that_present_offset = true; + if (this_present_offset || that_present_offset) { + if (!(this_present_offset && that_present_offset)) + return false; + if (this.offset != that.offset) + return false; + } + return true; } @@ -16354,13 +21290,13 @@ public class Hbase { return 0; } - public int compareTo(getRowWithColumns_args other) { + public int compareTo(getRowWithColumnsPaginatedTs_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getRowWithColumns_args typedOther = (getRowWithColumns_args)other; + getRowWithColumnsPaginatedTs_args typedOther = (getRowWithColumnsPaginatedTs_args)other; lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); if (lastComparison != 0) { @@ -16392,6 +21328,36 @@ public class Hbase { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(typedOther.isSetTimestamp()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTimestamp()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetLimit()).compareTo(typedOther.isSetLimit()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLimit()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.limit, typedOther.limit); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOffset()).compareTo(typedOther.isSetOffset()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOffset()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.offset, typedOther.offset); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -16426,13 +21392,13 @@ public class Hbase { case 3: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list42 = iprot.readListBegin(); - this.columns = new ArrayList(_list42.size); - for (int _i43 = 0; _i43 < _list42.size; ++_i43) + org.apache.thrift.protocol.TList _list70 = iprot.readListBegin(); + this.columns = new ArrayList(_list70.size); + for (int _i71 = 0; _i71 < _list70.size; ++_i71) { - ByteBuffer _elem44; - _elem44 = iprot.readBinary(); - this.columns.add(_elem44); + ByteBuffer _elem72; + _elem72 = iprot.readBinary(); + this.columns.add(_elem72); } iprot.readListEnd(); } @@ -16440,6 +21406,30 @@ public class Hbase { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; + case 4: // TIMESTAMP + if (field.type == org.apache.thrift.protocol.TType.I64) { + this.timestamp = iprot.readI64(); + setTimestampIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 5: // LIMIT + if (field.type == org.apache.thrift.protocol.TType.I32) { + this.limit = iprot.readI32(); + setLimitIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 6: // OFFSET + if (field.type == org.apache.thrift.protocol.TType.I32) { + this.offset = iprot.readI32(); + setOffsetIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -16469,21 +21459,30 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); - for (ByteBuffer _iter45 : this.columns) + for (ByteBuffer _iter73 : this.columns) { - oprot.writeBinary(_iter45); + oprot.writeBinary(_iter73); } oprot.writeListEnd(); } oprot.writeFieldEnd(); } + oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC); + oprot.writeI64(this.timestamp); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(LIMIT_FIELD_DESC); + oprot.writeI32(this.limit); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(OFFSET_FIELD_DESC); + oprot.writeI32(this.offset); + oprot.writeFieldEnd(); oprot.writeFieldStop(); oprot.writeStructEnd(); } @Override public String toString() { - StringBuilder sb = new StringBuilder("getRowWithColumns_args("); + StringBuilder sb = new StringBuilder("getRowWithColumnsPaginatedTs_args("); boolean first = true; sb.append("tableName:"); @@ -16509,6 +21508,18 @@ public class Hbase { sb.append(this.columns); } first = false; + if (!first) sb.append(", "); + sb.append("timestamp:"); + sb.append(this.timestamp); + first = false; + if (!first) sb.append(", "); + sb.append("limit:"); + sb.append(this.limit); + first = false; + if (!first) sb.append(", "); + sb.append("offset:"); + sb.append(this.offset); + first = false; sb.append(")"); return sb.toString(); } @@ -16527,6 +21538,8 @@ public class Hbase { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -16535,8 +21548,8 @@ public class Hbase { } - public static class getRowWithColumns_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumns_result"); + public static class getRowWithColumnsPaginatedTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsPaginatedTs_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); @@ -16616,13 +21629,13 @@ public class Hbase { tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumns_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsPaginatedTs_result.class, metaDataMap); } - public getRowWithColumns_result() { + public getRowWithColumnsPaginatedTs_result() { } - public getRowWithColumns_result( + public getRowWithColumnsPaginatedTs_result( List success, IOError io) { @@ -16634,7 +21647,7 @@ public class Hbase { /** * Performs a deep copy on other. */ - public getRowWithColumns_result(getRowWithColumns_result other) { + public getRowWithColumnsPaginatedTs_result(getRowWithColumnsPaginatedTs_result other) { if (other.isSetSuccess()) { List __this__success = new ArrayList(); for (TRowResult other_element : other.success) { @@ -16647,8 +21660,8 @@ public class Hbase { } } - public getRowWithColumns_result deepCopy() { - return new getRowWithColumns_result(this); + public getRowWithColumnsPaginatedTs_result deepCopy() { + return new getRowWithColumnsPaginatedTs_result(this); } @Override @@ -16676,7 +21689,7 @@ public class Hbase { return this.success; } - public getRowWithColumns_result setSuccess(List success) { + public getRowWithColumnsPaginatedTs_result setSuccess(List success) { this.success = success; return this; } @@ -16700,7 +21713,7 @@ public class Hbase { return this.io; } - public getRowWithColumns_result setIo(IOError io) { + public getRowWithColumnsPaginatedTs_result setIo(IOError io) { this.io = io; return this; } @@ -16772,12 +21785,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getRowWithColumns_result) - return this.equals((getRowWithColumns_result)that); + if (that instanceof getRowWithColumnsPaginatedTs_result) + return this.equals((getRowWithColumnsPaginatedTs_result)that); return false; } - public boolean equals(getRowWithColumns_result that) { + public boolean equals(getRowWithColumnsPaginatedTs_result that) { if (that == null) return false; @@ -16807,13 +21820,13 @@ public class Hbase { return 0; } - public int compareTo(getRowWithColumns_result other) { + public int compareTo(getRowWithColumnsPaginatedTs_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getRowWithColumns_result typedOther = (getRowWithColumns_result)other; + getRowWithColumnsPaginatedTs_result typedOther = (getRowWithColumnsPaginatedTs_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -16855,14 +21868,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list46 = iprot.readListBegin(); - this.success = new ArrayList(_list46.size); - for (int _i47 = 0; _i47 < _list46.size; ++_i47) + org.apache.thrift.protocol.TList _list74 = iprot.readListBegin(); + this.success = new ArrayList(_list74.size); + for (int _i75 = 0; _i75 < _list74.size; ++_i75) { - TRowResult _elem48; - _elem48 = new TRowResult(); - _elem48.read(iprot); - this.success.add(_elem48); + TRowResult _elem76; + _elem76 = new TRowResult(); + _elem76.read(iprot); + this.success.add(_elem76); } iprot.readListEnd(); } @@ -16896,9 +21909,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter49 : this.success) + for (TRowResult _iter77 : this.success) { - _iter49.write(oprot); + _iter77.write(oprot); } oprot.writeListEnd(); } @@ -16914,7 +21927,7 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("getRowWithColumns_result("); + StringBuilder sb = new StringBuilder("getRowWithColumnsPaginatedTs_result("); boolean first = true; sb.append("success:"); @@ -16958,40 +21971,22 @@ public class Hbase { } - public static class getRowTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowTs_args"); + public static class countRowWithColumns_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("countRowWithColumns_args"); private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)3); + private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); - /** - * name of the table - */ public ByteBuffer tableName; - /** - * row key - */ public ByteBuffer row; - /** - * timestamp - */ - public long timestamp; + public List columns; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { - /** - * name of the table - */ TABLE_NAME((short)1, "tableName"), - /** - * row key - */ ROW((short)2, "row"), - /** - * timestamp - */ - TIMESTAMP((short)3, "timestamp"); + COLUMNS((short)3, "columns"); private static final Map byName = new HashMap(); @@ -17010,8 +22005,8 @@ public class Hbase { return TABLE_NAME; case 2: // ROW return ROW; - case 3: // TIMESTAMP - return TIMESTAMP; + case 3: // COLUMNS + return COLUMNS; default: return null; } @@ -17052,8 +22047,6 @@ public class Hbase { } // isset id assignments - private static final int __TIMESTAMP_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { @@ -17062,57 +22055,57 @@ public class Hbase { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text"))); - tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "Text")))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowTs_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(countRowWithColumns_args.class, metaDataMap); } - public getRowTs_args() { + public countRowWithColumns_args() { } - public getRowTs_args( + public countRowWithColumns_args( ByteBuffer tableName, ByteBuffer row, - long timestamp) + List columns) { this(); this.tableName = tableName; this.row = row; - this.timestamp = timestamp; - setTimestampIsSet(true); + this.columns = columns; } /** * Performs a deep copy on other. */ - public getRowTs_args(getRowTs_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); + public countRowWithColumns_args(countRowWithColumns_args other) { if (other.isSetTableName()) { this.tableName = other.tableName; } if (other.isSetRow()) { this.row = other.row; } - this.timestamp = other.timestamp; + if (other.isSetColumns()) { + List __this__columns = new ArrayList(); + for (ByteBuffer other_element : other.columns) { + __this__columns.add(other_element); + } + this.columns = __this__columns; + } } - public getRowTs_args deepCopy() { - return new getRowTs_args(this); + public countRowWithColumns_args deepCopy() { + return new countRowWithColumns_args(this); } @Override public void clear() { this.tableName = null; this.row = null; - setTimestampIsSet(false); - this.timestamp = 0; + this.columns = null; } - /** - * name of the table - */ public byte[] getTableName() { setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); return tableName == null ? null : tableName.array(); @@ -17122,15 +22115,12 @@ public class Hbase { return tableName; } - /** - * name of the table - */ - public getRowTs_args setTableName(byte[] tableName) { + public countRowWithColumns_args setTableName(byte[] tableName) { setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); return this; } - public getRowTs_args setTableName(ByteBuffer tableName) { + public countRowWithColumns_args setTableName(ByteBuffer tableName) { this.tableName = tableName; return this; } @@ -17150,9 +22140,6 @@ public class Hbase { } } - /** - * row key - */ public byte[] getRow() { setRow(org.apache.thrift.TBaseHelper.rightSize(row)); return row == null ? null : row.array(); @@ -17162,15 +22149,12 @@ public class Hbase { return row; } - /** - * row key - */ - public getRowTs_args setRow(byte[] row) { + public countRowWithColumns_args setRow(byte[] row) { setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); return this; } - public getRowTs_args setRow(ByteBuffer row) { + public countRowWithColumns_args setRow(ByteBuffer row) { this.row = row; return this; } @@ -17190,33 +22174,43 @@ public class Hbase { } } - /** - * timestamp - */ - public long getTimestamp() { - return this.timestamp; + public int getColumnsSize() { + return (this.columns == null) ? 0 : this.columns.size(); } - /** - * timestamp - */ - public getRowTs_args setTimestamp(long timestamp) { - this.timestamp = timestamp; - setTimestampIsSet(true); + public java.util.Iterator getColumnsIterator() { + return (this.columns == null) ? null : this.columns.iterator(); + } + + public void addToColumns(ByteBuffer elem) { + if (this.columns == null) { + this.columns = new ArrayList(); + } + this.columns.add(elem); + } + + public List getColumns() { + return this.columns; + } + + public countRowWithColumns_args setColumns(List columns) { + this.columns = columns; return this; } - public void unsetTimestamp() { - __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID); + public void unsetColumns() { + this.columns = null; } - /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */ - public boolean isSetTimestamp() { - return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID); + /** Returns true if field columns is set (has been assigned a value) and false otherwise */ + public boolean isSetColumns() { + return this.columns != null; } - public void setTimestampIsSet(boolean value) { - __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value); + public void setColumnsIsSet(boolean value) { + if (!value) { + this.columns = null; + } } public void setFieldValue(_Fields field, Object value) { @@ -17237,11 +22231,11 @@ public class Hbase { } break; - case TIMESTAMP: + case COLUMNS: if (value == null) { - unsetTimestamp(); + unsetColumns(); } else { - setTimestamp((Long)value); + setColumns((List)value); } break; @@ -17256,8 +22250,8 @@ public class Hbase { case ROW: return getRow(); - case TIMESTAMP: - return new Long(getTimestamp()); + case COLUMNS: + return getColumns(); } throw new IllegalStateException(); @@ -17274,8 +22268,8 @@ public class Hbase { return isSetTableName(); case ROW: return isSetRow(); - case TIMESTAMP: - return isSetTimestamp(); + case COLUMNS: + return isSetColumns(); } throw new IllegalStateException(); } @@ -17284,12 +22278,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getRowTs_args) - return this.equals((getRowTs_args)that); + if (that instanceof countRowWithColumns_args) + return this.equals((countRowWithColumns_args)that); return false; } - public boolean equals(getRowTs_args that) { + public boolean equals(countRowWithColumns_args that) { if (that == null) return false; @@ -17311,12 +22305,12 @@ public class Hbase { return false; } - boolean this_present_timestamp = true; - boolean that_present_timestamp = true; - if (this_present_timestamp || that_present_timestamp) { - if (!(this_present_timestamp && that_present_timestamp)) + boolean this_present_columns = true && this.isSetColumns(); + boolean that_present_columns = true && that.isSetColumns(); + if (this_present_columns || that_present_columns) { + if (!(this_present_columns && that_present_columns)) return false; - if (this.timestamp != that.timestamp) + if (!this.columns.equals(that.columns)) return false; } @@ -17328,13 +22322,13 @@ public class Hbase { return 0; } - public int compareTo(getRowTs_args other) { + public int compareTo(countRowWithColumns_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getRowTs_args typedOther = (getRowTs_args)other; + countRowWithColumns_args typedOther = (countRowWithColumns_args)other; lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); if (lastComparison != 0) { @@ -17356,12 +22350,12 @@ public class Hbase { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(typedOther.isSetTimestamp()); + lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns()); if (lastComparison != 0) { return lastComparison; } - if (isSetTimestamp()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp); + if (isSetColumns()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns); if (lastComparison != 0) { return lastComparison; } @@ -17397,10 +22391,19 @@ public class Hbase { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; - case 3: // TIMESTAMP - if (field.type == org.apache.thrift.protocol.TType.I64) { - this.timestamp = iprot.readI64(); - setTimestampIsSet(true); + case 3: // COLUMNS + if (field.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list78 = iprot.readListBegin(); + this.columns = new ArrayList(_list78.size); + for (int _i79 = 0; _i79 < _list78.size; ++_i79) + { + ByteBuffer _elem80; + _elem80 = iprot.readBinary(); + this.columns.add(_elem80); + } + iprot.readListEnd(); + } } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -17430,16 +22433,25 @@ public class Hbase { oprot.writeBinary(this.row); oprot.writeFieldEnd(); } - oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC); - oprot.writeI64(this.timestamp); - oprot.writeFieldEnd(); + if (this.columns != null) { + oprot.writeFieldBegin(COLUMNS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); + for (ByteBuffer _iter81 : this.columns) + { + oprot.writeBinary(_iter81); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @Override public String toString() { - StringBuilder sb = new StringBuilder("getRowTs_args("); + StringBuilder sb = new StringBuilder("countRowWithColumns_args("); boolean first = true; sb.append("tableName:"); @@ -17458,8 +22470,12 @@ public class Hbase { } first = false; if (!first) sb.append(", "); - sb.append("timestamp:"); - sb.append(this.timestamp); + sb.append("columns:"); + if (this.columns == null) { + sb.append("null"); + } else { + sb.append(this.columns); + } first = false; sb.append(")"); return sb.toString(); @@ -17487,13 +22503,13 @@ public class Hbase { } - public static class getRowTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowTs_result"); + public static class countRowWithColumns_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("countRowWithColumns_result"); - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (short)0); private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); - public List success; + public int success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -17558,101 +22574,84 @@ public class Hbase { } // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private BitSet __isset_bit_vector = new BitSet(1); public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowTs_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(countRowWithColumns_result.class, metaDataMap); } - public getRowTs_result() { + public countRowWithColumns_result() { } - public getRowTs_result( - List success, + public countRowWithColumns_result( + int success, IOError io) { this(); this.success = success; + setSuccessIsSet(true); this.io = io; } /** * Performs a deep copy on other. */ - public getRowTs_result(getRowTs_result other) { - if (other.isSetSuccess()) { - List __this__success = new ArrayList(); - for (TRowResult other_element : other.success) { - __this__success.add(new TRowResult(other_element)); - } - this.success = __this__success; - } + public countRowWithColumns_result(countRowWithColumns_result other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + this.success = other.success; if (other.isSetIo()) { this.io = new IOError(other.io); } } - public getRowTs_result deepCopy() { - return new getRowTs_result(this); + public countRowWithColumns_result deepCopy() { + return new countRowWithColumns_result(this); } @Override public void clear() { - this.success = null; + setSuccessIsSet(false); + this.success = 0; this.io = null; } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } - - public java.util.Iterator getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } - - public void addToSuccess(TRowResult elem) { - if (this.success == null) { - this.success = new ArrayList(); - } - this.success.add(elem); - } - - public List getSuccess() { + public int getSuccess() { return this.success; } - public getRowTs_result setSuccess(List success) { + public countRowWithColumns_result setSuccess(int success) { this.success = success; + setSuccessIsSet(true); return this; } public void unsetSuccess() { - this.success = null; + __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } /** Returns true if field success is set (has been assigned a value) and false otherwise */ public boolean isSetSuccess() { - return this.success != null; + return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } + __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); } public IOError getIo() { return this.io; } - public getRowTs_result setIo(IOError io) { + public countRowWithColumns_result setIo(IOError io) { this.io = io; return this; } @@ -17678,7 +22677,7 @@ public class Hbase { if (value == null) { unsetSuccess(); } else { - setSuccess((List)value); + setSuccess((Integer)value); } break; @@ -17696,7 +22695,7 @@ public class Hbase { public Object getFieldValue(_Fields field) { switch (field) { case SUCCESS: - return getSuccess(); + return new Integer(getSuccess()); case IO: return getIo(); @@ -17724,21 +22723,21 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getRowTs_result) - return this.equals((getRowTs_result)that); + if (that instanceof countRowWithColumns_result) + return this.equals((countRowWithColumns_result)that); return false; } - public boolean equals(getRowTs_result that) { + public boolean equals(countRowWithColumns_result that) { if (that == null) return false; - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); + boolean this_present_success = true; + boolean that_present_success = true; if (this_present_success || that_present_success) { if (!(this_present_success && that_present_success)) return false; - if (!this.success.equals(that.success)) + if (this.success != that.success) return false; } @@ -17759,13 +22758,13 @@ public class Hbase { return 0; } - public int compareTo(getRowTs_result other) { + public int compareTo(countRowWithColumns_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getRowTs_result typedOther = (getRowTs_result)other; + countRowWithColumns_result typedOther = (countRowWithColumns_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -17805,19 +22804,9 @@ public class Hbase { } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list50 = iprot.readListBegin(); - this.success = new ArrayList(_list50.size); - for (int _i51 = 0; _i51 < _list50.size; ++_i51) - { - TRowResult _elem52; - _elem52 = new TRowResult(); - _elem52.read(iprot); - this.success.add(_elem52); - } - iprot.readListEnd(); - } + if (field.type == org.apache.thrift.protocol.TType.I32) { + this.success = iprot.readI32(); + setSuccessIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -17846,14 +22835,7 @@ public class Hbase { if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter53 : this.success) - { - _iter53.write(oprot); - } - oprot.writeListEnd(); - } + oprot.writeI32(this.success); oprot.writeFieldEnd(); } else if (this.isSetIo()) { oprot.writeFieldBegin(IO_FIELD_DESC); @@ -17866,15 +22848,11 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("getRowTs_result("); + StringBuilder sb = new StringBuilder("countRowWithColumns_result("); boolean first = true; sb.append("success:"); - if (this.success == null) { - sb.append("null"); - } else { - sb.append(this.success); - } + sb.append(this.success); first = false; if (!first) sb.append(", "); sb.append("io:"); @@ -17910,41 +22888,23 @@ public class Hbase { } - public static class getRowWithColumnsTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsTs_args"); + public static class countRowWithColumnsTs_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("countRowWithColumnsTs_args"); private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2); private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3); private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)4); - /** - * name of table - */ public ByteBuffer tableName; - /** - * row key - */ public ByteBuffer row; - /** - * List of columns to return, null for all columns - */ public List columns; public long timestamp; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { - /** - * name of table - */ TABLE_NAME((short)1, "tableName"), - /** - * row key - */ ROW((short)2, "row"), - /** - * List of columns to return, null for all columns - */ COLUMNS((short)3, "columns"), TIMESTAMP((short)4, "timestamp"); @@ -18025,13 +22985,13 @@ public class Hbase { tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(countRowWithColumnsTs_args.class, metaDataMap); } - public getRowWithColumnsTs_args() { + public countRowWithColumnsTs_args() { } - public getRowWithColumnsTs_args( + public countRowWithColumnsTs_args( ByteBuffer tableName, ByteBuffer row, List columns, @@ -18048,7 +23008,7 @@ public class Hbase { /** * Performs a deep copy on other. */ - public getRowWithColumnsTs_args(getRowWithColumnsTs_args other) { + public countRowWithColumnsTs_args(countRowWithColumnsTs_args other) { __isset_bit_vector.clear(); __isset_bit_vector.or(other.__isset_bit_vector); if (other.isSetTableName()) { @@ -18067,8 +23027,8 @@ public class Hbase { this.timestamp = other.timestamp; } - public getRowWithColumnsTs_args deepCopy() { - return new getRowWithColumnsTs_args(this); + public countRowWithColumnsTs_args deepCopy() { + return new countRowWithColumnsTs_args(this); } @Override @@ -18080,9 +23040,6 @@ public class Hbase { this.timestamp = 0; } - /** - * name of table - */ public byte[] getTableName() { setTableName(org.apache.thrift.TBaseHelper.rightSize(tableName)); return tableName == null ? null : tableName.array(); @@ -18092,15 +23049,12 @@ public class Hbase { return tableName; } - /** - * name of table - */ - public getRowWithColumnsTs_args setTableName(byte[] tableName) { + public countRowWithColumnsTs_args setTableName(byte[] tableName) { setTableName(tableName == null ? (ByteBuffer)null : ByteBuffer.wrap(tableName)); return this; } - public getRowWithColumnsTs_args setTableName(ByteBuffer tableName) { + public countRowWithColumnsTs_args setTableName(ByteBuffer tableName) { this.tableName = tableName; return this; } @@ -18120,9 +23074,6 @@ public class Hbase { } } - /** - * row key - */ public byte[] getRow() { setRow(org.apache.thrift.TBaseHelper.rightSize(row)); return row == null ? null : row.array(); @@ -18132,15 +23083,12 @@ public class Hbase { return row; } - /** - * row key - */ - public getRowWithColumnsTs_args setRow(byte[] row) { + public countRowWithColumnsTs_args setRow(byte[] row) { setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row)); return this; } - public getRowWithColumnsTs_args setRow(ByteBuffer row) { + public countRowWithColumnsTs_args setRow(ByteBuffer row) { this.row = row; return this; } @@ -18175,17 +23123,11 @@ public class Hbase { this.columns.add(elem); } - /** - * List of columns to return, null for all columns - */ public List getColumns() { return this.columns; } - /** - * List of columns to return, null for all columns - */ - public getRowWithColumnsTs_args setColumns(List columns) { + public countRowWithColumnsTs_args setColumns(List columns) { this.columns = columns; return this; } @@ -18209,7 +23151,7 @@ public class Hbase { return this.timestamp; } - public getRowWithColumnsTs_args setTimestamp(long timestamp) { + public countRowWithColumnsTs_args setTimestamp(long timestamp) { this.timestamp = timestamp; setTimestampIsSet(true); return this; @@ -18306,12 +23248,12 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getRowWithColumnsTs_args) - return this.equals((getRowWithColumnsTs_args)that); + if (that instanceof countRowWithColumnsTs_args) + return this.equals((countRowWithColumnsTs_args)that); return false; } - public boolean equals(getRowWithColumnsTs_args that) { + public boolean equals(countRowWithColumnsTs_args that) { if (that == null) return false; @@ -18359,13 +23301,13 @@ public class Hbase { return 0; } - public int compareTo(getRowWithColumnsTs_args other) { + public int compareTo(countRowWithColumnsTs_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getRowWithColumnsTs_args typedOther = (getRowWithColumnsTs_args)other; + countRowWithColumnsTs_args typedOther = (countRowWithColumnsTs_args)other; lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName()); if (lastComparison != 0) { @@ -18441,13 +23383,13 @@ public class Hbase { case 3: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list54 = iprot.readListBegin(); - this.columns = new ArrayList(_list54.size); - for (int _i55 = 0; _i55 < _list54.size; ++_i55) + org.apache.thrift.protocol.TList _list82 = iprot.readListBegin(); + this.columns = new ArrayList(_list82.size); + for (int _i83 = 0; _i83 < _list82.size; ++_i83) { - ByteBuffer _elem56; - _elem56 = iprot.readBinary(); - this.columns.add(_elem56); + ByteBuffer _elem84; + _elem84 = iprot.readBinary(); + this.columns.add(_elem84); } iprot.readListEnd(); } @@ -18492,9 +23434,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); - for (ByteBuffer _iter57 : this.columns) + for (ByteBuffer _iter85 : this.columns) { - oprot.writeBinary(_iter57); + oprot.writeBinary(_iter85); } oprot.writeListEnd(); } @@ -18509,7 +23451,7 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("getRowWithColumnsTs_args("); + StringBuilder sb = new StringBuilder("countRowWithColumnsTs_args("); boolean first = true; sb.append("tableName:"); @@ -18557,6 +23499,8 @@ public class Hbase { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -18565,13 +23509,13 @@ public class Hbase { } - public static class getRowWithColumnsTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRowWithColumnsTs_result"); + public static class countRowWithColumnsTs_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("countRowWithColumnsTs_result"); - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (short)0); private static final org.apache.thrift.protocol.TField IO_FIELD_DESC = new org.apache.thrift.protocol.TField("io", org.apache.thrift.protocol.TType.STRUCT, (short)1); - public List success; + public int success; public IOError io; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -18636,101 +23580,84 @@ public class Hbase { } // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private BitSet __isset_bit_vector = new BitSet(1); public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRowResult.class)))); + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRowWithColumnsTs_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(countRowWithColumnsTs_result.class, metaDataMap); } - public getRowWithColumnsTs_result() { + public countRowWithColumnsTs_result() { } - public getRowWithColumnsTs_result( - List success, + public countRowWithColumnsTs_result( + int success, IOError io) { this(); this.success = success; + setSuccessIsSet(true); this.io = io; } /** * Performs a deep copy on other. */ - public getRowWithColumnsTs_result(getRowWithColumnsTs_result other) { - if (other.isSetSuccess()) { - List __this__success = new ArrayList(); - for (TRowResult other_element : other.success) { - __this__success.add(new TRowResult(other_element)); - } - this.success = __this__success; - } + public countRowWithColumnsTs_result(countRowWithColumnsTs_result other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + this.success = other.success; if (other.isSetIo()) { this.io = new IOError(other.io); } } - public getRowWithColumnsTs_result deepCopy() { - return new getRowWithColumnsTs_result(this); + public countRowWithColumnsTs_result deepCopy() { + return new countRowWithColumnsTs_result(this); } @Override public void clear() { - this.success = null; + setSuccessIsSet(false); + this.success = 0; this.io = null; } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } - - public java.util.Iterator getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } - - public void addToSuccess(TRowResult elem) { - if (this.success == null) { - this.success = new ArrayList(); - } - this.success.add(elem); - } - - public List getSuccess() { + public int getSuccess() { return this.success; } - public getRowWithColumnsTs_result setSuccess(List success) { + public countRowWithColumnsTs_result setSuccess(int success) { this.success = success; + setSuccessIsSet(true); return this; } public void unsetSuccess() { - this.success = null; + __isset_bit_vector.clear(__SUCCESS_ISSET_ID); } /** Returns true if field success is set (has been assigned a value) and false otherwise */ public boolean isSetSuccess() { - return this.success != null; + return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } + __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); } public IOError getIo() { return this.io; } - public getRowWithColumnsTs_result setIo(IOError io) { + public countRowWithColumnsTs_result setIo(IOError io) { this.io = io; return this; } @@ -18756,7 +23683,7 @@ public class Hbase { if (value == null) { unsetSuccess(); } else { - setSuccess((List)value); + setSuccess((Integer)value); } break; @@ -18774,7 +23701,7 @@ public class Hbase { public Object getFieldValue(_Fields field) { switch (field) { case SUCCESS: - return getSuccess(); + return new Integer(getSuccess()); case IO: return getIo(); @@ -18802,21 +23729,21 @@ public class Hbase { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof getRowWithColumnsTs_result) - return this.equals((getRowWithColumnsTs_result)that); + if (that instanceof countRowWithColumnsTs_result) + return this.equals((countRowWithColumnsTs_result)that); return false; } - public boolean equals(getRowWithColumnsTs_result that) { + public boolean equals(countRowWithColumnsTs_result that) { if (that == null) return false; - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); + boolean this_present_success = true; + boolean that_present_success = true; if (this_present_success || that_present_success) { if (!(this_present_success && that_present_success)) return false; - if (!this.success.equals(that.success)) + if (this.success != that.success) return false; } @@ -18837,13 +23764,13 @@ public class Hbase { return 0; } - public int compareTo(getRowWithColumnsTs_result other) { + public int compareTo(countRowWithColumnsTs_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - getRowWithColumnsTs_result typedOther = (getRowWithColumnsTs_result)other; + countRowWithColumnsTs_result typedOther = (countRowWithColumnsTs_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -18883,19 +23810,9 @@ public class Hbase { } switch (field.id) { case 0: // SUCCESS - if (field.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list58 = iprot.readListBegin(); - this.success = new ArrayList(_list58.size); - for (int _i59 = 0; _i59 < _list58.size; ++_i59) - { - TRowResult _elem60; - _elem60 = new TRowResult(); - _elem60.read(iprot); - this.success.add(_elem60); - } - iprot.readListEnd(); - } + if (field.type == org.apache.thrift.protocol.TType.I32) { + this.success = iprot.readI32(); + setSuccessIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -18924,14 +23841,7 @@ public class Hbase { if (this.isSetSuccess()) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter61 : this.success) - { - _iter61.write(oprot); - } - oprot.writeListEnd(); - } + oprot.writeI32(this.success); oprot.writeFieldEnd(); } else if (this.isSetIo()) { oprot.writeFieldBegin(IO_FIELD_DESC); @@ -18944,15 +23854,11 @@ public class Hbase { @Override public String toString() { - StringBuilder sb = new StringBuilder("getRowWithColumnsTs_result("); + StringBuilder sb = new StringBuilder("countRowWithColumnsTs_result("); boolean first = true; sb.append("success:"); - if (this.success == null) { - sb.append("null"); - } else { - sb.append(this.success); - } + sb.append(this.success); first = false; if (!first) sb.append(", "); sb.append("io:"); @@ -19349,13 +24255,13 @@ public class Hbase { case 2: // ROWS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list62 = iprot.readListBegin(); - this.rows = new ArrayList(_list62.size); - for (int _i63 = 0; _i63 < _list62.size; ++_i63) + org.apache.thrift.protocol.TList _list86 = iprot.readListBegin(); + this.rows = new ArrayList(_list86.size); + for (int _i87 = 0; _i87 < _list86.size; ++_i87) { - ByteBuffer _elem64; - _elem64 = iprot.readBinary(); - this.rows.add(_elem64); + ByteBuffer _elem88; + _elem88 = iprot.readBinary(); + this.rows.add(_elem88); } iprot.readListEnd(); } @@ -19387,9 +24293,9 @@ public class Hbase { oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.rows.size())); - for (ByteBuffer _iter65 : this.rows) + for (ByteBuffer _iter89 : this.rows) { - oprot.writeBinary(_iter65); + oprot.writeBinary(_iter89); } oprot.writeListEnd(); } @@ -19765,14 +24671,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list66 = iprot.readListBegin(); - this.success = new ArrayList(_list66.size); - for (int _i67 = 0; _i67 < _list66.size; ++_i67) + org.apache.thrift.protocol.TList _list90 = iprot.readListBegin(); + this.success = new ArrayList(_list90.size); + for (int _i91 = 0; _i91 < _list90.size; ++_i91) { - TRowResult _elem68; - _elem68 = new TRowResult(); - _elem68.read(iprot); - this.success.add(_elem68); + TRowResult _elem92; + _elem92 = new TRowResult(); + _elem92.read(iprot); + this.success.add(_elem92); } iprot.readListEnd(); } @@ -19806,9 +24712,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter69 : this.success) + for (TRowResult _iter93 : this.success) { - _iter69.write(oprot); + _iter93.write(oprot); } oprot.writeListEnd(); } @@ -20330,13 +25236,13 @@ public class Hbase { case 2: // ROWS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list70 = iprot.readListBegin(); - this.rows = new ArrayList(_list70.size); - for (int _i71 = 0; _i71 < _list70.size; ++_i71) + org.apache.thrift.protocol.TList _list94 = iprot.readListBegin(); + this.rows = new ArrayList(_list94.size); + for (int _i95 = 0; _i95 < _list94.size; ++_i95) { - ByteBuffer _elem72; - _elem72 = iprot.readBinary(); - this.rows.add(_elem72); + ByteBuffer _elem96; + _elem96 = iprot.readBinary(); + this.rows.add(_elem96); } iprot.readListEnd(); } @@ -20347,13 +25253,13 @@ public class Hbase { case 3: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list73 = iprot.readListBegin(); - this.columns = new ArrayList(_list73.size); - for (int _i74 = 0; _i74 < _list73.size; ++_i74) + org.apache.thrift.protocol.TList _list97 = iprot.readListBegin(); + this.columns = new ArrayList(_list97.size); + for (int _i98 = 0; _i98 < _list97.size; ++_i98) { - ByteBuffer _elem75; - _elem75 = iprot.readBinary(); - this.columns.add(_elem75); + ByteBuffer _elem99; + _elem99 = iprot.readBinary(); + this.columns.add(_elem99); } iprot.readListEnd(); } @@ -20385,9 +25291,9 @@ public class Hbase { oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.rows.size())); - for (ByteBuffer _iter76 : this.rows) + for (ByteBuffer _iter100 : this.rows) { - oprot.writeBinary(_iter76); + oprot.writeBinary(_iter100); } oprot.writeListEnd(); } @@ -20397,9 +25303,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); - for (ByteBuffer _iter77 : this.columns) + for (ByteBuffer _iter101 : this.columns) { - oprot.writeBinary(_iter77); + oprot.writeBinary(_iter101); } oprot.writeListEnd(); } @@ -20783,14 +25689,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list78 = iprot.readListBegin(); - this.success = new ArrayList(_list78.size); - for (int _i79 = 0; _i79 < _list78.size; ++_i79) + org.apache.thrift.protocol.TList _list102 = iprot.readListBegin(); + this.success = new ArrayList(_list102.size); + for (int _i103 = 0; _i103 < _list102.size; ++_i103) { - TRowResult _elem80; - _elem80 = new TRowResult(); - _elem80.read(iprot); - this.success.add(_elem80); + TRowResult _elem104; + _elem104 = new TRowResult(); + _elem104.read(iprot); + this.success.add(_elem104); } iprot.readListEnd(); } @@ -20824,9 +25730,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter81 : this.success) + for (TRowResult _iter105 : this.success) { - _iter81.write(oprot); + _iter105.write(oprot); } oprot.writeListEnd(); } @@ -21331,13 +26237,13 @@ public class Hbase { case 2: // ROWS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list82 = iprot.readListBegin(); - this.rows = new ArrayList(_list82.size); - for (int _i83 = 0; _i83 < _list82.size; ++_i83) + org.apache.thrift.protocol.TList _list106 = iprot.readListBegin(); + this.rows = new ArrayList(_list106.size); + for (int _i107 = 0; _i107 < _list106.size; ++_i107) { - ByteBuffer _elem84; - _elem84 = iprot.readBinary(); - this.rows.add(_elem84); + ByteBuffer _elem108; + _elem108 = iprot.readBinary(); + this.rows.add(_elem108); } iprot.readListEnd(); } @@ -21377,9 +26283,9 @@ public class Hbase { oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.rows.size())); - for (ByteBuffer _iter85 : this.rows) + for (ByteBuffer _iter109 : this.rows) { - oprot.writeBinary(_iter85); + oprot.writeBinary(_iter109); } oprot.writeListEnd(); } @@ -21764,14 +26670,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list86 = iprot.readListBegin(); - this.success = new ArrayList(_list86.size); - for (int _i87 = 0; _i87 < _list86.size; ++_i87) + org.apache.thrift.protocol.TList _list110 = iprot.readListBegin(); + this.success = new ArrayList(_list110.size); + for (int _i111 = 0; _i111 < _list110.size; ++_i111) { - TRowResult _elem88; - _elem88 = new TRowResult(); - _elem88.read(iprot); - this.success.add(_elem88); + TRowResult _elem112; + _elem112 = new TRowResult(); + _elem112.read(iprot); + this.success.add(_elem112); } iprot.readListEnd(); } @@ -21805,9 +26711,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter89 : this.success) + for (TRowResult _iter113 : this.success) { - _iter89.write(oprot); + _iter113.write(oprot); } oprot.writeListEnd(); } @@ -22401,13 +27307,13 @@ public class Hbase { case 2: // ROWS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list90 = iprot.readListBegin(); - this.rows = new ArrayList(_list90.size); - for (int _i91 = 0; _i91 < _list90.size; ++_i91) + org.apache.thrift.protocol.TList _list114 = iprot.readListBegin(); + this.rows = new ArrayList(_list114.size); + for (int _i115 = 0; _i115 < _list114.size; ++_i115) { - ByteBuffer _elem92; - _elem92 = iprot.readBinary(); - this.rows.add(_elem92); + ByteBuffer _elem116; + _elem116 = iprot.readBinary(); + this.rows.add(_elem116); } iprot.readListEnd(); } @@ -22418,13 +27324,13 @@ public class Hbase { case 3: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list93 = iprot.readListBegin(); - this.columns = new ArrayList(_list93.size); - for (int _i94 = 0; _i94 < _list93.size; ++_i94) + org.apache.thrift.protocol.TList _list117 = iprot.readListBegin(); + this.columns = new ArrayList(_list117.size); + for (int _i118 = 0; _i118 < _list117.size; ++_i118) { - ByteBuffer _elem95; - _elem95 = iprot.readBinary(); - this.columns.add(_elem95); + ByteBuffer _elem119; + _elem119 = iprot.readBinary(); + this.columns.add(_elem119); } iprot.readListEnd(); } @@ -22464,9 +27370,9 @@ public class Hbase { oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.rows.size())); - for (ByteBuffer _iter96 : this.rows) + for (ByteBuffer _iter120 : this.rows) { - oprot.writeBinary(_iter96); + oprot.writeBinary(_iter120); } oprot.writeListEnd(); } @@ -22476,9 +27382,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); - for (ByteBuffer _iter97 : this.columns) + for (ByteBuffer _iter121 : this.columns) { - oprot.writeBinary(_iter97); + oprot.writeBinary(_iter121); } oprot.writeListEnd(); } @@ -22871,14 +27777,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list98 = iprot.readListBegin(); - this.success = new ArrayList(_list98.size); - for (int _i99 = 0; _i99 < _list98.size; ++_i99) + org.apache.thrift.protocol.TList _list122 = iprot.readListBegin(); + this.success = new ArrayList(_list122.size); + for (int _i123 = 0; _i123 < _list122.size; ++_i123) { - TRowResult _elem100; - _elem100 = new TRowResult(); - _elem100.read(iprot); - this.success.add(_elem100); + TRowResult _elem124; + _elem124 = new TRowResult(); + _elem124.read(iprot); + this.success.add(_elem124); } iprot.readListEnd(); } @@ -22912,9 +27818,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter101 : this.success) + for (TRowResult _iter125 : this.success) { - _iter101.write(oprot); + _iter125.write(oprot); } oprot.writeListEnd(); } @@ -23433,14 +28339,14 @@ public class Hbase { case 3: // MUTATIONS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list102 = iprot.readListBegin(); - this.mutations = new ArrayList(_list102.size); - for (int _i103 = 0; _i103 < _list102.size; ++_i103) + org.apache.thrift.protocol.TList _list126 = iprot.readListBegin(); + this.mutations = new ArrayList(_list126.size); + for (int _i127 = 0; _i127 < _list126.size; ++_i127) { - Mutation _elem104; - _elem104 = new Mutation(); - _elem104.read(iprot); - this.mutations.add(_elem104); + Mutation _elem128; + _elem128 = new Mutation(); + _elem128.read(iprot); + this.mutations.add(_elem128); } iprot.readListEnd(); } @@ -23477,9 +28383,9 @@ public class Hbase { oprot.writeFieldBegin(MUTATIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.mutations.size())); - for (Mutation _iter105 : this.mutations) + for (Mutation _iter129 : this.mutations) { - _iter105.write(oprot); + _iter129.write(oprot); } oprot.writeListEnd(); } @@ -24472,14 +29378,14 @@ public class Hbase { case 3: // MUTATIONS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list106 = iprot.readListBegin(); - this.mutations = new ArrayList(_list106.size); - for (int _i107 = 0; _i107 < _list106.size; ++_i107) + org.apache.thrift.protocol.TList _list130 = iprot.readListBegin(); + this.mutations = new ArrayList(_list130.size); + for (int _i131 = 0; _i131 < _list130.size; ++_i131) { - Mutation _elem108; - _elem108 = new Mutation(); - _elem108.read(iprot); - this.mutations.add(_elem108); + Mutation _elem132; + _elem132 = new Mutation(); + _elem132.read(iprot); + this.mutations.add(_elem132); } iprot.readListEnd(); } @@ -24524,9 +29430,9 @@ public class Hbase { oprot.writeFieldBegin(MUTATIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.mutations.size())); - for (Mutation _iter109 : this.mutations) + for (Mutation _iter133 : this.mutations) { - _iter109.write(oprot); + _iter133.write(oprot); } oprot.writeListEnd(); } @@ -25346,14 +30252,14 @@ public class Hbase { case 2: // ROW_BATCHES if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list110 = iprot.readListBegin(); - this.rowBatches = new ArrayList(_list110.size); - for (int _i111 = 0; _i111 < _list110.size; ++_i111) + org.apache.thrift.protocol.TList _list134 = iprot.readListBegin(); + this.rowBatches = new ArrayList(_list134.size); + for (int _i135 = 0; _i135 < _list134.size; ++_i135) { - BatchMutation _elem112; - _elem112 = new BatchMutation(); - _elem112.read(iprot); - this.rowBatches.add(_elem112); + BatchMutation _elem136; + _elem136 = new BatchMutation(); + _elem136.read(iprot); + this.rowBatches.add(_elem136); } iprot.readListEnd(); } @@ -25385,9 +30291,9 @@ public class Hbase { oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.rowBatches.size())); - for (BatchMutation _iter113 : this.rowBatches) + for (BatchMutation _iter137 : this.rowBatches) { - _iter113.write(oprot); + _iter137.write(oprot); } oprot.writeListEnd(); } @@ -26274,14 +31180,14 @@ public class Hbase { case 2: // ROW_BATCHES if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list114 = iprot.readListBegin(); - this.rowBatches = new ArrayList(_list114.size); - for (int _i115 = 0; _i115 < _list114.size; ++_i115) + org.apache.thrift.protocol.TList _list138 = iprot.readListBegin(); + this.rowBatches = new ArrayList(_list138.size); + for (int _i139 = 0; _i139 < _list138.size; ++_i139) { - BatchMutation _elem116; - _elem116 = new BatchMutation(); - _elem116.read(iprot); - this.rowBatches.add(_elem116); + BatchMutation _elem140; + _elem140 = new BatchMutation(); + _elem140.read(iprot); + this.rowBatches.add(_elem140); } iprot.readListEnd(); } @@ -26321,9 +31227,9 @@ public class Hbase { oprot.writeFieldBegin(ROW_BATCHES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.rowBatches.size())); - for (BatchMutation _iter117 : this.rowBatches) + for (BatchMutation _iter141 : this.rowBatches) { - _iter117.write(oprot); + _iter141.write(oprot); } oprot.writeListEnd(); } @@ -27404,6 +32310,8 @@ public class Hbase { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -29356,6 +34264,8 @@ public class Hbase { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -31685,13 +36595,13 @@ public class Hbase { case 3: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list118 = iprot.readListBegin(); - this.columns = new ArrayList(_list118.size); - for (int _i119 = 0; _i119 < _list118.size; ++_i119) + org.apache.thrift.protocol.TList _list142 = iprot.readListBegin(); + this.columns = new ArrayList(_list142.size); + for (int _i143 = 0; _i143 < _list142.size; ++_i143) { - ByteBuffer _elem120; - _elem120 = iprot.readBinary(); - this.columns.add(_elem120); + ByteBuffer _elem144; + _elem144 = iprot.readBinary(); + this.columns.add(_elem144); } iprot.readListEnd(); } @@ -31728,9 +36638,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); - for (ByteBuffer _iter121 : this.columns) + for (ByteBuffer _iter145 : this.columns) { - oprot.writeBinary(_iter121); + oprot.writeBinary(_iter145); } oprot.writeListEnd(); } @@ -32752,13 +37662,13 @@ public class Hbase { case 4: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list122 = iprot.readListBegin(); - this.columns = new ArrayList(_list122.size); - for (int _i123 = 0; _i123 < _list122.size; ++_i123) + org.apache.thrift.protocol.TList _list146 = iprot.readListBegin(); + this.columns = new ArrayList(_list146.size); + for (int _i147 = 0; _i147 < _list146.size; ++_i147) { - ByteBuffer _elem124; - _elem124 = iprot.readBinary(); - this.columns.add(_elem124); + ByteBuffer _elem148; + _elem148 = iprot.readBinary(); + this.columns.add(_elem148); } iprot.readListEnd(); } @@ -32800,9 +37710,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); - for (ByteBuffer _iter125 : this.columns) + for (ByteBuffer _iter149 : this.columns) { - oprot.writeBinary(_iter125); + oprot.writeBinary(_iter149); } oprot.writeListEnd(); } @@ -33718,13 +38628,13 @@ public class Hbase { case 3: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list126 = iprot.readListBegin(); - this.columns = new ArrayList(_list126.size); - for (int _i127 = 0; _i127 < _list126.size; ++_i127) + org.apache.thrift.protocol.TList _list150 = iprot.readListBegin(); + this.columns = new ArrayList(_list150.size); + for (int _i151 = 0; _i151 < _list150.size; ++_i151) { - ByteBuffer _elem128; - _elem128 = iprot.readBinary(); - this.columns.add(_elem128); + ByteBuffer _elem152; + _elem152 = iprot.readBinary(); + this.columns.add(_elem152); } iprot.readListEnd(); } @@ -33761,9 +38671,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); - for (ByteBuffer _iter129 : this.columns) + for (ByteBuffer _iter153 : this.columns) { - oprot.writeBinary(_iter129); + oprot.writeBinary(_iter153); } oprot.writeListEnd(); } @@ -34767,13 +39677,13 @@ public class Hbase { case 3: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list130 = iprot.readListBegin(); - this.columns = new ArrayList(_list130.size); - for (int _i131 = 0; _i131 < _list130.size; ++_i131) + org.apache.thrift.protocol.TList _list154 = iprot.readListBegin(); + this.columns = new ArrayList(_list154.size); + for (int _i155 = 0; _i155 < _list154.size; ++_i155) { - ByteBuffer _elem132; - _elem132 = iprot.readBinary(); - this.columns.add(_elem132); + ByteBuffer _elem156; + _elem156 = iprot.readBinary(); + this.columns.add(_elem156); } iprot.readListEnd(); } @@ -34818,9 +39728,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); - for (ByteBuffer _iter133 : this.columns) + for (ByteBuffer _iter157 : this.columns) { - oprot.writeBinary(_iter133); + oprot.writeBinary(_iter157); } oprot.writeListEnd(); } @@ -34883,8 +39793,6 @@ public class Hbase { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -35935,13 +40843,13 @@ public class Hbase { case 4: // COLUMNS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list134 = iprot.readListBegin(); - this.columns = new ArrayList(_list134.size); - for (int _i135 = 0; _i135 < _list134.size; ++_i135) + org.apache.thrift.protocol.TList _list158 = iprot.readListBegin(); + this.columns = new ArrayList(_list158.size); + for (int _i159 = 0; _i159 < _list158.size; ++_i159) { - ByteBuffer _elem136; - _elem136 = iprot.readBinary(); - this.columns.add(_elem136); + ByteBuffer _elem160; + _elem160 = iprot.readBinary(); + this.columns.add(_elem160); } iprot.readListEnd(); } @@ -35991,9 +40899,9 @@ public class Hbase { oprot.writeFieldBegin(COLUMNS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.columns.size())); - for (ByteBuffer _iter137 : this.columns) + for (ByteBuffer _iter161 : this.columns) { - oprot.writeBinary(_iter137); + oprot.writeBinary(_iter161); } oprot.writeListEnd(); } @@ -36756,6 +41664,8 @@ public class Hbase { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -37153,14 +42063,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list138 = iprot.readListBegin(); - this.success = new ArrayList(_list138.size); - for (int _i139 = 0; _i139 < _list138.size; ++_i139) + org.apache.thrift.protocol.TList _list162 = iprot.readListBegin(); + this.success = new ArrayList(_list162.size); + for (int _i163 = 0; _i163 < _list162.size; ++_i163) { - TRowResult _elem140; - _elem140 = new TRowResult(); - _elem140.read(iprot); - this.success.add(_elem140); + TRowResult _elem164; + _elem164 = new TRowResult(); + _elem164.read(iprot); + this.success.add(_elem164); } iprot.readListEnd(); } @@ -37202,9 +42112,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter141 : this.success) + for (TRowResult _iter165 : this.success) { - _iter141.write(oprot); + _iter165.write(oprot); } oprot.writeListEnd(); } @@ -38068,14 +42978,14 @@ public class Hbase { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list142 = iprot.readListBegin(); - this.success = new ArrayList(_list142.size); - for (int _i143 = 0; _i143 < _list142.size; ++_i143) + org.apache.thrift.protocol.TList _list166 = iprot.readListBegin(); + this.success = new ArrayList(_list166.size); + for (int _i167 = 0; _i167 < _list166.size; ++_i167) { - TRowResult _elem144; - _elem144 = new TRowResult(); - _elem144.read(iprot); - this.success.add(_elem144); + TRowResult _elem168; + _elem168 = new TRowResult(); + _elem168.read(iprot); + this.success.add(_elem168); } iprot.readListEnd(); } @@ -38117,9 +43027,9 @@ public class Hbase { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TRowResult _iter145 : this.success) + for (TRowResult _iter169 : this.success) { - _iter145.write(oprot); + _iter169.write(oprot); } oprot.writeListEnd(); } @@ -38490,6 +43400,8 @@ public class Hbase { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); diff --git a/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift b/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift index 57c7744..945a51f 100644 --- a/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift +++ b/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift @@ -329,6 +329,28 @@ service Hbase { 3:list columns ) throws (1:IOError io) + /** + * Get the specified columns for the specified table and row at the latest + * timestamp, paginated by specified limit and offset. Returns an empty list + * if no rows exist. + * + * @return TRowResult containing the rows and map of columns to TCells + */ + list getRowWithColumnsPaginated( + /** name of table */ + 1:Text tableName, + + /** row keys */ + 2:Text rows + + /** List of columns to return, null for all columns */ + 3:list columns, + + 4:i32 limit, + + 5:i32 offset + ) throws (1:IOError io) + /** * Get all the data for the specified table and row at the specified * timestamp. Returns an empty list if the row does not exist. @@ -363,6 +385,51 @@ service Hbase { 3:list columns, 4:i64 timestamp ) throws (1:IOError io) + + /** + * Get the specified columns for the specified table and row at the specified + * timestamp, paginated by specified limit and offset. Returns an empty list + * if the row does not exist. + * + * @return TRowResult containing the row and map of columns to TCells + */ + list getRowWithColumnsPaginatedTs( + /** name of table */ + 1:Text tableName, + + /** row key */ + 2:Text row, + + /** List of columns to return, null for all columns */ + 3:list columns, + 4:i64 timestamp, + 5:i32 limit, + 6:i32 offset + ) throws (1:IOError io) + + /** + * Counts specified columns for the specified table and row. + * + * @return int + */ + i32 countRowWithColumns( + 1:Text tableName, + 2:Text row, + 3:list columns + ) throws (1:IOError io) + + /** + * Counts specified columns for the specified table and row at the specified + * timestamp. + * + * @return int + */ + i32 countRowWithColumnsTs( + 1:Text tableName, + 2:Text row, + 3:list columns, + 4:i64 timestamp + ) throws (1:IOError io) /** * Get all the data for the specified table and rows at the latest -- 1.7.4.1