You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by ns...@apache.org on 2011/10/11 19:43:53 UTC
svn commit: r1181951 [2/3] - in /hbase/branches/0.89/src:
main/java/org/apache/hadoop/hbase/client/
main/java/org/apache/hadoop/hbase/ipc/
main/java/org/apache/hadoop/hbase/regionserver/
main/java/org/apache/hadoop/hbase/thrift/ main/java/org/apache/ha...
Modified: hbase/branches/0.89/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java
URL: http://svn.apache.org/viewvc/hbase/branches/0.89/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java?rev=1181951&r1=1181950&r2=1181951&view=diff
==============================================================================
--- hbase/branches/0.89/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java (original)
+++ hbase/branches/0.89/src/main/java/org/apache/hadoop/hbase/thrift/generated/Hbase.java Tue Oct 11 17:43:52 2011
@@ -211,6 +211,52 @@ public class Hbase {
public List<TRowResult> getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp) throws IOError, TException;
/**
+ * Get multiple rows with the same columns or timestamps for all.
+ * This returns latest entries, all columns and cfs.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ *
+ * @param tableName
+ * @param rows
+ */
+ public List<TRowResult> getRows(byte[] tableName, List<byte[]> rows) throws IOError, TException;
+
+ /**
+ * Get multiple rows only up to a certain timestamp
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ *
+ * @param tableName
+ * @param rows
+ * @param timestamp
+ */
+ public List<TRowResult> getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws IOError, TException;
+
+ /**
+ * Get multiple rows only with particular cf:qualifier pairs on all rows
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ *
+ * @param tableName
+ * @param rows
+ * @param families
+ */
+ public List<TRowResult> getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> families) throws IOError, TException;
+
+ /**
+ * Get multiple rows only with particular cf:qualifier pairs on all rows
+ * and only up to a particular timestamp.
+ *
+ * @return TRowResult containing the row and map of columns to TCells
+ *
+ * @param tableName
+ * @param rows
+ * @param families
+ * @param timestamp
+ */
+ public List<TRowResult> getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> families, long timestamp) throws IOError, TException;
+
+ /**
* Apply a series of mutations (updates/deletes) to a row in a
* single transaction. If an exception is thrown, then the
* transaction is aborted. Default current timestamp is used, and
@@ -267,6 +313,43 @@ public class Hbase {
public void mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp) throws IOError, IllegalArgument, TException;
/**
+ * Applies a list of mutations to a single row only if the value for
+ * row, cf[:qualifier] equals valueCheck
+ *
+ * Accepts null or '' for valueCheck, in which case entry for
+ * row, cf[:qualifier] must not exist.
+ *
+ * @return bool whether the check passed and mutations were applied
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param columnCheck
+ * @param valueCheck
+ * @param mutations list of mutation commands
+ */
+ public boolean checkAndMutateRow(byte[] tableName, byte[] row, byte[] columnCheck, byte[] valueCheck, List<Mutation> mutations) throws IOError, IllegalArgument, TException;
+
+ /**
+ * Same as above, but the puts and deletes are added at specified timestamp.
+ *
+ * NOTE: No way to specify what timerange to query for the checked value;
+ * it will look for most recent entry (the default Get behavior).
+ *
+ * @param tableName name of table
+ *
+ * @param row row key
+ *
+ * @param columnCheck
+ * @param valueCheck
+ * @param mutations list of mutation commands
+ *
+ * @param timestamp timestamp
+ */
+ public boolean checkAndMutateRowTs(byte[] tableName, byte[] row, byte[] columnCheck, byte[] valueCheck, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException;
+
+ /**
* Atomically increment the column value specified. Returns the next value post increment.
*
* @param tableName name of table
@@ -1204,6 +1287,158 @@ public class Hbase {
throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
}
+ public List<TRowResult> getRows(byte[] tableName, List<byte[]> rows) throws IOError, TException
+ {
+ send_getRows(tableName, rows);
+ return recv_getRows();
+ }
+
+ public void send_getRows(byte[] tableName, List<byte[]> rows) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("getRows", TMessageType.CALL, seqid_));
+ getRows_args args = new getRows_args();
+ args.tableName = tableName;
+ args.rows = rows;
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public List<TRowResult> recv_getRows() throws IOError, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ getRows_result result = new getRows_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRows failed: unknown result");
+ }
+
+ public List<TRowResult> getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws IOError, TException
+ {
+ send_getRowsTs(tableName, rows, timestamp);
+ return recv_getRowsTs();
+ }
+
+ public void send_getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("getRowsTs", TMessageType.CALL, seqid_));
+ getRowsTs_args args = new getRowsTs_args();
+ args.tableName = tableName;
+ args.rows = rows;
+ args.timestamp = timestamp;
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public List<TRowResult> recv_getRowsTs() throws IOError, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ getRowsTs_result result = new getRowsTs_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsTs failed: unknown result");
+ }
+
+ public List<TRowResult> getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> families) throws IOError, TException
+ {
+ send_getRowsWithColumns(tableName, rows, families);
+ return recv_getRowsWithColumns();
+ }
+
+ public void send_getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> families) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.CALL, seqid_));
+ getRowsWithColumns_args args = new getRowsWithColumns_args();
+ args.tableName = tableName;
+ args.rows = rows;
+ args.families = families;
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public List<TRowResult> recv_getRowsWithColumns() throws IOError, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ getRowsWithColumns_result result = new getRowsWithColumns_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumns failed: unknown result");
+ }
+
+ public List<TRowResult> getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> families, long timestamp) throws IOError, TException
+ {
+ send_getRowsWithColumnsTs(tableName, rows, families, timestamp);
+ return recv_getRowsWithColumnsTs();
+ }
+
+ public void send_getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> families, long timestamp) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.CALL, seqid_));
+ getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args();
+ args.tableName = tableName;
+ args.rows = rows;
+ args.families = families;
+ args.timestamp = timestamp;
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public List<TRowResult> recv_getRowsWithColumnsTs() throws IOError, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result");
+ }
+
public void mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations) throws IOError, IllegalArgument, TException
{
send_mutateRow(tableName, row, mutations);
@@ -1356,6 +1591,93 @@ public class Hbase {
return;
}
+ public boolean checkAndMutateRow(byte[] tableName, byte[] row, byte[] columnCheck, byte[] valueCheck, List<Mutation> mutations) throws IOError, IllegalArgument, TException
+ {
+ send_checkAndMutateRow(tableName, row, columnCheck, valueCheck, mutations);
+ return recv_checkAndMutateRow();
+ }
+
+ public void send_checkAndMutateRow(byte[] tableName, byte[] row, byte[] columnCheck, byte[] valueCheck, List<Mutation> mutations) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("checkAndMutateRow", TMessageType.CALL, seqid_));
+ checkAndMutateRow_args args = new checkAndMutateRow_args();
+ args.tableName = tableName;
+ args.row = row;
+ args.columnCheck = columnCheck;
+ args.valueCheck = valueCheck;
+ args.mutations = mutations;
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public boolean recv_checkAndMutateRow() throws IOError, IllegalArgument, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ checkAndMutateRow_result result = new checkAndMutateRow_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ throw new TApplicationException(TApplicationException.MISSING_RESULT, "checkAndMutateRow failed: unknown result");
+ }
+
+ public boolean checkAndMutateRowTs(byte[] tableName, byte[] row, byte[] columnCheck, byte[] valueCheck, List<Mutation> mutations, long timestamp) throws IOError, IllegalArgument, TException
+ {
+ send_checkAndMutateRowTs(tableName, row, columnCheck, valueCheck, mutations, timestamp);
+ return recv_checkAndMutateRowTs();
+ }
+
+ public void send_checkAndMutateRowTs(byte[] tableName, byte[] row, byte[] columnCheck, byte[] valueCheck, List<Mutation> mutations, long timestamp) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("checkAndMutateRowTs", TMessageType.CALL, seqid_));
+ checkAndMutateRowTs_args args = new checkAndMutateRowTs_args();
+ args.tableName = tableName;
+ args.row = row;
+ args.columnCheck = columnCheck;
+ args.valueCheck = valueCheck;
+ args.mutations = mutations;
+ args.timestamp = timestamp;
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public boolean recv_checkAndMutateRowTs() throws IOError, IllegalArgument, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ checkAndMutateRowTs_result result = new checkAndMutateRowTs_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.io != null) {
+ throw result.io;
+ }
+ if (result.ia != null) {
+ throw result.ia;
+ }
+ throw new TApplicationException(TApplicationException.MISSING_RESULT, "checkAndMutateRowTs failed: unknown result");
+ }
+
public long atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value) throws IOError, IllegalArgument, TException
{
send_atomicIncrement(tableName, row, column, value);
@@ -2061,10 +2383,16 @@ public class Hbase {
processMap_.put("getRowWithColumns", new getRowWithColumns());
processMap_.put("getRowTs", new getRowTs());
processMap_.put("getRowWithColumnsTs", new getRowWithColumnsTs());
+ processMap_.put("getRows", new getRows());
+ processMap_.put("getRowsTs", new getRowsTs());
+ processMap_.put("getRowsWithColumns", new getRowsWithColumns());
+ processMap_.put("getRowsWithColumnsTs", new getRowsWithColumnsTs());
processMap_.put("mutateRow", new mutateRow());
processMap_.put("mutateRowTs", new mutateRowTs());
processMap_.put("mutateRows", new mutateRows());
processMap_.put("mutateRowsTs", new mutateRowsTs());
+ processMap_.put("checkAndMutateRow", new checkAndMutateRow());
+ processMap_.put("checkAndMutateRowTs", new checkAndMutateRowTs());
processMap_.put("atomicIncrement", new atomicIncrement());
processMap_.put("deleteAll", new deleteAll());
processMap_.put("deleteAllTs", new deleteAllTs());
@@ -2591,6 +2919,118 @@ public class Hbase {
}
+ private class getRows implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ getRows_args args = new getRows_args();
+ args.read(iprot);
+ iprot.readMessageEnd();
+ getRows_result result = new getRows_result();
+ try {
+ result.success = iface_.getRows(args.tableName, args.rows);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing getRows", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRows");
+ oprot.writeMessageBegin(new TMessage("getRows", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("getRows", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class getRowsTs implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ getRowsTs_args args = new getRowsTs_args();
+ args.read(iprot);
+ iprot.readMessageEnd();
+ getRowsTs_result result = new getRowsTs_result();
+ try {
+ result.success = iface_.getRowsTs(args.tableName, args.rows, args.timestamp);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing getRowsTs", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsTs");
+ oprot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("getRowsTs", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class getRowsWithColumns implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ getRowsWithColumns_args args = new getRowsWithColumns_args();
+ args.read(iprot);
+ iprot.readMessageEnd();
+ getRowsWithColumns_result result = new getRowsWithColumns_result();
+ try {
+ result.success = iface_.getRowsWithColumns(args.tableName, args.rows, args.families);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing getRowsWithColumns", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumns");
+ oprot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("getRowsWithColumns", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class getRowsWithColumnsTs implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ getRowsWithColumnsTs_args args = new getRowsWithColumnsTs_args();
+ args.read(iprot);
+ iprot.readMessageEnd();
+ getRowsWithColumnsTs_result result = new getRowsWithColumnsTs_result();
+ try {
+ result.success = iface_.getRowsWithColumnsTs(args.tableName, args.rows, args.families, args.timestamp);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing getRowsWithColumnsTs", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getRowsWithColumnsTs");
+ oprot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("getRowsWithColumnsTs", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
private class mutateRow implements ProcessFunction {
public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
{
@@ -2711,6 +3151,68 @@ public class Hbase {
}
+ private class checkAndMutateRow implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ checkAndMutateRow_args args = new checkAndMutateRow_args();
+ args.read(iprot);
+ iprot.readMessageEnd();
+ checkAndMutateRow_result result = new checkAndMutateRow_result();
+ try {
+ result.success = iface_.checkAndMutateRow(args.tableName, args.row, args.columnCheck, args.valueCheck, args.mutations);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing checkAndMutateRow", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing checkAndMutateRow");
+ oprot.writeMessageBegin(new TMessage("checkAndMutateRow", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("checkAndMutateRow", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class checkAndMutateRowTs implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ checkAndMutateRowTs_args args = new checkAndMutateRowTs_args();
+ args.read(iprot);
+ iprot.readMessageEnd();
+ checkAndMutateRowTs_result result = new checkAndMutateRowTs_result();
+ try {
+ result.success = iface_.checkAndMutateRowTs(args.tableName, args.row, args.columnCheck, args.valueCheck, args.mutations, args.timestamp);
+ result.setSuccessIsSet(true);
+ } catch (IOError io) {
+ result.io = io;
+ } catch (IllegalArgument ia) {
+ result.ia = ia;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing checkAndMutateRowTs", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing checkAndMutateRowTs");
+ oprot.writeMessageBegin(new TMessage("checkAndMutateRowTs", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("checkAndMutateRowTs", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
private class atomicIncrement implements ProcessFunction {
public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
{
@@ -16466,40 +16968,19 @@ public class Hbase {
}
- public static class mutateRow_args implements TBase<mutateRow_args._Fields>, java.io.Serializable, Cloneable, Comparable<mutateRow_args> {
- private static final TStruct STRUCT_DESC = new TStruct("mutateRow_args");
+ public static class getRows_args implements TBase<getRows_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRows_args> {
+ private static final TStruct STRUCT_DESC = new TStruct("getRows_args");
private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
- private static final TField ROW_FIELD_DESC = new TField("row", TType.STRING, (short)2);
- private static final TField MUTATIONS_FIELD_DESC = new TField("mutations", TType.LIST, (short)3);
+ private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
- /**
- * name of table
- */
public byte[] tableName;
- /**
- * row key
- */
- public byte[] row;
- /**
- * list of mutation commands
- */
- public List<Mutation> mutations;
+ public List<byte[]> rows;
/** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
public enum _Fields implements TFieldIdEnum {
- /**
- * name of table
- */
TABLE_NAME((short)1, "tableName"),
- /**
- * row key
- */
- ROW((short)2, "row"),
- /**
- * list of mutation commands
- */
- MUTATIONS((short)3, "mutations");
+ ROWS((short)2, "rows");
private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
@@ -16557,70 +17038,57 @@ public class Hbase {
public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
new FieldValueMetaData(TType.STRING)));
- put(_Fields.ROW, new FieldMetaData("row", TFieldRequirementType.DEFAULT,
- new FieldValueMetaData(TType.STRING)));
- put(_Fields.MUTATIONS, new FieldMetaData("mutations", TFieldRequirementType.DEFAULT,
+ put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
new ListMetaData(TType.LIST,
- new StructMetaData(TType.STRUCT, Mutation.class))));
+ new FieldValueMetaData(TType.STRING))));
}});
static {
- FieldMetaData.addStructMetaDataMap(mutateRow_args.class, metaDataMap);
+ FieldMetaData.addStructMetaDataMap(getRows_args.class, metaDataMap);
}
- public mutateRow_args() {
+ public getRows_args() {
}
- public mutateRow_args(
+ public getRows_args(
byte[] tableName,
- byte[] row,
- List<Mutation> mutations)
+ List<byte[]> rows)
{
this();
this.tableName = tableName;
- this.row = row;
- this.mutations = mutations;
+ this.rows = rows;
}
/**
* Performs a deep copy on <i>other</i>.
*/
- public mutateRow_args(mutateRow_args other) {
+ public getRows_args(getRows_args other) {
if (other.isSetTableName()) {
this.tableName = other.tableName;
}
- if (other.isSetRow()) {
- this.row = other.row;
- }
- if (other.isSetMutations()) {
- List<Mutation> __this__mutations = new ArrayList<Mutation>();
- for (Mutation other_element : other.mutations) {
- __this__mutations.add(new Mutation(other_element));
+ if (other.isSetRows()) {
+ List<byte[]> __this__rows = new ArrayList<byte[]>();
+ for (byte[] other_element : other.rows) {
+ __this__rows.add(other_element);
}
- this.mutations = __this__mutations;
+ this.rows = __this__rows;
}
}
- public mutateRow_args deepCopy() {
- return new mutateRow_args(this);
+ public getRows_args deepCopy() {
+ return new getRows_args(this);
}
@Deprecated
- public mutateRow_args clone() {
- return new mutateRow_args(this);
+ public getRows_args clone() {
+ return new getRows_args(this);
}
- /**
- * name of table
- */
public byte[] getTableName() {
return this.tableName;
}
- /**
- * name of table
- */
- public mutateRow_args setTableName(byte[] tableName) {
+ public getRows_args setTableName(byte[] tableName) {
this.tableName = tableName;
return this;
}
@@ -16640,78 +17108,42 @@ public class Hbase {
}
}
- /**
- * row key
- */
- public byte[] getRow() {
- return this.row;
- }
-
- /**
- * row key
- */
- public mutateRow_args setRow(byte[] row) {
- this.row = row;
- return this;
- }
-
- public void unsetRow() {
- this.row = null;
- }
-
- /** Returns true if field row is set (has been asigned a value) and false otherwise */
- public boolean isSetRow() {
- return this.row != null;
- }
-
- public void setRowIsSet(boolean value) {
- if (!value) {
- this.row = null;
- }
- }
-
- public int getMutationsSize() {
- return (this.mutations == null) ? 0 : this.mutations.size();
+ public int getRowsSize() {
+ return (this.rows == null) ? 0 : this.rows.size();
}
- public java.util.Iterator<Mutation> getMutationsIterator() {
- return (this.mutations == null) ? null : this.mutations.iterator();
+ public java.util.Iterator<byte[]> getRowsIterator() {
+ return (this.rows == null) ? null : this.rows.iterator();
}
- public void addToMutations(Mutation elem) {
- if (this.mutations == null) {
- this.mutations = new ArrayList<Mutation>();
+ public void addToRows(byte[] elem) {
+ if (this.rows == null) {
+ this.rows = new ArrayList<byte[]>();
}
- this.mutations.add(elem);
+ this.rows.add(elem);
}
- /**
- * list of mutation commands
- */
- public List<Mutation> getMutations() {
- return this.mutations;
+ public List<byte[]> getRows() {
+ return this.rows;
}
- /**
- * list of mutation commands
- */
- public mutateRow_args setMutations(List<Mutation> mutations) {
- this.mutations = mutations;
+ public getRows_args setRows(List<byte[]> rows) {
+ this.rows = rows;
return this;
}
- public void unsetMutations() {
- this.mutations = null;
+ public void unsetRows() {
+ this.rows = null;
}
- /** Returns true if field mutations is set (has been asigned a value) and false otherwise */
- public boolean isSetMutations() {
- return this.mutations != null;
+ /** Returns true if field rows is set (has been asigned a value) and false otherwise */
+ public boolean isSetRows() {
+ return this.rows != null;
}
- public void setMutationsIsSet(boolean value) {
+ public void setRowsIsSet(boolean value) {
if (!value) {
- this.mutations = null;
+ this.rows = null;
}
}
@@ -16725,19 +17157,11 @@ public class Hbase {
}
break;
- case ROW:
- if (value == null) {
- unsetRow();
- } else {
- setRow((byte[])value);
- }
- break;
-
- case MUTATIONS:
+ case ROWS:
if (value == null) {
- unsetMutations();
+ unsetRows();
} else {
- setMutations((List<Mutation>)value);
+ setRows((List<byte[]>)value);
}
break;
@@ -16753,11 +17177,8 @@ public class Hbase {
case TABLE_NAME:
return getTableName();
- case ROW:
- return getRow();
-
- case MUTATIONS:
- return getMutations();
+ case ROWS:
+ return getRows();
}
throw new IllegalStateException();
@@ -16772,10 +17193,8 @@ public class Hbase {
switch (field) {
case TABLE_NAME:
return isSetTableName();
- case ROW:
- return isSetRow();
- case MUTATIONS:
- return isSetMutations();
+ case ROWS:
+ return isSetRows();
}
throw new IllegalStateException();
}
@@ -16788,12 +17207,12 @@ public class Hbase {
public boolean equals(Object that) {
if (that == null)
return false;
- if (that instanceof mutateRow_args)
- return this.equals((mutateRow_args)that);
+ if (that instanceof getRows_args)
+ return this.equals((getRows_args)that);
return false;
}
- public boolean equals(mutateRow_args that) {
+ public boolean equals(getRows_args that) {
if (that == null)
return false;
@@ -16806,21 +17225,12 @@ 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 (!java.util.Arrays.equals(this.row, that.row))
- return false;
- }
-
- boolean this_present_mutations = true && this.isSetMutations();
- boolean that_present_mutations = true && that.isSetMutations();
- if (this_present_mutations || that_present_mutations) {
- if (!(this_present_mutations && that_present_mutations))
+ 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.mutations.equals(that.mutations))
+ if (!this.rows.equals(that.rows))
return false;
}
@@ -16836,26 +17246,21 @@ public class Hbase {
if (present_tableName)
builder.append(tableName);
- boolean present_row = true && (isSetRow());
- builder.append(present_row);
- if (present_row)
- builder.append(row);
-
- boolean present_mutations = true && (isSetMutations());
- builder.append(present_mutations);
- if (present_mutations)
- builder.append(mutations);
+ boolean present_rows = true && (isSetRows());
+ builder.append(present_rows);
+ if (present_rows)
+ builder.append(rows);
return builder.toHashCode();
}
- public int compareTo(mutateRow_args other) {
+ public int compareTo(getRows_args other) {
if (!getClass().equals(other.getClass())) {
return getClass().getName().compareTo(other.getClass().getName());
}
int lastComparison = 0;
- mutateRow_args typedOther = (mutateRow_args)other;
+ getRows_args typedOther = (getRows_args)other;
lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
if (lastComparison != 0) {
@@ -16865,19 +17270,5619 @@ public class Hbase {
if (lastComparison != 0) {
return lastComparison;
}
- lastComparison = Boolean.valueOf(isSetRow()).compareTo(isSetRow());
- if (lastComparison != 0) {
- return lastComparison;
- }
- lastComparison = TBaseHelper.compareTo(row, typedOther.row);
+ lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
if (lastComparison != 0) {
return lastComparison;
}
- lastComparison = Boolean.valueOf(isSetMutations()).compareTo(isSetMutations());
+ lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
if (lastComparison != 0) {
return lastComparison;
}
- lastComparison = TBaseHelper.compareTo(mutations, typedOther.mutations);
+ return 0;
+ }
+
+ public void read(TProtocol iprot) throws TException {
+ TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == TType.STOP) {
+ break;
+ }
+ _Fields fieldId = _Fields.findByThriftId(field.id);
+ if (fieldId == null) {
+ TProtocolUtil.skip(iprot, field.type);
+ } else {
+ switch (fieldId) {
+ case TABLE_NAME:
+ if (field.type == TType.STRING) {
+ this.tableName = iprot.readBinary();
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case ROWS:
+ if (field.type == TType.LIST) {
+ {
+ TList _list66 = iprot.readListBegin();
+ this.rows = new ArrayList<byte[]>(_list66.size);
+ for (int _i67 = 0; _i67 < _list66.size; ++_i67)
+ {
+ byte[] _elem68;
+ _elem68 = iprot.readBinary();
+ this.rows.add(_elem68);
+ }
+ iprot.readListEnd();
+ }
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ }
+ iprot.readFieldEnd();
+ }
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ validate();
+ }
+
+ public void write(TProtocol oprot) throws TException {
+ validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (this.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(this.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (this.rows != null) {
+ oprot.writeFieldBegin(ROWS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
+ for (byte[] _iter69 : this.rows)
+ {
+ oprot.writeBinary(_iter69);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("getRows_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("rows:");
+ if (this.rows == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.rows);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws TException {
+ // check for required fields
+ }
+
+ }
+
+ public static class getRows_result implements TBase<getRows_result._Fields>, java.io.Serializable, Cloneable {
+ private static final TStruct STRUCT_DESC = new TStruct("getRows_result");
+
+ private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+ private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
+
+ public List<TRowResult> success;
+ public IOError io;
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byId.put((int)field._thriftId, field);
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ return byId.get(fieldId);
+ }
+
+ /**
+ * 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, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+ put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+ new ListMetaData(TType.LIST,
+ new StructMetaData(TType.STRUCT, TRowResult.class))));
+ put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
+ new FieldValueMetaData(TType.STRUCT)));
+ }});
+
+ static {
+ FieldMetaData.addStructMetaDataMap(getRows_result.class, metaDataMap);
+ }
+
+ public getRows_result() {
+ }
+
+ public getRows_result(
+ List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRows_result(getRows_result other) {
+ if (other.isSetSuccess()) {
+ List<TRowResult> __this__success = new ArrayList<TRowResult>();
+ 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 getRows_result deepCopy() {
+ return new getRows_result(this);
+ }
+
+ @Deprecated
+ public getRows_result clone() {
+ return new getRows_result(this);
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ public List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRows_result setSuccess(List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been asigned 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 getRows_result setIo(IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been asigned 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<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ public void setFieldValue(int fieldID, Object value) {
+ setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ public Object getFieldValue(int fieldId) {
+ return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new IllegalStateException();
+ }
+
+ public boolean isSet(int fieldID) {
+ return isSet(_Fields.findByThriftIdOrThrow(fieldID));
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof getRows_result)
+ return this.equals((getRows_result)that);
+ return false;
+ }
+
+ public boolean equals(getRows_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() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_success = true && (isSetSuccess());
+ builder.append(present_success);
+ if (present_success)
+ builder.append(success);
+
+ boolean present_io = true && (isSetIo());
+ builder.append(present_io);
+ if (present_io)
+ builder.append(io);
+
+ return builder.toHashCode();
+ }
+
+ public void read(TProtocol iprot) throws TException {
+ TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == TType.STOP) {
+ break;
+ }
+ _Fields fieldId = _Fields.findByThriftId(field.id);
+ if (fieldId == null) {
+ TProtocolUtil.skip(iprot, field.type);
+ } else {
+ switch (fieldId) {
+ case SUCCESS:
+ if (field.type == TType.LIST) {
+ {
+ TList _list70 = iprot.readListBegin();
+ this.success = new ArrayList<TRowResult>(_list70.size);
+ for (int _i71 = 0; _i71 < _list70.size; ++_i71)
+ {
+ TRowResult _elem72;
+ _elem72 = new TRowResult();
+ _elem72.read(iprot);
+ this.success.add(_elem72);
+ }
+ iprot.readListEnd();
+ }
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case IO:
+ if (field.type == TType.STRUCT) {
+ this.io = new IOError();
+ this.io.read(iprot);
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ }
+ iprot.readFieldEnd();
+ }
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ validate();
+ }
+
+ public void write(TProtocol oprot) throws TException {
+ oprot.writeStructBegin(STRUCT_DESC);
+
+ if (this.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
+ for (TRowResult _iter73 : this.success)
+ {
+ _iter73.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("getRows_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 TException {
+ // check for required fields
+ }
+
+ }
+
+ public static class getRowsTs_args implements TBase<getRowsTs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsTs_args> {
+ private static final TStruct STRUCT_DESC = new TStruct("getRowsTs_args");
+
+ private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
+ private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
+ private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
+
+ public byte[] tableName;
+ public List<byte[]> rows;
+ public long timestamp;
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements TFieldIdEnum {
+ TABLE_NAME((short)1, "tableName"),
+ ROWS((short)2, "rows"),
+ TIMESTAMP((short)3, "timestamp");
+
+ private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byId.put((int)field._thriftId, field);
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ return byId.get(fieldId);
+ }
+
+ /**
+ * 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 BitSet __isset_bit_vector = new BitSet(1);
+
+ public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+ put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
+ new FieldValueMetaData(TType.STRING)));
+ put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
+ new ListMetaData(TType.LIST,
+ new FieldValueMetaData(TType.STRING))));
+ put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
+ new FieldValueMetaData(TType.I64)));
+ }});
+
+ static {
+ FieldMetaData.addStructMetaDataMap(getRowsTs_args.class, metaDataMap);
+ }
+
+ public getRowsTs_args() {
+ }
+
+ public getRowsTs_args(
+ byte[] tableName,
+ List<byte[]> rows,
+ long timestamp)
+ {
+ this();
+ this.tableName = tableName;
+ this.rows = rows;
+ this.timestamp = timestamp;
+ setTimestampIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowsTs_args(getRowsTs_args other) {
+ __isset_bit_vector.clear();
+ __isset_bit_vector.or(other.__isset_bit_vector);
+ if (other.isSetTableName()) {
+ this.tableName = other.tableName;
+ }
+ if (other.isSetRows()) {
+ List<byte[]> __this__rows = new ArrayList<byte[]>();
+ for (byte[] other_element : other.rows) {
+ __this__rows.add(other_element);
+ }
+ this.rows = __this__rows;
+ }
+ this.timestamp = other.timestamp;
+ }
+
+ public getRowsTs_args deepCopy() {
+ return new getRowsTs_args(this);
+ }
+
+ @Deprecated
+ public getRowsTs_args clone() {
+ return new getRowsTs_args(this);
+ }
+
+ public byte[] getTableName() {
+ return this.tableName;
+ }
+
+ public getRowsTs_args setTableName(byte[] tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getRowsSize() {
+ return (this.rows == null) ? 0 : this.rows.size();
+ }
+
+ public java.util.Iterator<byte[]> getRowsIterator() {
+ return (this.rows == null) ? null : this.rows.iterator();
+ }
+
+ public void addToRows(byte[] elem) {
+ if (this.rows == null) {
+ this.rows = new ArrayList<byte[]>();
+ }
+ this.rows.add(elem);
+ }
+
+ public List<byte[]> getRows() {
+ return this.rows;
+ }
+
+ public getRowsTs_args setRows(List<byte[]> rows) {
+ this.rows = rows;
+ return this;
+ }
+
+ public void unsetRows() {
+ this.rows = null;
+ }
+
+ /** Returns true if field rows is set (has been asigned a value) and false otherwise */
+ public boolean isSetRows() {
+ return this.rows != null;
+ }
+
+ public void setRowsIsSet(boolean value) {
+ if (!value) {
+ this.rows = null;
+ }
+ }
+
+ public long getTimestamp() {
+ return this.timestamp;
+ }
+
+ public getRowsTs_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 asigned 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:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((byte[])value);
+ }
+ break;
+
+ case ROWS:
+ if (value == null) {
+ unsetRows();
+ } else {
+ setRows((List<byte[]>)value);
+ }
+ break;
+
+ case TIMESTAMP:
+ if (value == null) {
+ unsetTimestamp();
+ } else {
+ setTimestamp((Long)value);
+ }
+ break;
+
+ }
+ }
+
+ public void setFieldValue(int fieldID, Object value) {
+ setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROWS:
+ return getRows();
+
+ case TIMESTAMP:
+ return new Long(getTimestamp());
+
+ }
+ throw new IllegalStateException();
+ }
+
+ public Object getFieldValue(int fieldId) {
+ return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROWS:
+ return isSetRows();
+ case TIMESTAMP:
+ return isSetTimestamp();
+ }
+ throw new IllegalStateException();
+ }
+
+ public boolean isSet(int fieldID) {
+ return isSet(_Fields.findByThriftIdOrThrow(fieldID));
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof getRowsTs_args)
+ return this.equals((getRowsTs_args)that);
+ return false;
+ }
+
+ public boolean equals(getRowsTs_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 (!java.util.Arrays.equals(this.tableName, that.tableName))
+ return false;
+ }
+
+ 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.rows.equals(that.rows))
+ 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;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_tableName = true && (isSetTableName());
+ builder.append(present_tableName);
+ if (present_tableName)
+ builder.append(tableName);
+
+ boolean present_rows = true && (isSetRows());
+ builder.append(present_rows);
+ if (present_rows)
+ builder.append(rows);
+
+ boolean present_timestamp = true;
+ builder.append(present_timestamp);
+ if (present_timestamp)
+ builder.append(timestamp);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(getRowsTs_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ getRowsTs_args typedOther = (getRowsTs_args)other;
+
+ lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ return 0;
+ }
+
+ public void read(TProtocol iprot) throws TException {
+ TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == TType.STOP) {
+ break;
+ }
+ _Fields fieldId = _Fields.findByThriftId(field.id);
+ if (fieldId == null) {
+ TProtocolUtil.skip(iprot, field.type);
+ } else {
+ switch (fieldId) {
+ case TABLE_NAME:
+ if (field.type == TType.STRING) {
+ this.tableName = iprot.readBinary();
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case ROWS:
+ if (field.type == TType.LIST) {
+ {
+ TList _list74 = iprot.readListBegin();
+ this.rows = new ArrayList<byte[]>(_list74.size);
+ for (int _i75 = 0; _i75 < _list74.size; ++_i75)
+ {
+ byte[] _elem76;
+ _elem76 = iprot.readBinary();
+ this.rows.add(_elem76);
+ }
+ iprot.readListEnd();
+ }
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case TIMESTAMP:
+ if (field.type == TType.I64) {
+ this.timestamp = iprot.readI64();
+ setTimestampIsSet(true);
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ }
+ iprot.readFieldEnd();
+ }
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ validate();
+ }
+
+ public void write(TProtocol oprot) throws TException {
+ validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (this.tableName != null) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeBinary(this.tableName);
+ oprot.writeFieldEnd();
+ }
+ if (this.rows != null) {
+ oprot.writeFieldBegin(ROWS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new TList(TType.STRING, this.rows.size()));
+ for (byte[] _iter77 : this.rows)
+ {
+ oprot.writeBinary(_iter77);
+ }
+ 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("getRowsTs_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("rows:");
+ if (this.rows == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.rows);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("timestamp:");
+ sb.append(this.timestamp);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws TException {
+ // check for required fields
+ }
+
+ }
+
+ public static class getRowsTs_result implements TBase<getRowsTs_result._Fields>, java.io.Serializable, Cloneable {
+ private static final TStruct STRUCT_DESC = new TStruct("getRowsTs_result");
+
+ private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+ private static final TField IO_FIELD_DESC = new TField("io", TType.STRUCT, (short)1);
+
+ public List<TRowResult> success;
+ public IOError io;
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements TFieldIdEnum {
+ SUCCESS((short)0, "success"),
+ IO((short)1, "io");
+
+ private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byId.put((int)field._thriftId, field);
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ return byId.get(fieldId);
+ }
+
+ /**
+ * 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, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+ put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+ new ListMetaData(TType.LIST,
+ new StructMetaData(TType.STRUCT, TRowResult.class))));
+ put(_Fields.IO, new FieldMetaData("io", TFieldRequirementType.DEFAULT,
+ new FieldValueMetaData(TType.STRUCT)));
+ }});
+
+ static {
+ FieldMetaData.addStructMetaDataMap(getRowsTs_result.class, metaDataMap);
+ }
+
+ public getRowsTs_result() {
+ }
+
+ public getRowsTs_result(
+ List<TRowResult> success,
+ IOError io)
+ {
+ this();
+ this.success = success;
+ this.io = io;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowsTs_result(getRowsTs_result other) {
+ if (other.isSetSuccess()) {
+ List<TRowResult> __this__success = new ArrayList<TRowResult>();
+ 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 getRowsTs_result deepCopy() {
+ return new getRowsTs_result(this);
+ }
+
+ @Deprecated
+ public getRowsTs_result clone() {
+ return new getRowsTs_result(this);
+ }
+
+ public int getSuccessSize() {
+ return (this.success == null) ? 0 : this.success.size();
+ }
+
+ public java.util.Iterator<TRowResult> getSuccessIterator() {
+ return (this.success == null) ? null : this.success.iterator();
+ }
+
+ public void addToSuccess(TRowResult elem) {
+ if (this.success == null) {
+ this.success = new ArrayList<TRowResult>();
+ }
+ this.success.add(elem);
+ }
+
+ public List<TRowResult> getSuccess() {
+ return this.success;
+ }
+
+ public getRowsTs_result setSuccess(List<TRowResult> success) {
+ this.success = success;
+ return this;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been asigned 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 getRowsTs_result setIo(IOError io) {
+ this.io = io;
+ return this;
+ }
+
+ public void unsetIo() {
+ this.io = null;
+ }
+
+ /** Returns true if field io is set (has been asigned 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<TRowResult>)value);
+ }
+ break;
+
+ case IO:
+ if (value == null) {
+ unsetIo();
+ } else {
+ setIo((IOError)value);
+ }
+ break;
+
+ }
+ }
+
+ public void setFieldValue(int fieldID, Object value) {
+ setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ case IO:
+ return getIo();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ public Object getFieldValue(int fieldId) {
+ return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ case IO:
+ return isSetIo();
+ }
+ throw new IllegalStateException();
+ }
+
+ public boolean isSet(int fieldID) {
+ return isSet(_Fields.findByThriftIdOrThrow(fieldID));
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof getRowsTs_result)
+ return this.equals((getRowsTs_result)that);
+ return false;
+ }
+
+ public boolean equals(getRowsTs_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() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_success = true && (isSetSuccess());
+ builder.append(present_success);
+ if (present_success)
+ builder.append(success);
+
+ boolean present_io = true && (isSetIo());
+ builder.append(present_io);
+ if (present_io)
+ builder.append(io);
+
+ return builder.toHashCode();
+ }
+
+ public void read(TProtocol iprot) throws TException {
+ TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == TType.STOP) {
+ break;
+ }
+ _Fields fieldId = _Fields.findByThriftId(field.id);
+ if (fieldId == null) {
+ TProtocolUtil.skip(iprot, field.type);
+ } else {
+ switch (fieldId) {
+ case SUCCESS:
+ if (field.type == TType.LIST) {
+ {
+ TList _list78 = iprot.readListBegin();
+ this.success = new ArrayList<TRowResult>(_list78.size);
+ for (int _i79 = 0; _i79 < _list78.size; ++_i79)
+ {
+ TRowResult _elem80;
+ _elem80 = new TRowResult();
+ _elem80.read(iprot);
+ this.success.add(_elem80);
+ }
+ iprot.readListEnd();
+ }
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case IO:
+ if (field.type == TType.STRUCT) {
+ this.io = new IOError();
+ this.io.read(iprot);
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ }
+ iprot.readFieldEnd();
+ }
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ validate();
+ }
+
+ public void write(TProtocol oprot) throws TException {
+ oprot.writeStructBegin(STRUCT_DESC);
+
+ if (this.isSetSuccess()) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ {
+ oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
+ for (TRowResult _iter81 : this.success)
+ {
+ _iter81.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("getRowsTs_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 TException {
+ // check for required fields
+ }
+
+ }
+
+ public static class getRowsWithColumns_args implements TBase<getRowsWithColumns_args._Fields>, java.io.Serializable, Cloneable, Comparable<getRowsWithColumns_args> {
+ private static final TStruct STRUCT_DESC = new TStruct("getRowsWithColumns_args");
+
+ private static final TField TABLE_NAME_FIELD_DESC = new TField("tableName", TType.STRING, (short)1);
+ private static final TField ROWS_FIELD_DESC = new TField("rows", TType.LIST, (short)2);
+ private static final TField FAMILIES_FIELD_DESC = new TField("families", TType.LIST, (short)3);
+
+ public byte[] tableName;
+ public List<byte[]> rows;
+ public List<byte[]> families;
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements TFieldIdEnum {
+ TABLE_NAME((short)1, "tableName"),
+ ROWS((short)2, "rows"),
+ FAMILIES((short)3, "families");
+
+ private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byId.put((int)field._thriftId, field);
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ return byId.get(fieldId);
+ }
+
+ /**
+ * 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, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+ put(_Fields.TABLE_NAME, new FieldMetaData("tableName", TFieldRequirementType.DEFAULT,
+ new FieldValueMetaData(TType.STRING)));
+ put(_Fields.ROWS, new FieldMetaData("rows", TFieldRequirementType.DEFAULT,
+ new ListMetaData(TType.LIST,
+ new FieldValueMetaData(TType.STRING))));
+ put(_Fields.FAMILIES, new FieldMetaData("families", TFieldRequirementType.DEFAULT,
+ new ListMetaData(TType.LIST,
+ new FieldValueMetaData(TType.STRING))));
+ }});
+
+ static {
+ FieldMetaData.addStructMetaDataMap(getRowsWithColumns_args.class, metaDataMap);
+ }
+
+ public getRowsWithColumns_args() {
+ }
+
+ public getRowsWithColumns_args(
+ byte[] tableName,
+ List<byte[]> rows,
+ List<byte[]> families)
+ {
+ this();
+ this.tableName = tableName;
+ this.rows = rows;
+ this.families = families;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public getRowsWithColumns_args(getRowsWithColumns_args other) {
+ if (other.isSetTableName()) {
+ this.tableName = other.tableName;
+ }
+ if (other.isSetRows()) {
+ List<byte[]> __this__rows = new ArrayList<byte[]>();
+ for (byte[] other_element : other.rows) {
+ __this__rows.add(other_element);
+ }
+ this.rows = __this__rows;
+ }
+ if (other.isSetFamilies()) {
+ List<byte[]> __this__families = new ArrayList<byte[]>();
+ for (byte[] other_element : other.families) {
+ __this__families.add(other_element);
+ }
+ this.families = __this__families;
+ }
+ }
+
+ public getRowsWithColumns_args deepCopy() {
+ return new getRowsWithColumns_args(this);
+ }
+
+ @Deprecated
+ public getRowsWithColumns_args clone() {
+ return new getRowsWithColumns_args(this);
+ }
+
+ public byte[] getTableName() {
+ return this.tableName;
+ }
+
+ public getRowsWithColumns_args setTableName(byte[] tableName) {
+ this.tableName = tableName;
+ return this;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been asigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public int getRowsSize() {
+ return (this.rows == null) ? 0 : this.rows.size();
+ }
+
+ public java.util.Iterator<byte[]> getRowsIterator() {
+ return (this.rows == null) ? null : this.rows.iterator();
+ }
+
+ public void addToRows(byte[] elem) {
+ if (this.rows == null) {
+ this.rows = new ArrayList<byte[]>();
+ }
+ this.rows.add(elem);
+ }
+
+ public List<byte[]> getRows() {
+ return this.rows;
+ }
+
+ public getRowsWithColumns_args setRows(List<byte[]> rows) {
+ this.rows = rows;
+ return this;
+ }
+
+ public void unsetRows() {
+ this.rows = null;
+ }
+
+ /** Returns true if field rows is set (has been asigned a value) and false otherwise */
+ public boolean isSetRows() {
+ return this.rows != null;
+ }
+
+ public void setRowsIsSet(boolean value) {
+ if (!value) {
+ this.rows = null;
+ }
+ }
+
+ public int getFamiliesSize() {
+ return (this.families == null) ? 0 : this.families.size();
+ }
+
+ public java.util.Iterator<byte[]> getFamiliesIterator() {
+ return (this.families == null) ? null : this.families.iterator();
+ }
+
+ public void addToFamilies(byte[] elem) {
+ if (this.families == null) {
+ this.families = new ArrayList<byte[]>();
+ }
+ this.families.add(elem);
+ }
+
+ public List<byte[]> getFamilies() {
+ return this.families;
+ }
+
+ public getRowsWithColumns_args setFamilies(List<byte[]> families) {
+ this.families = families;
+ return this;
+ }
+
+ public void unsetFamilies() {
+ this.families = null;
+ }
+
+ /** Returns true if field families is set (has been asigned a value) and false otherwise */
+ public boolean isSetFamilies() {
+ return this.families != null;
+ }
+
+ public void setFamiliesIsSet(boolean value) {
+ if (!value) {
+ this.families = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((byte[])value);
+ }
+ break;
+
+ case ROWS:
+ if (value == null) {
+ unsetRows();
+ } else {
+ setRows((List<byte[]>)value);
+ }
+ break;
+
+ case FAMILIES:
+ if (value == null) {
+ unsetFamilies();
+ } else {
+ setFamilies((List<byte[]>)value);
+ }
+ break;
+
+ }
+ }
+
+ public void setFieldValue(int fieldID, Object value) {
+ setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return getTableName();
+
+ case ROWS:
+ return getRows();
+
+ case FAMILIES:
+ return getFamilies();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ public Object getFieldValue(int fieldId) {
+ return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ switch (field) {
+ case TABLE_NAME:
+ return isSetTableName();
+ case ROWS:
+ return isSetRows();
+ case FAMILIES:
+ return isSetFamilies();
+ }
+ throw new IllegalStateException();
+ }
+
+ public boolean isSet(int fieldID) {
+ return isSet(_Fields.findByThriftIdOrThrow(fieldID));
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof getRowsWithColumns_args)
+ return this.equals((getRowsWithColumns_args)that);
+ return false;
+ }
+
+ public boolean equals(getRowsWithColumns_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 (!java.util.Arrays.equals(this.tableName, that.tableName))
+ return false;
+ }
+
+ 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.rows.equals(that.rows))
+ return false;
+ }
+
+ boolean this_present_families = true && this.isSetFamilies();
+ boolean that_present_families = true && that.isSetFamilies();
+ if (this_present_families || that_present_families) {
+ if (!(this_present_families && that_present_families))
+ return false;
+ if (!this.families.equals(that.families))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_tableName = true && (isSetTableName());
+ builder.append(present_tableName);
+ if (present_tableName)
+ builder.append(tableName);
+
+ boolean present_rows = true && (isSetRows());
+ builder.append(present_rows);
+ if (present_rows)
+ builder.append(rows);
+
+ boolean present_families = true && (isSetFamilies());
+ builder.append(present_families);
+ if (present_families)
+ builder.append(families);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(getRowsWithColumns_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ getRowsWithColumns_args typedOther = (getRowsWithColumns_args)other;
+
+ lastComparison = Boolean.valueOf(isSetTableName()).compareTo(isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = TBaseHelper.compareTo(tableName, typedOther.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = Boolean.valueOf(isSetRows()).compareTo(isSetRows());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = TBaseHelper.compareTo(rows, typedOther.rows);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = Boolean.valueOf(isSetFamilies()).compareTo(isSetFamilies());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ lastComparison = TBaseHelper.compareTo(families, typedOther.families);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ return 0;
+ }
+
+ public void read(TProtocol iprot) throws TException {
+ TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == TType.STOP) {
+ break;
+ }
+ _Fields fieldId = _Fields.findByThriftId(field.id);
+ if (fieldId == null) {
+ TProtocolUtil.skip(iprot, field.type);
+ } else {
+ switch (fieldId) {
+ case TABLE_NAME:
+ if (field.type == TType.STRING) {
+ this.tableName = iprot.readBinary();
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case ROWS:
+ if (field.type == TType.LIST) {
+ {
+ TList _list82 = iprot.readListBegin();
+ this.rows = new ArrayList<byte[]>(_list82.size);
+ for (int _i83 = 0; _i83 < _list82.size; ++_i83)
+ {
+ byte[] _elem84;
+ _elem84 = iprot.readBinary();
+ this.rows.add(_elem84);
+ }
+ iprot.readListEnd();
+ }
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case FAMILIES:
+ if (field.type == TType.LIST) {
+ {
+ TList _list85 = iprot.readListBegin();
+ this.families = new ArrayList<byte[]>(_list85.size);
+ for (int _i86 = 0; _i86 < _list85.size; ++_i86)
+ {
+ byte[] _elem87;
+ _elem87 = iprot.readBinary();
+ this.families.add(_elem87);
+ }
+ iprot.readListEnd();
+ }
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ }
+ iprot.readFieldEnd();
+ }
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ validate();
+ }
+
[... 6661 lines stripped ...]