You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by jo...@apache.org on 2010/12/21 23:17:12 UTC
svn commit: r1051679 [2/6] - in /cassandra/trunk: ./ conf/ interface/
interface/thrift/gen-java/org/apache/cassandra/thrift/
src/java/org/apache/cassandra/avro/ src/java/org/apache/cassandra/concurrent/
src/java/org/apache/cassandra/config/ src/java/or...
Modified: cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java
URL: http://svn.apache.org/viewvc/cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java?rev=1051679&r1=1051678&r2=1051679&view=diff
==============================================================================
--- cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java (original)
+++ cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java Tue Dec 21 22:17:09 2010
@@ -174,6 +174,62 @@ public class Cassandra {
public void truncate(String cfname) throws InvalidRequestException, UnavailableException, TException;
/**
+ * Increment or decrement a counter.
+ *
+ * @param key
+ * @param column_parent
+ * @param column
+ * @param consistency_level
+ */
+ public void add(ByteBuffer key, ColumnParent column_parent, CounterColumn column, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException;
+
+ /**
+ * Batch increment or decrement a counter.
+ *
+ * @param update_map
+ * @param consistency_level
+ */
+ public void batch_add(Map<ByteBuffer,Map<String,List<CounterMutation>>> update_map, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException;
+
+ /**
+ * Return the counter at the specified column path.
+ *
+ * @param key
+ * @param path
+ * @param consistency_level
+ */
+ public Counter get_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level) throws InvalidRequestException, NotFoundException, UnavailableException, TimedOutException, TException;
+
+ /**
+ * Get a list of counters from the specified columns.
+ *
+ * @param key
+ * @param column_parent
+ * @param predicate
+ * @param consistency_level
+ */
+ public List<Counter> get_counter_slice(ByteBuffer key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException;
+
+ /**
+ * Get counter slices from multiple keys.
+ *
+ * @param keys
+ * @param column_parent
+ * @param predicate
+ * @param consistency_level
+ */
+ public Map<ByteBuffer,List<Counter>> multiget_counter_slice(List<ByteBuffer> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException;
+
+ /**
+ * Remove a counter at the specified location.
+ *
+ * @param key
+ * @param path
+ * @param consistency_level
+ */
+ public void remove_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException;
+
+ /**
* for each schema version present in the cluster, returns a list of nodes at that version.
* hosts that do not respond will be under the key DatabaseDescriptor.INITIAL_VERSION.
* the cluster is all on the same version if the size of the map is 1.
@@ -312,6 +368,18 @@ public class Cassandra {
public void truncate(String cfname, AsyncMethodCallback<AsyncClient.truncate_call> resultHandler) throws TException;
+ public void add(ByteBuffer key, ColumnParent column_parent, CounterColumn column, ConsistencyLevel consistency_level, AsyncMethodCallback<AsyncClient.add_call> resultHandler) throws TException;
+
+ public void batch_add(Map<ByteBuffer,Map<String,List<CounterMutation>>> update_map, ConsistencyLevel consistency_level, AsyncMethodCallback<AsyncClient.batch_add_call> resultHandler) throws TException;
+
+ public void get_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level, AsyncMethodCallback<AsyncClient.get_counter_call> resultHandler) throws TException;
+
+ public void get_counter_slice(ByteBuffer key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level, AsyncMethodCallback<AsyncClient.get_counter_slice_call> resultHandler) throws TException;
+
+ public void multiget_counter_slice(List<ByteBuffer> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level, AsyncMethodCallback<AsyncClient.multiget_counter_slice_call> resultHandler) throws TException;
+
+ public void remove_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level, AsyncMethodCallback<AsyncClient.remove_counter_call> resultHandler) throws TException;
+
public void describe_schema_versions(AsyncMethodCallback<AsyncClient.describe_schema_versions_call> resultHandler) throws TException;
public void describe_keyspaces(AsyncMethodCallback<AsyncClient.describe_keyspaces_call> resultHandler) throws TException;
@@ -966,6 +1034,284 @@ public class Cassandra {
return;
}
+ public void add(ByteBuffer key, ColumnParent column_parent, CounterColumn column, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ send_add(key, column_parent, column, consistency_level);
+ recv_add();
+ }
+
+ public void send_add(ByteBuffer key, ColumnParent column_parent, CounterColumn column, ConsistencyLevel consistency_level) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("add", TMessageType.CALL, ++seqid_));
+ add_args args = new add_args();
+ args.setKey(key);
+ args.setColumn_parent(column_parent);
+ args.setColumn(column);
+ args.setConsistency_level(consistency_level);
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public void recv_add() throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ if (msg.seqid != seqid_) {
+ throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "add failed: out of sequence response");
+ }
+ add_result result = new add_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.ire != null) {
+ throw result.ire;
+ }
+ if (result.ue != null) {
+ throw result.ue;
+ }
+ if (result.te != null) {
+ throw result.te;
+ }
+ return;
+ }
+
+ public void batch_add(Map<ByteBuffer,Map<String,List<CounterMutation>>> update_map, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ send_batch_add(update_map, consistency_level);
+ recv_batch_add();
+ }
+
+ public void send_batch_add(Map<ByteBuffer,Map<String,List<CounterMutation>>> update_map, ConsistencyLevel consistency_level) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("batch_add", TMessageType.CALL, ++seqid_));
+ batch_add_args args = new batch_add_args();
+ args.setUpdate_map(update_map);
+ args.setConsistency_level(consistency_level);
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public void recv_batch_add() throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ if (msg.seqid != seqid_) {
+ throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "batch_add failed: out of sequence response");
+ }
+ batch_add_result result = new batch_add_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.ire != null) {
+ throw result.ire;
+ }
+ if (result.ue != null) {
+ throw result.ue;
+ }
+ if (result.te != null) {
+ throw result.te;
+ }
+ return;
+ }
+
+ public Counter get_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level) throws InvalidRequestException, NotFoundException, UnavailableException, TimedOutException, TException
+ {
+ send_get_counter(key, path, consistency_level);
+ return recv_get_counter();
+ }
+
+ public void send_get_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("get_counter", TMessageType.CALL, ++seqid_));
+ get_counter_args args = new get_counter_args();
+ args.setKey(key);
+ args.setPath(path);
+ args.setConsistency_level(consistency_level);
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public Counter recv_get_counter() throws InvalidRequestException, NotFoundException, UnavailableException, TimedOutException, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ if (msg.seqid != seqid_) {
+ throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "get_counter failed: out of sequence response");
+ }
+ get_counter_result result = new get_counter_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.ire != null) {
+ throw result.ire;
+ }
+ if (result.nfe != null) {
+ throw result.nfe;
+ }
+ if (result.ue != null) {
+ throw result.ue;
+ }
+ if (result.te != null) {
+ throw result.te;
+ }
+ throw new TApplicationException(TApplicationException.MISSING_RESULT, "get_counter failed: unknown result");
+ }
+
+ public List<Counter> get_counter_slice(ByteBuffer key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ send_get_counter_slice(key, column_parent, predicate, consistency_level);
+ return recv_get_counter_slice();
+ }
+
+ public void send_get_counter_slice(ByteBuffer key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("get_counter_slice", TMessageType.CALL, ++seqid_));
+ get_counter_slice_args args = new get_counter_slice_args();
+ args.setKey(key);
+ args.setColumn_parent(column_parent);
+ args.setPredicate(predicate);
+ args.setConsistency_level(consistency_level);
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public List<Counter> recv_get_counter_slice() throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ if (msg.seqid != seqid_) {
+ throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "get_counter_slice failed: out of sequence response");
+ }
+ get_counter_slice_result result = new get_counter_slice_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.ire != null) {
+ throw result.ire;
+ }
+ if (result.ue != null) {
+ throw result.ue;
+ }
+ if (result.te != null) {
+ throw result.te;
+ }
+ throw new TApplicationException(TApplicationException.MISSING_RESULT, "get_counter_slice failed: unknown result");
+ }
+
+ public Map<ByteBuffer,List<Counter>> multiget_counter_slice(List<ByteBuffer> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ send_multiget_counter_slice(keys, column_parent, predicate, consistency_level);
+ return recv_multiget_counter_slice();
+ }
+
+ public void send_multiget_counter_slice(List<ByteBuffer> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("multiget_counter_slice", TMessageType.CALL, ++seqid_));
+ multiget_counter_slice_args args = new multiget_counter_slice_args();
+ args.setKeys(keys);
+ args.setColumn_parent(column_parent);
+ args.setPredicate(predicate);
+ args.setConsistency_level(consistency_level);
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public Map<ByteBuffer,List<Counter>> recv_multiget_counter_slice() throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ if (msg.seqid != seqid_) {
+ throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "multiget_counter_slice failed: out of sequence response");
+ }
+ multiget_counter_slice_result result = new multiget_counter_slice_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ if (result.ire != null) {
+ throw result.ire;
+ }
+ if (result.ue != null) {
+ throw result.ue;
+ }
+ if (result.te != null) {
+ throw result.te;
+ }
+ throw new TApplicationException(TApplicationException.MISSING_RESULT, "multiget_counter_slice failed: unknown result");
+ }
+
+ public void remove_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ send_remove_counter(key, path, consistency_level);
+ recv_remove_counter();
+ }
+
+ public void send_remove_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level) throws TException
+ {
+ oprot_.writeMessageBegin(new TMessage("remove_counter", TMessageType.CALL, ++seqid_));
+ remove_counter_args args = new remove_counter_args();
+ args.setKey(key);
+ args.setPath(path);
+ args.setConsistency_level(consistency_level);
+ args.write(oprot_);
+ oprot_.writeMessageEnd();
+ oprot_.getTransport().flush();
+ }
+
+ public void recv_remove_counter() throws InvalidRequestException, UnavailableException, TimedOutException, TException
+ {
+ TMessage msg = iprot_.readMessageBegin();
+ if (msg.type == TMessageType.EXCEPTION) {
+ TApplicationException x = TApplicationException.read(iprot_);
+ iprot_.readMessageEnd();
+ throw x;
+ }
+ if (msg.seqid != seqid_) {
+ throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "remove_counter failed: out of sequence response");
+ }
+ remove_counter_result result = new remove_counter_result();
+ result.read(iprot_);
+ iprot_.readMessageEnd();
+ if (result.ire != null) {
+ throw result.ire;
+ }
+ if (result.ue != null) {
+ throw result.ue;
+ }
+ if (result.te != null) {
+ throw result.te;
+ }
+ return;
+ }
+
public Map<String,List<String>> describe_schema_versions() throws InvalidRequestException, TException
{
send_describe_schema_versions();
@@ -2038,16 +2384,244 @@ public class Cassandra {
}
}
- public void describe_schema_versions(AsyncMethodCallback<describe_schema_versions_call> resultHandler) throws TException {
+ public void add(ByteBuffer key, ColumnParent column_parent, CounterColumn column, ConsistencyLevel consistency_level, AsyncMethodCallback<add_call> resultHandler) throws TException {
checkReady();
- describe_schema_versions_call method_call = new describe_schema_versions_call(resultHandler, this, protocolFactory, transport);
+ add_call method_call = new add_call(key, column_parent, column, consistency_level, resultHandler, this, protocolFactory, transport);
manager.call(method_call);
}
- public static class describe_schema_versions_call extends TAsyncMethodCall {
- public describe_schema_versions_call(AsyncMethodCallback<describe_schema_versions_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+ public static class add_call extends TAsyncMethodCall {
+ private ByteBuffer key;
+ private ColumnParent column_parent;
+ private CounterColumn column;
+ private ConsistencyLevel consistency_level;
+ public add_call(ByteBuffer key, ColumnParent column_parent, CounterColumn column, ConsistencyLevel consistency_level, AsyncMethodCallback<add_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
super(client, protocolFactory, transport, resultHandler, false);
- }
+ this.key = key;
+ this.column_parent = column_parent;
+ this.column = column;
+ this.consistency_level = consistency_level;
+ }
+
+ public void write_args(TProtocol prot) throws TException {
+ prot.writeMessageBegin(new TMessage("add", TMessageType.CALL, 0));
+ add_args args = new add_args();
+ args.setKey(key);
+ args.setColumn_parent(column_parent);
+ args.setColumn(column);
+ args.setConsistency_level(consistency_level);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public void getResult() throws InvalidRequestException, UnavailableException, TimedOutException, TException {
+ if (getState() != State.RESPONSE_READ) {
+ throw new IllegalStateException("Method call not finished!");
+ }
+ TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
+ TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ (new Client(prot)).recv_add();
+ }
+ }
+
+ public void batch_add(Map<ByteBuffer,Map<String,List<CounterMutation>>> update_map, ConsistencyLevel consistency_level, AsyncMethodCallback<batch_add_call> resultHandler) throws TException {
+ checkReady();
+ batch_add_call method_call = new batch_add_call(update_map, consistency_level, resultHandler, this, protocolFactory, transport);
+ manager.call(method_call);
+ }
+
+ public static class batch_add_call extends TAsyncMethodCall {
+ private Map<ByteBuffer,Map<String,List<CounterMutation>>> update_map;
+ private ConsistencyLevel consistency_level;
+ public batch_add_call(Map<ByteBuffer,Map<String,List<CounterMutation>>> update_map, ConsistencyLevel consistency_level, AsyncMethodCallback<batch_add_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.update_map = update_map;
+ this.consistency_level = consistency_level;
+ }
+
+ public void write_args(TProtocol prot) throws TException {
+ prot.writeMessageBegin(new TMessage("batch_add", TMessageType.CALL, 0));
+ batch_add_args args = new batch_add_args();
+ args.setUpdate_map(update_map);
+ args.setConsistency_level(consistency_level);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public void getResult() throws InvalidRequestException, UnavailableException, TimedOutException, TException {
+ if (getState() != State.RESPONSE_READ) {
+ throw new IllegalStateException("Method call not finished!");
+ }
+ TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
+ TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ (new Client(prot)).recv_batch_add();
+ }
+ }
+
+ public void get_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level, AsyncMethodCallback<get_counter_call> resultHandler) throws TException {
+ checkReady();
+ get_counter_call method_call = new get_counter_call(key, path, consistency_level, resultHandler, this, protocolFactory, transport);
+ manager.call(method_call);
+ }
+
+ public static class get_counter_call extends TAsyncMethodCall {
+ private ByteBuffer key;
+ private ColumnPath path;
+ private ConsistencyLevel consistency_level;
+ public get_counter_call(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level, AsyncMethodCallback<get_counter_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.key = key;
+ this.path = path;
+ this.consistency_level = consistency_level;
+ }
+
+ public void write_args(TProtocol prot) throws TException {
+ prot.writeMessageBegin(new TMessage("get_counter", TMessageType.CALL, 0));
+ get_counter_args args = new get_counter_args();
+ args.setKey(key);
+ args.setPath(path);
+ args.setConsistency_level(consistency_level);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Counter getResult() throws InvalidRequestException, NotFoundException, UnavailableException, TimedOutException, TException {
+ if (getState() != State.RESPONSE_READ) {
+ throw new IllegalStateException("Method call not finished!");
+ }
+ TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
+ TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_get_counter();
+ }
+ }
+
+ public void get_counter_slice(ByteBuffer key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level, AsyncMethodCallback<get_counter_slice_call> resultHandler) throws TException {
+ checkReady();
+ get_counter_slice_call method_call = new get_counter_slice_call(key, column_parent, predicate, consistency_level, resultHandler, this, protocolFactory, transport);
+ manager.call(method_call);
+ }
+
+ public static class get_counter_slice_call extends TAsyncMethodCall {
+ private ByteBuffer key;
+ private ColumnParent column_parent;
+ private SlicePredicate predicate;
+ private ConsistencyLevel consistency_level;
+ public get_counter_slice_call(ByteBuffer key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level, AsyncMethodCallback<get_counter_slice_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.key = key;
+ this.column_parent = column_parent;
+ this.predicate = predicate;
+ this.consistency_level = consistency_level;
+ }
+
+ public void write_args(TProtocol prot) throws TException {
+ prot.writeMessageBegin(new TMessage("get_counter_slice", TMessageType.CALL, 0));
+ get_counter_slice_args args = new get_counter_slice_args();
+ args.setKey(key);
+ args.setColumn_parent(column_parent);
+ args.setPredicate(predicate);
+ args.setConsistency_level(consistency_level);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public List<Counter> getResult() throws InvalidRequestException, UnavailableException, TimedOutException, TException {
+ if (getState() != State.RESPONSE_READ) {
+ throw new IllegalStateException("Method call not finished!");
+ }
+ TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
+ TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_get_counter_slice();
+ }
+ }
+
+ public void multiget_counter_slice(List<ByteBuffer> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level, AsyncMethodCallback<multiget_counter_slice_call> resultHandler) throws TException {
+ checkReady();
+ multiget_counter_slice_call method_call = new multiget_counter_slice_call(keys, column_parent, predicate, consistency_level, resultHandler, this, protocolFactory, transport);
+ manager.call(method_call);
+ }
+
+ public static class multiget_counter_slice_call extends TAsyncMethodCall {
+ private List<ByteBuffer> keys;
+ private ColumnParent column_parent;
+ private SlicePredicate predicate;
+ private ConsistencyLevel consistency_level;
+ public multiget_counter_slice_call(List<ByteBuffer> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level, AsyncMethodCallback<multiget_counter_slice_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.keys = keys;
+ this.column_parent = column_parent;
+ this.predicate = predicate;
+ this.consistency_level = consistency_level;
+ }
+
+ public void write_args(TProtocol prot) throws TException {
+ prot.writeMessageBegin(new TMessage("multiget_counter_slice", TMessageType.CALL, 0));
+ multiget_counter_slice_args args = new multiget_counter_slice_args();
+ args.setKeys(keys);
+ args.setColumn_parent(column_parent);
+ args.setPredicate(predicate);
+ args.setConsistency_level(consistency_level);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public Map<ByteBuffer,List<Counter>> getResult() throws InvalidRequestException, UnavailableException, TimedOutException, TException {
+ if (getState() != State.RESPONSE_READ) {
+ throw new IllegalStateException("Method call not finished!");
+ }
+ TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
+ TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_multiget_counter_slice();
+ }
+ }
+
+ public void remove_counter(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level, AsyncMethodCallback<remove_counter_call> resultHandler) throws TException {
+ checkReady();
+ remove_counter_call method_call = new remove_counter_call(key, path, consistency_level, resultHandler, this, protocolFactory, transport);
+ manager.call(method_call);
+ }
+
+ public static class remove_counter_call extends TAsyncMethodCall {
+ private ByteBuffer key;
+ private ColumnPath path;
+ private ConsistencyLevel consistency_level;
+ public remove_counter_call(ByteBuffer key, ColumnPath path, ConsistencyLevel consistency_level, AsyncMethodCallback<remove_counter_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.key = key;
+ this.path = path;
+ this.consistency_level = consistency_level;
+ }
+
+ public void write_args(TProtocol prot) throws TException {
+ prot.writeMessageBegin(new TMessage("remove_counter", TMessageType.CALL, 0));
+ remove_counter_args args = new remove_counter_args();
+ args.setKey(key);
+ args.setPath(path);
+ args.setConsistency_level(consistency_level);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public void getResult() throws InvalidRequestException, UnavailableException, TimedOutException, TException {
+ if (getState() != State.RESPONSE_READ) {
+ throw new IllegalStateException("Method call not finished!");
+ }
+ TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
+ TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ (new Client(prot)).recv_remove_counter();
+ }
+ }
+
+ public void describe_schema_versions(AsyncMethodCallback<describe_schema_versions_call> resultHandler) throws TException {
+ checkReady();
+ describe_schema_versions_call method_call = new describe_schema_versions_call(resultHandler, this, protocolFactory, transport);
+ manager.call(method_call);
+ }
+
+ public static class describe_schema_versions_call extends TAsyncMethodCall {
+ public describe_schema_versions_call(AsyncMethodCallback<describe_schema_versions_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
public void write_args(TProtocol prot) throws TException {
prot.writeMessageBegin(new TMessage("describe_schema_versions", TMessageType.CALL, 0));
@@ -2514,6 +3088,12 @@ public class Cassandra {
processMap_.put("remove", new remove());
processMap_.put("batch_mutate", new batch_mutate());
processMap_.put("truncate", new truncate());
+ processMap_.put("add", new add());
+ processMap_.put("batch_add", new batch_add());
+ processMap_.put("get_counter", new get_counter());
+ processMap_.put("get_counter_slice", new get_counter_slice());
+ processMap_.put("multiget_counter_slice", new multiget_counter_slice());
+ processMap_.put("remove_counter", new remove_counter());
processMap_.put("describe_schema_versions", new describe_schema_versions());
processMap_.put("describe_keyspaces", new describe_keyspaces());
processMap_.put("describe_cluster_name", new describe_cluster_name());
@@ -3097,37 +3677,41 @@ public class Cassandra {
}
- private class describe_schema_versions implements ProcessFunction {
+ private class add implements ProcessFunction {
public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
{
- describe_schema_versions_args args = new describe_schema_versions_args();
+ add_args args = new add_args();
try {
args.read(iprot);
} catch (TProtocolException e) {
iprot.readMessageEnd();
TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
- oprot.writeMessageBegin(new TMessage("describe_schema_versions", TMessageType.EXCEPTION, seqid));
+ oprot.writeMessageBegin(new TMessage("add", TMessageType.EXCEPTION, seqid));
x.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
return;
}
iprot.readMessageEnd();
- describe_schema_versions_result result = new describe_schema_versions_result();
+ add_result result = new add_result();
try {
- result.success = iface_.describe_schema_versions();
+ iface_.add(args.key, args.column_parent, args.column, args.consistency_level);
} catch (InvalidRequestException ire) {
result.ire = ire;
+ } catch (UnavailableException ue) {
+ result.ue = ue;
+ } catch (TimedOutException te) {
+ result.te = te;
} catch (Throwable th) {
- LOGGER.error("Internal error processing describe_schema_versions", th);
- TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing describe_schema_versions");
- oprot.writeMessageBegin(new TMessage("describe_schema_versions", TMessageType.EXCEPTION, seqid));
+ LOGGER.error("Internal error processing add", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing add");
+ oprot.writeMessageBegin(new TMessage("add", TMessageType.EXCEPTION, seqid));
x.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
return;
}
- oprot.writeMessageBegin(new TMessage("describe_schema_versions", TMessageType.REPLY, seqid));
+ oprot.writeMessageBegin(new TMessage("add", TMessageType.REPLY, seqid));
result.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
@@ -3135,37 +3719,41 @@ public class Cassandra {
}
- private class describe_keyspaces implements ProcessFunction {
+ private class batch_add implements ProcessFunction {
public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
{
- describe_keyspaces_args args = new describe_keyspaces_args();
+ batch_add_args args = new batch_add_args();
try {
args.read(iprot);
} catch (TProtocolException e) {
iprot.readMessageEnd();
TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
- oprot.writeMessageBegin(new TMessage("describe_keyspaces", TMessageType.EXCEPTION, seqid));
+ oprot.writeMessageBegin(new TMessage("batch_add", TMessageType.EXCEPTION, seqid));
x.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
return;
}
iprot.readMessageEnd();
- describe_keyspaces_result result = new describe_keyspaces_result();
+ batch_add_result result = new batch_add_result();
try {
- result.success = iface_.describe_keyspaces();
+ iface_.batch_add(args.update_map, args.consistency_level);
} catch (InvalidRequestException ire) {
result.ire = ire;
+ } catch (UnavailableException ue) {
+ result.ue = ue;
+ } catch (TimedOutException te) {
+ result.te = te;
} catch (Throwable th) {
- LOGGER.error("Internal error processing describe_keyspaces", th);
- TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing describe_keyspaces");
- oprot.writeMessageBegin(new TMessage("describe_keyspaces", TMessageType.EXCEPTION, seqid));
+ LOGGER.error("Internal error processing batch_add", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing batch_add");
+ oprot.writeMessageBegin(new TMessage("batch_add", TMessageType.EXCEPTION, seqid));
x.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
return;
}
- oprot.writeMessageBegin(new TMessage("describe_keyspaces", TMessageType.REPLY, seqid));
+ oprot.writeMessageBegin(new TMessage("batch_add", TMessageType.REPLY, seqid));
result.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
@@ -3173,25 +3761,43 @@ public class Cassandra {
}
- private class describe_cluster_name implements ProcessFunction {
+ private class get_counter implements ProcessFunction {
public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
{
- describe_cluster_name_args args = new describe_cluster_name_args();
+ get_counter_args args = new get_counter_args();
try {
args.read(iprot);
} catch (TProtocolException e) {
iprot.readMessageEnd();
TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
- oprot.writeMessageBegin(new TMessage("describe_cluster_name", TMessageType.EXCEPTION, seqid));
+ oprot.writeMessageBegin(new TMessage("get_counter", TMessageType.EXCEPTION, seqid));
x.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
return;
}
iprot.readMessageEnd();
- describe_cluster_name_result result = new describe_cluster_name_result();
- result.success = iface_.describe_cluster_name();
- oprot.writeMessageBegin(new TMessage("describe_cluster_name", TMessageType.REPLY, seqid));
+ get_counter_result result = new get_counter_result();
+ try {
+ result.success = iface_.get_counter(args.key, args.path, args.consistency_level);
+ } catch (InvalidRequestException ire) {
+ result.ire = ire;
+ } catch (NotFoundException nfe) {
+ result.nfe = nfe;
+ } catch (UnavailableException ue) {
+ result.ue = ue;
+ } catch (TimedOutException te) {
+ result.te = te;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing get_counter", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing get_counter");
+ oprot.writeMessageBegin(new TMessage("get_counter", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("get_counter", TMessageType.REPLY, seqid));
result.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
@@ -3199,25 +3805,41 @@ public class Cassandra {
}
- private class describe_version implements ProcessFunction {
+ private class get_counter_slice implements ProcessFunction {
public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
{
- describe_version_args args = new describe_version_args();
+ get_counter_slice_args args = new get_counter_slice_args();
try {
args.read(iprot);
} catch (TProtocolException e) {
iprot.readMessageEnd();
TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
- oprot.writeMessageBegin(new TMessage("describe_version", TMessageType.EXCEPTION, seqid));
+ oprot.writeMessageBegin(new TMessage("get_counter_slice", TMessageType.EXCEPTION, seqid));
x.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
return;
}
iprot.readMessageEnd();
- describe_version_result result = new describe_version_result();
- result.success = iface_.describe_version();
- oprot.writeMessageBegin(new TMessage("describe_version", TMessageType.REPLY, seqid));
+ get_counter_slice_result result = new get_counter_slice_result();
+ try {
+ result.success = iface_.get_counter_slice(args.key, args.column_parent, args.predicate, args.consistency_level);
+ } catch (InvalidRequestException ire) {
+ result.ire = ire;
+ } catch (UnavailableException ue) {
+ result.ue = ue;
+ } catch (TimedOutException te) {
+ result.te = te;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing get_counter_slice", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing get_counter_slice");
+ oprot.writeMessageBegin(new TMessage("get_counter_slice", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("get_counter_slice", TMessageType.REPLY, seqid));
result.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
@@ -3225,37 +3847,41 @@ public class Cassandra {
}
- private class describe_ring implements ProcessFunction {
+ private class multiget_counter_slice implements ProcessFunction {
public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
{
- describe_ring_args args = new describe_ring_args();
+ multiget_counter_slice_args args = new multiget_counter_slice_args();
try {
args.read(iprot);
} catch (TProtocolException e) {
iprot.readMessageEnd();
TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
- oprot.writeMessageBegin(new TMessage("describe_ring", TMessageType.EXCEPTION, seqid));
+ oprot.writeMessageBegin(new TMessage("multiget_counter_slice", TMessageType.EXCEPTION, seqid));
x.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
return;
}
iprot.readMessageEnd();
- describe_ring_result result = new describe_ring_result();
+ multiget_counter_slice_result result = new multiget_counter_slice_result();
try {
- result.success = iface_.describe_ring(args.keyspace);
+ result.success = iface_.multiget_counter_slice(args.keys, args.column_parent, args.predicate, args.consistency_level);
} catch (InvalidRequestException ire) {
result.ire = ire;
+ } catch (UnavailableException ue) {
+ result.ue = ue;
+ } catch (TimedOutException te) {
+ result.te = te;
} catch (Throwable th) {
- LOGGER.error("Internal error processing describe_ring", th);
- TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing describe_ring");
- oprot.writeMessageBegin(new TMessage("describe_ring", TMessageType.EXCEPTION, seqid));
+ LOGGER.error("Internal error processing multiget_counter_slice", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing multiget_counter_slice");
+ oprot.writeMessageBegin(new TMessage("multiget_counter_slice", TMessageType.EXCEPTION, seqid));
x.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
return;
}
- oprot.writeMessageBegin(new TMessage("describe_ring", TMessageType.REPLY, seqid));
+ oprot.writeMessageBegin(new TMessage("multiget_counter_slice", TMessageType.REPLY, seqid));
result.write(oprot);
oprot.writeMessageEnd();
oprot.getTransport().flush();
@@ -3263,10 +3889,218 @@ public class Cassandra {
}
- private class describe_partitioner implements ProcessFunction {
+ private class remove_counter implements ProcessFunction {
public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
{
- describe_partitioner_args args = new describe_partitioner_args();
+ remove_counter_args args = new remove_counter_args();
+ try {
+ args.read(iprot);
+ } catch (TProtocolException e) {
+ iprot.readMessageEnd();
+ TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
+ oprot.writeMessageBegin(new TMessage("remove_counter", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ iprot.readMessageEnd();
+ remove_counter_result result = new remove_counter_result();
+ try {
+ iface_.remove_counter(args.key, args.path, args.consistency_level);
+ } catch (InvalidRequestException ire) {
+ result.ire = ire;
+ } catch (UnavailableException ue) {
+ result.ue = ue;
+ } catch (TimedOutException te) {
+ result.te = te;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing remove_counter", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing remove_counter");
+ oprot.writeMessageBegin(new TMessage("remove_counter", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("remove_counter", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class describe_schema_versions implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ describe_schema_versions_args args = new describe_schema_versions_args();
+ try {
+ args.read(iprot);
+ } catch (TProtocolException e) {
+ iprot.readMessageEnd();
+ TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
+ oprot.writeMessageBegin(new TMessage("describe_schema_versions", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ iprot.readMessageEnd();
+ describe_schema_versions_result result = new describe_schema_versions_result();
+ try {
+ result.success = iface_.describe_schema_versions();
+ } catch (InvalidRequestException ire) {
+ result.ire = ire;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing describe_schema_versions", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing describe_schema_versions");
+ oprot.writeMessageBegin(new TMessage("describe_schema_versions", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("describe_schema_versions", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class describe_keyspaces implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ describe_keyspaces_args args = new describe_keyspaces_args();
+ try {
+ args.read(iprot);
+ } catch (TProtocolException e) {
+ iprot.readMessageEnd();
+ TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
+ oprot.writeMessageBegin(new TMessage("describe_keyspaces", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ iprot.readMessageEnd();
+ describe_keyspaces_result result = new describe_keyspaces_result();
+ try {
+ result.success = iface_.describe_keyspaces();
+ } catch (InvalidRequestException ire) {
+ result.ire = ire;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing describe_keyspaces", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing describe_keyspaces");
+ oprot.writeMessageBegin(new TMessage("describe_keyspaces", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("describe_keyspaces", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class describe_cluster_name implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ describe_cluster_name_args args = new describe_cluster_name_args();
+ try {
+ args.read(iprot);
+ } catch (TProtocolException e) {
+ iprot.readMessageEnd();
+ TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
+ oprot.writeMessageBegin(new TMessage("describe_cluster_name", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ iprot.readMessageEnd();
+ describe_cluster_name_result result = new describe_cluster_name_result();
+ result.success = iface_.describe_cluster_name();
+ oprot.writeMessageBegin(new TMessage("describe_cluster_name", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class describe_version implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ describe_version_args args = new describe_version_args();
+ try {
+ args.read(iprot);
+ } catch (TProtocolException e) {
+ iprot.readMessageEnd();
+ TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
+ oprot.writeMessageBegin(new TMessage("describe_version", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ iprot.readMessageEnd();
+ describe_version_result result = new describe_version_result();
+ result.success = iface_.describe_version();
+ oprot.writeMessageBegin(new TMessage("describe_version", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class describe_ring implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ describe_ring_args args = new describe_ring_args();
+ try {
+ args.read(iprot);
+ } catch (TProtocolException e) {
+ iprot.readMessageEnd();
+ TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
+ oprot.writeMessageBegin(new TMessage("describe_ring", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ iprot.readMessageEnd();
+ describe_ring_result result = new describe_ring_result();
+ try {
+ result.success = iface_.describe_ring(args.keyspace);
+ } catch (InvalidRequestException ire) {
+ result.ire = ire;
+ } catch (Throwable th) {
+ LOGGER.error("Internal error processing describe_ring", th);
+ TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing describe_ring");
+ oprot.writeMessageBegin(new TMessage("describe_ring", TMessageType.EXCEPTION, seqid));
+ x.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ return;
+ }
+ oprot.writeMessageBegin(new TMessage("describe_ring", TMessageType.REPLY, seqid));
+ result.write(oprot);
+ oprot.writeMessageEnd();
+ oprot.getTransport().flush();
+ }
+
+ }
+
+ private class describe_partitioner implements ProcessFunction {
+ public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+ {
+ describe_partitioner_args args = new describe_partitioner_args();
try {
args.read(iprot);
} catch (TProtocolException e) {
@@ -7138,14 +7972,14 @@ public class Cassandra {
case 0: // SUCCESS
if (field.type == TType.LIST) {
{
- TList _list38 = iprot.readListBegin();
- this.success = new ArrayList<ColumnOrSuperColumn>(_list38.size);
- for (int _i39 = 0; _i39 < _list38.size; ++_i39)
+ TList _list42 = iprot.readListBegin();
+ this.success = new ArrayList<ColumnOrSuperColumn>(_list42.size);
+ for (int _i43 = 0; _i43 < _list42.size; ++_i43)
{
- ColumnOrSuperColumn _elem40;
- _elem40 = new ColumnOrSuperColumn();
- _elem40.read(iprot);
- this.success.add(_elem40);
+ ColumnOrSuperColumn _elem44;
+ _elem44 = new ColumnOrSuperColumn();
+ _elem44.read(iprot);
+ this.success.add(_elem44);
}
iprot.readListEnd();
}
@@ -7195,9 +8029,9 @@ public class Cassandra {
oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
{
oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
- for (ColumnOrSuperColumn _iter41 : this.success)
+ for (ColumnOrSuperColumn _iter45 : this.success)
{
- _iter41.write(oprot);
+ _iter45.write(oprot);
}
oprot.writeListEnd();
}
@@ -8949,13 +9783,13 @@ public class Cassandra {
case 1: // KEYS
if (field.type == TType.LIST) {
{
- TList _list42 = iprot.readListBegin();
- this.keys = new ArrayList<ByteBuffer>(_list42.size);
- for (int _i43 = 0; _i43 < _list42.size; ++_i43)
+ TList _list46 = iprot.readListBegin();
+ this.keys = new ArrayList<ByteBuffer>(_list46.size);
+ for (int _i47 = 0; _i47 < _list46.size; ++_i47)
{
- ByteBuffer _elem44;
- _elem44 = iprot.readBinary();
- this.keys.add(_elem44);
+ ByteBuffer _elem48;
+ _elem48 = iprot.readBinary();
+ this.keys.add(_elem48);
}
iprot.readListEnd();
}
@@ -9005,9 +9839,9 @@ public class Cassandra {
oprot.writeFieldBegin(KEYS_FIELD_DESC);
{
oprot.writeListBegin(new TList(TType.STRING, this.keys.size()));
- for (ByteBuffer _iter45 : this.keys)
+ for (ByteBuffer _iter49 : this.keys)
{
- oprot.writeBinary(_iter45);
+ oprot.writeBinary(_iter49);
}
oprot.writeListEnd();
}
@@ -9580,26 +10414,26 @@ public class Cassandra {
case 0: // SUCCESS
if (field.type == TType.MAP) {
{
- TMap _map46 = iprot.readMapBegin();
- this.success = new HashMap<ByteBuffer,List<ColumnOrSuperColumn>>(2*_map46.size);
- for (int _i47 = 0; _i47 < _map46.size; ++_i47)
+ TMap _map50 = iprot.readMapBegin();
+ this.success = new HashMap<ByteBuffer,List<ColumnOrSuperColumn>>(2*_map50.size);
+ for (int _i51 = 0; _i51 < _map50.size; ++_i51)
{
- ByteBuffer _key48;
- List<ColumnOrSuperColumn> _val49;
- _key48 = iprot.readBinary();
+ ByteBuffer _key52;
+ List<ColumnOrSuperColumn> _val53;
+ _key52 = iprot.readBinary();
{
- TList _list50 = iprot.readListBegin();
- _val49 = new ArrayList<ColumnOrSuperColumn>(_list50.size);
- for (int _i51 = 0; _i51 < _list50.size; ++_i51)
+ TList _list54 = iprot.readListBegin();
+ _val53 = new ArrayList<ColumnOrSuperColumn>(_list54.size);
+ for (int _i55 = 0; _i55 < _list54.size; ++_i55)
{
- ColumnOrSuperColumn _elem52;
- _elem52 = new ColumnOrSuperColumn();
- _elem52.read(iprot);
- _val49.add(_elem52);
+ ColumnOrSuperColumn _elem56;
+ _elem56 = new ColumnOrSuperColumn();
+ _elem56.read(iprot);
+ _val53.add(_elem56);
}
iprot.readListEnd();
}
- this.success.put(_key48, _val49);
+ this.success.put(_key52, _val53);
}
iprot.readMapEnd();
}
@@ -9649,14 +10483,14 @@ public class Cassandra {
oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
{
oprot.writeMapBegin(new TMap(TType.STRING, TType.LIST, this.success.size()));
- for (Map.Entry<ByteBuffer, List<ColumnOrSuperColumn>> _iter53 : this.success.entrySet())
+ for (Map.Entry<ByteBuffer, List<ColumnOrSuperColumn>> _iter57 : this.success.entrySet())
{
- oprot.writeBinary(_iter53.getKey());
+ oprot.writeBinary(_iter57.getKey());
{
- oprot.writeListBegin(new TList(TType.STRUCT, _iter53.getValue().size()));
- for (ColumnOrSuperColumn _iter54 : _iter53.getValue())
+ oprot.writeListBegin(new TList(TType.STRUCT, _iter57.getValue().size()));
+ for (ColumnOrSuperColumn _iter58 : _iter57.getValue())
{
- _iter54.write(oprot);
+ _iter58.write(oprot);
}
oprot.writeListEnd();
}
@@ -10228,13 +11062,13 @@ public class Cassandra {
case 1: // KEYS
if (field.type == TType.LIST) {
{
- TList _list55 = iprot.readListBegin();
- this.keys = new ArrayList<ByteBuffer>(_list55.size);
- for (int _i56 = 0; _i56 < _list55.size; ++_i56)
+ TList _list59 = iprot.readListBegin();
+ this.keys = new ArrayList<ByteBuffer>(_list59.size);
+ for (int _i60 = 0; _i60 < _list59.size; ++_i60)
{
- ByteBuffer _elem57;
- _elem57 = iprot.readBinary();
- this.keys.add(_elem57);
+ ByteBuffer _elem61;
+ _elem61 = iprot.readBinary();
+ this.keys.add(_elem61);
}
iprot.readListEnd();
}
@@ -10284,9 +11118,9 @@ public class Cassandra {
oprot.writeFieldBegin(KEYS_FIELD_DESC);
{
oprot.writeListBegin(new TList(TType.STRING, this.keys.size()));
- for (ByteBuffer _iter58 : this.keys)
+ for (ByteBuffer _iter62 : this.keys)
{
- oprot.writeBinary(_iter58);
+ oprot.writeBinary(_iter62);
}
oprot.writeListEnd();
}
@@ -10855,15 +11689,15 @@ public class Cassandra {
case 0: // SUCCESS
if (field.type == TType.MAP) {
{
- TMap _map59 = iprot.readMapBegin();
- this.success = new HashMap<ByteBuffer,Integer>(2*_map59.size);
- for (int _i60 = 0; _i60 < _map59.size; ++_i60)
+ TMap _map63 = iprot.readMapBegin();
+ this.success = new HashMap<ByteBuffer,Integer>(2*_map63.size);
+ for (int _i64 = 0; _i64 < _map63.size; ++_i64)
{
- ByteBuffer _key61;
- int _val62;
- _key61 = iprot.readBinary();
- _val62 = iprot.readI32();
- this.success.put(_key61, _val62);
+ ByteBuffer _key65;
+ int _val66;
+ _key65 = iprot.readBinary();
+ _val66 = iprot.readI32();
+ this.success.put(_key65, _val66);
}
iprot.readMapEnd();
}
@@ -10913,10 +11747,10 @@ public class Cassandra {
oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
{
oprot.writeMapBegin(new TMap(TType.STRING, TType.I32, this.success.size()));
- for (Map.Entry<ByteBuffer, Integer> _iter63 : this.success.entrySet())
+ for (Map.Entry<ByteBuffer, Integer> _iter67 : this.success.entrySet())
{
- oprot.writeBinary(_iter63.getKey());
- oprot.writeI32(_iter63.getValue());
+ oprot.writeBinary(_iter67.getKey());
+ oprot.writeI32(_iter67.getValue());
}
oprot.writeMapEnd();
}
@@ -12068,14 +12902,14 @@ public class Cassandra {
case 0: // SUCCESS
if (field.type == TType.LIST) {
{
- TList _list64 = iprot.readListBegin();
- this.success = new ArrayList<KeySlice>(_list64.size);
- for (int _i65 = 0; _i65 < _list64.size; ++_i65)
+ TList _list68 = iprot.readListBegin();
+ this.success = new ArrayList<KeySlice>(_list68.size);
+ for (int _i69 = 0; _i69 < _list68.size; ++_i69)
{
- KeySlice _elem66;
- _elem66 = new KeySlice();
- _elem66.read(iprot);
- this.success.add(_elem66);
+ KeySlice _elem70;
+ _elem70 = new KeySlice();
+ _elem70.read(iprot);
+ this.success.add(_elem70);
}
iprot.readListEnd();
}
@@ -12125,9 +12959,9 @@ public class Cassandra {
oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
{
oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
- for (KeySlice _iter67 : this.success)
+ for (KeySlice _iter71 : this.success)
{
- _iter67.write(oprot);
+ _iter71.write(oprot);
}
oprot.writeListEnd();
}
@@ -13279,14 +14113,14 @@ public class Cassandra {
case 0: // SUCCESS
if (field.type == TType.LIST) {
{
- TList _list68 = iprot.readListBegin();
- this.success = new ArrayList<KeySlice>(_list68.size);
- for (int _i69 = 0; _i69 < _list68.size; ++_i69)
+ TList _list72 = iprot.readListBegin();
+ this.success = new ArrayList<KeySlice>(_list72.size);
+ for (int _i73 = 0; _i73 < _list72.size; ++_i73)
{
- KeySlice _elem70;
- _elem70 = new KeySlice();
- _elem70.read(iprot);
- this.success.add(_elem70);
+ KeySlice _elem74;
+ _elem74 = new KeySlice();
+ _elem74.read(iprot);
+ this.success.add(_elem74);
}
iprot.readListEnd();
}
@@ -13336,9 +14170,9 @@ public class Cassandra {
oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
{
oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
- for (KeySlice _iter71 : this.success)
+ for (KeySlice _iter75 : this.success)
{
- _iter71.write(oprot);
+ _iter75.write(oprot);
}
oprot.writeListEnd();
}
@@ -15955,38 +16789,38 @@ public class Cassandra {
case 1: // MUTATION_MAP
if (field.type == TType.MAP) {
{
- TMap _map72 = iprot.readMapBegin();
- this.mutation_map = new HashMap<ByteBuffer,Map<String,List<Mutation>>>(2*_map72.size);
- for (int _i73 = 0; _i73 < _map72.size; ++_i73)
+ TMap _map76 = iprot.readMapBegin();
+ this.mutation_map = new HashMap<ByteBuffer,Map<String,List<Mutation>>>(2*_map76.size);
+ for (int _i77 = 0; _i77 < _map76.size; ++_i77)
{
- ByteBuffer _key74;
- Map<String,List<Mutation>> _val75;
- _key74 = iprot.readBinary();
+ ByteBuffer _key78;
+ Map<String,List<Mutation>> _val79;
+ _key78 = iprot.readBinary();
{
- TMap _map76 = iprot.readMapBegin();
- _val75 = new HashMap<String,List<Mutation>>(2*_map76.size);
- for (int _i77 = 0; _i77 < _map76.size; ++_i77)
+ TMap _map80 = iprot.readMapBegin();
+ _val79 = new HashMap<String,List<Mutation>>(2*_map80.size);
+ for (int _i81 = 0; _i81 < _map80.size; ++_i81)
{
- String _key78;
- List<Mutation> _val79;
- _key78 = iprot.readString();
+ String _key82;
+ List<Mutation> _val83;
+ _key82 = iprot.readString();
{
- TList _list80 = iprot.readListBegin();
- _val79 = new ArrayList<Mutation>(_list80.size);
- for (int _i81 = 0; _i81 < _list80.size; ++_i81)
+ TList _list84 = iprot.readListBegin();
+ _val83 = new ArrayList<Mutation>(_list84.size);
+ for (int _i85 = 0; _i85 < _list84.size; ++_i85)
{
- Mutation _elem82;
- _elem82 = new Mutation();
- _elem82.read(iprot);
- _val79.add(_elem82);
+ Mutation _elem86;
+ _elem86 = new Mutation();
+ _elem86.read(iprot);
+ _val83.add(_elem86);
}
iprot.readListEnd();
}
- _val75.put(_key78, _val79);
+ _val79.put(_key82, _val83);
}
iprot.readMapEnd();
}
- this.mutation_map.put(_key74, _val75);
+ this.mutation_map.put(_key78, _val79);
}
iprot.readMapEnd();
}
@@ -16020,19 +16854,19 @@ public class Cassandra {
oprot.writeFieldBegin(MUTATION_MAP_FIELD_DESC);
{
oprot.writeMapBegin(new TMap(TType.STRING, TType.MAP, this.mutation_map.size()));
- for (Map.Entry<ByteBuffer, Map<String,List<Mutation>>> _iter83 : this.mutation_map.entrySet())
+ for (Map.Entry<ByteBuffer, Map<String,List<Mutation>>> _iter87 : this.mutation_map.entrySet())
{
- oprot.writeBinary(_iter83.getKey());
+ oprot.writeBinary(_iter87.getKey());
{
- oprot.writeMapBegin(new TMap(TType.STRING, TType.LIST, _iter83.getValue().size()));
- for (Map.Entry<String, List<Mutation>> _iter84 : _iter83.getValue().entrySet())
+ oprot.writeMapBegin(new TMap(TType.STRING, TType.LIST, _iter87.getValue().size()));
+ for (Map.Entry<String, List<Mutation>> _iter88 : _iter87.getValue().entrySet())
{
- oprot.writeString(_iter84.getKey());
+ oprot.writeString(_iter88.getKey());
{
- oprot.writeListBegin(new TList(TType.STRUCT, _iter84.getValue().size()));
- for (Mutation _iter85 : _iter84.getValue())
+ oprot.writeListBegin(new TList(TType.STRUCT, _iter88.getValue().size()));
+ for (Mutation _iter89 : _iter88.getValue())
{
- _iter85.write(oprot);
+ _iter89.write(oprot);
}
oprot.writeListEnd();
}
@@ -17238,6 +18072,6752 @@ public class Cassandra {
}
+ public static class add_args implements TBase<add_args, add_args._Fields>, java.io.Serializable, Cloneable {
+ private static final TStruct STRUCT_DESC = new TStruct("add_args");
+
+ private static final TField KEY_FIELD_DESC = new TField("key", TType.STRING, (short)1);
+ private static final TField COLUMN_PARENT_FIELD_DESC = new TField("column_parent", TType.STRUCT, (short)2);
+ private static final TField COLUMN_FIELD_DESC = new TField("column", TType.STRUCT, (short)3);
+ private static final TField CONSISTENCY_LEVEL_FIELD_DESC = new TField("consistency_level", TType.I32, (short)4);
+
+ public ByteBuffer key;
+ public ColumnParent column_parent;
+ public CounterColumn column;
+ /**
+ *
+ * @see ConsistencyLevel
+ */
+ public ConsistencyLevel consistency_level;
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements TFieldIdEnum {
+ KEY((short)1, "key"),
+ COLUMN_PARENT((short)2, "column_parent"),
+ COLUMN((short)3, "column"),
+ /**
+ *
+ * @see ConsistencyLevel
+ */
+ CONSISTENCY_LEVEL((short)4, "consistency_level");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ 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: // KEY
+ return KEY;
+ case 2: // COLUMN_PARENT
+ return COLUMN_PARENT;
+ case 3: // COLUMN
+ return COLUMN;
+ case 4: // CONSISTENCY_LEVEL
+ return CONSISTENCY_LEVEL;
+ 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, FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.KEY, new FieldMetaData("key", TFieldRequirementType.REQUIRED,
+ new FieldValueMetaData(TType.STRING)));
+ tmpMap.put(_Fields.COLUMN_PARENT, new FieldMetaData("column_parent", TFieldRequirementType.REQUIRED,
+ new StructMetaData(TType.STRUCT, ColumnParent.class)));
+ tmpMap.put(_Fields.COLUMN, new FieldMetaData("column", TFieldRequirementType.REQUIRED,
+ new StructMetaData(TType.STRUCT, CounterColumn.class)));
+ tmpMap.put(_Fields.CONSISTENCY_LEVEL, new FieldMetaData("consistency_level", TFieldRequirementType.REQUIRED,
+ new EnumMetaData(TType.ENUM, ConsistencyLevel.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ FieldMetaData.addStructMetaDataMap(add_args.class, metaDataMap);
+ }
+
+ public add_args() {
+ this.consistency_level = ConsistencyLevel.ONE;
+
+ }
+
+ public add_args(
+ ByteBuffer key,
+ ColumnParent column_parent,
+ CounterColumn column,
+ ConsistencyLevel consistency_level)
+ {
+ this();
+ this.key = key;
+ this.column_parent = column_parent;
+ this.column = column;
+ this.consistency_level = consistency_level;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public add_args(add_args other) {
+ if (other.isSetKey()) {
+ this.key = TBaseHelper.copyBinary(other.key);
+;
+ }
+ if (other.isSetColumn_parent()) {
+ this.column_parent = new ColumnParent(other.column_parent);
+ }
+ if (other.isSetColumn()) {
+ this.column = new CounterColumn(other.column);
+ }
+ if (other.isSetConsistency_level()) {
+ this.consistency_level = other.consistency_level;
+ }
+ }
+
+ public add_args deepCopy() {
+ return new add_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.key = null;
+ this.column_parent = null;
+ this.column = null;
+ this.consistency_level = ConsistencyLevel.ONE;
+
+ }
+
+ public byte[] getKey() {
+ setKey(TBaseHelper.rightSize(key));
+ return key.array();
+ }
+
+ public ByteBuffer BufferForKey() {
+ return key;
+ }
+
+ public add_args setKey(byte[] key) {
+ setKey(ByteBuffer.wrap(key));
+ return this;
+ }
+
+ public add_args setKey(ByteBuffer key) {
+ this.key = key;
+ return this;
+ }
+
+ public void unsetKey() {
+ this.key = null;
+ }
+
+ /** Returns true if field key is set (has been asigned a value) and false otherwise */
+ public boolean isSetKey() {
+ return this.key != null;
+ }
+
+ public void setKeyIsSet(boolean value) {
+ if (!value) {
+ this.key = null;
+ }
+ }
+
+ public ColumnParent getColumn_parent() {
+ return this.column_parent;
+ }
+
+ public add_args setColumn_parent(ColumnParent column_parent) {
+ this.column_parent = column_parent;
+ return this;
+ }
+
+ public void unsetColumn_parent() {
+ this.column_parent = null;
+ }
+
+ /** Returns true if field column_parent is set (has been asigned a value) and false otherwise */
+ public boolean isSetColumn_parent() {
+ return this.column_parent != null;
+ }
+
+ public void setColumn_parentIsSet(boolean value) {
+ if (!value) {
+ this.column_parent = null;
+ }
+ }
+
+ public CounterColumn getColumn() {
+ return this.column;
+ }
+
+ public add_args setColumn(CounterColumn column) {
+ this.column = column;
+ return this;
+ }
+
+ public void unsetColumn() {
+ this.column = null;
+ }
+
+ /** Returns true if field column is set (has been asigned a value) and false otherwise */
+ public boolean isSetColumn() {
+ return this.column != null;
+ }
+
+ public void setColumnIsSet(boolean value) {
+ if (!value) {
+ this.column = null;
+ }
+ }
+
+ /**
+ *
+ * @see ConsistencyLevel
+ */
+ public ConsistencyLevel getConsistency_level() {
+ return this.consistency_level;
+ }
+
+ /**
+ *
+ * @see ConsistencyLevel
+ */
+ public add_args setConsistency_level(ConsistencyLevel consistency_level) {
+ this.consistency_level = consistency_level;
+ return this;
+ }
+
+ public void unsetConsistency_level() {
+ this.consistency_level = null;
+ }
+
+ /** Returns true if field consistency_level is set (has been asigned a value) and false otherwise */
+ public boolean isSetConsistency_level() {
+ return this.consistency_level != null;
+ }
+
+ public void setConsistency_levelIsSet(boolean value) {
+ if (!value) {
+ this.consistency_level = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case KEY:
+ if (value == null) {
+ unsetKey();
+ } else {
+ setKey((ByteBuffer)value);
+ }
+ break;
+
+ case COLUMN_PARENT:
+ if (value == null) {
+ unsetColumn_parent();
+ } else {
+ setColumn_parent((ColumnParent)value);
+ }
+ break;
+
+ case COLUMN:
+ if (value == null) {
+ unsetColumn();
+ } else {
+ setColumn((CounterColumn)value);
+ }
+ break;
+
+ case CONSISTENCY_LEVEL:
+ if (value == null) {
+ unsetConsistency_level();
+ } else {
+ setConsistency_level((ConsistencyLevel)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case KEY:
+ return getKey();
+
+ case COLUMN_PARENT:
+ return getColumn_parent();
+
+ case COLUMN:
+ return getColumn();
+
+ case CONSISTENCY_LEVEL:
+ return getConsistency_level();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case KEY:
+ return isSetKey();
+ case COLUMN_PARENT:
+ return isSetColumn_parent();
+ case COLUMN:
+ return isSetColumn();
+ case CONSISTENCY_LEVEL:
+ return isSetConsistency_level();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof add_args)
+ return this.equals((add_args)that);
+ return false;
+ }
+
+ public boolean equals(add_args that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_key = true && this.isSetKey();
+ boolean that_present_key = true && that.isSetKey();
+ if (this_present_key || that_present_key) {
+ if (!(this_present_key && that_present_key))
+ return false;
+ if (!this.key.equals(that.key))
+ return false;
+ }
+
+ boolean this_present_column_parent = true && this.isSetColumn_parent();
+ boolean that_present_column_parent = true && that.isSetColumn_parent();
+ if (this_present_column_parent || that_present_column_parent) {
+ if (!(this_present_column_parent && that_present_column_parent))
+ return false;
+ if (!this.column_parent.equals(that.column_parent))
+ 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_consistency_level = true && this.isSetConsistency_level();
+ boolean that_present_consistency_level = true && that.isSetConsistency_level();
+ if (this_present_consistency_level || that_present_consistency_level) {
+ if (!(this_present_consistency_level && that_present_consistency_level))
+ return false;
+ if (!this.consistency_level.equals(that.consistency_level))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_key = true && (isSetKey());
+ builder.append(present_key);
+ if (present_key)
+ builder.append(key);
+
+ boolean present_column_parent = true && (isSetColumn_parent());
+ builder.append(present_column_parent);
+ if (present_column_parent)
+ builder.append(column_parent);
+
+ boolean present_column = true && (isSetColumn());
+ builder.append(present_column);
+ if (present_column)
+ builder.append(column);
+
+ boolean present_consistency_level = true && (isSetConsistency_level());
+ builder.append(present_consistency_level);
+ if (present_consistency_level)
+ builder.append(consistency_level.getValue());
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(add_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ add_args typedOther = (add_args)other;
+
+ lastComparison = Boolean.valueOf(isSetKey()).compareTo(typedOther.isSetKey());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetKey()) {
+ lastComparison = TBaseHelper.compareTo(this.key, typedOther.key);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetColumn_parent()).compareTo(typedOther.isSetColumn_parent());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn_parent()) {
+ lastComparison = TBaseHelper.compareTo(this.column_parent, typedOther.column_parent);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetColumn()).compareTo(typedOther.isSetColumn());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColumn()) {
+ lastComparison = TBaseHelper.compareTo(this.column, typedOther.column);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetConsistency_level()).compareTo(typedOther.isSetConsistency_level());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetConsistency_level()) {
+ lastComparison = TBaseHelper.compareTo(this.consistency_level, typedOther.consistency_level);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(TProtocol iprot) throws TException {
+ TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == TType.STOP) {
+ break;
+ }
+ switch (field.id) {
+ case 1: // KEY
+ if (field.type == TType.STRING) {
+ this.key = iprot.readBinary();
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case 2: // COLUMN_PARENT
+ if (field.type == TType.STRUCT) {
+ this.column_parent = new ColumnParent();
+ this.column_parent.read(iprot);
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case 3: // COLUMN
+ if (field.type == TType.STRUCT) {
+ this.column = new CounterColumn();
+ this.column.read(iprot);
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case 4: // CONSISTENCY_LEVEL
+ if (field.type == TType.I32) {
+ this.consistency_level = ConsistencyLevel.findByValue(iprot.readI32());
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ default:
+ 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(TProtocol oprot) throws TException {
+ validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (this.key != null) {
+ oprot.writeFieldBegin(KEY_FIELD_DESC);
+ oprot.writeBinary(this.key);
+ oprot.writeFieldEnd();
+ }
+ if (this.column_parent != null) {
+ oprot.writeFieldBegin(COLUMN_PARENT_FIELD_DESC);
+ this.column_parent.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (this.column != null) {
+ oprot.writeFieldBegin(COLUMN_FIELD_DESC);
+ this.column.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (this.consistency_level != null) {
+ oprot.writeFieldBegin(CONSISTENCY_LEVEL_FIELD_DESC);
+ oprot.writeI32(this.consistency_level.getValue());
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("add_args(");
+ boolean first = true;
+
+ sb.append("key:");
+ if (this.key == null) {
+ sb.append("null");
+ } else {
+ TBaseHelper.toString(this.key, sb);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("column_parent:");
+ if (this.column_parent == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.column_parent);
+ }
+ 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("consistency_level:");
+ if (this.consistency_level == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.consistency_level);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws TException {
+ // check for required fields
+ if (key == null) {
+ throw new TProtocolException("Required field 'key' was not present! Struct: " + toString());
+ }
+ if (column_parent == null) {
+ throw new TProtocolException("Required field 'column_parent' was not present! Struct: " + toString());
+ }
+ if (column == null) {
+ throw new TProtocolException("Required field 'column' was not present! Struct: " + toString());
+ }
+ if (consistency_level == null) {
+ throw new TProtocolException("Required field 'consistency_level' was not present! Struct: " + toString());
+ }
+ }
+
+ }
+
+ public static class add_result implements TBase<add_result, add_result._Fields>, java.io.Serializable, Cloneable {
+ private static final TStruct STRUCT_DESC = new TStruct("add_result");
+
+ private static final TField IRE_FIELD_DESC = new TField("ire", TType.STRUCT, (short)1);
+ private static final TField UE_FIELD_DESC = new TField("ue", TType.STRUCT, (short)2);
+ private static final TField TE_FIELD_DESC = new TField("te", TType.STRUCT, (short)3);
+
+ public InvalidRequestException ire;
+ public UnavailableException ue;
+ public TimedOutException te;
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements TFieldIdEnum {
+ IRE((short)1, "ire"),
+ UE((short)2, "ue"),
+ TE((short)3, "te");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ 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: // IRE
+ return IRE;
+ case 2: // UE
+ return UE;
+ case 3: // TE
+ return TE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
[... 6252 lines stripped ...]