Skip to content
Fetching contributors…
Cannot retrieve contributors at this time
12030 lines (11033 sloc) 325 KB
/**
* Autogenerated by Thrift Compiler (0.8.0)
*
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
* @generated
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using Thrift;
using Thrift.Collections;
using Thrift.Protocol;
using Thrift.Transport;
namespace Apache.Cassandra
{
public class Cassandra {
public interface Iface {
void login(AuthenticationRequest auth_request);
void set_keyspace(string keyspace);
ColumnOrSuperColumn get(byte[] key, ColumnPath column_path, ConsistencyLevel consistency_level);
List<ColumnOrSuperColumn> get_slice(byte[] key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level);
int get_count(byte[] key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level);
Dictionary<byte[], List<ColumnOrSuperColumn>> multiget_slice(List<byte[]> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level);
Dictionary<byte[], int> multiget_count(List<byte[]> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level);
List<KeySlice> get_range_slices(ColumnParent column_parent, SlicePredicate predicate, KeyRange range, ConsistencyLevel consistency_level);
List<KeySlice> get_paged_slice(string column_family, KeyRange range, byte[] start_column, ConsistencyLevel consistency_level);
List<KeySlice> get_indexed_slices(ColumnParent column_parent, IndexClause index_clause, SlicePredicate column_predicate, ConsistencyLevel consistency_level);
void insert(byte[] key, ColumnParent column_parent, Column column, ConsistencyLevel consistency_level);
void add(byte[] key, ColumnParent column_parent, CounterColumn column, ConsistencyLevel consistency_level);
void remove(byte[] key, ColumnPath column_path, long timestamp, ConsistencyLevel consistency_level);
void remove_counter(byte[] key, ColumnPath path, ConsistencyLevel consistency_level);
void batch_mutate(Dictionary<byte[], Dictionary<string, List<Mutation>>> mutation_map, ConsistencyLevel consistency_level);
void truncate(string cfname);
Dictionary<string, List<string>> describe_schema_versions();
List<KsDef> describe_keyspaces();
string describe_cluster_name();
string describe_version();
List<TokenRange> describe_ring(string keyspace);
Dictionary<string, string> describe_token_map();
string describe_partitioner();
string describe_snitch();
KsDef describe_keyspace(string keyspace);
List<string> describe_splits(string cfName, string start_token, string end_token, int keys_per_split);
string system_add_column_family(CfDef cf_def);
string system_drop_column_family(string column_family);
string system_add_keyspace(KsDef ks_def);
string system_drop_keyspace(string keyspace);
string system_update_keyspace(KsDef ks_def);
string system_update_column_family(CfDef cf_def);
CqlResult execute_cql_query(byte[] query, Compression compression);
CqlPreparedResult prepare_cql_query(byte[] query, Compression compression);
CqlResult execute_prepared_cql_query(int itemId, List<byte[]> values);
void set_cql_version(string version);
}
public class Client : Iface {
public Client(TProtocol prot) : this(prot, prot)
{
}
public Client(TProtocol iprot, TProtocol oprot)
{
iprot_ = iprot;
oprot_ = oprot;
}
protected TProtocol iprot_;
protected TProtocol oprot_;
protected int seqid_;
public TProtocol InputProtocol
{
get { return iprot_; }
}
public TProtocol OutputProtocol
{
get { return oprot_; }
}
public void login(AuthenticationRequest auth_request)
{
send_login(auth_request);
recv_login();
}
public void send_login(AuthenticationRequest auth_request)
{
oprot_.WriteMessageBegin(new TMessage("login", TMessageType.Call, seqid_));
login_args args = new login_args();
args.Auth_request = auth_request;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public void recv_login()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
login_result result = new login_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.authnx) {
throw result.Authnx;
}
if (result.__isset.authzx) {
throw result.Authzx;
}
return;
}
public void set_keyspace(string keyspace)
{
send_set_keyspace(keyspace);
recv_set_keyspace();
}
public void send_set_keyspace(string keyspace)
{
oprot_.WriteMessageBegin(new TMessage("set_keyspace", TMessageType.Call, seqid_));
set_keyspace_args args = new set_keyspace_args();
args.Keyspace = keyspace;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public void recv_set_keyspace()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
set_keyspace_result result = new set_keyspace_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.ire) {
throw result.Ire;
}
return;
}
public ColumnOrSuperColumn get(byte[] key, ColumnPath column_path, ConsistencyLevel consistency_level)
{
send_get(key, column_path, consistency_level);
return recv_get();
}
public void send_get(byte[] key, ColumnPath column_path, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("get", TMessageType.Call, seqid_));
get_args args = new get_args();
args.Key = key;
args.Column_path = column_path;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public ColumnOrSuperColumn recv_get()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
get_result result = new get_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.nfe) {
throw result.Nfe;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get failed: unknown result");
}
public List<ColumnOrSuperColumn> get_slice(byte[] key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level)
{
send_get_slice(key, column_parent, predicate, consistency_level);
return recv_get_slice();
}
public void send_get_slice(byte[] key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("get_slice", TMessageType.Call, seqid_));
get_slice_args args = new get_slice_args();
args.Key = key;
args.Column_parent = column_parent;
args.Predicate = predicate;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public List<ColumnOrSuperColumn> recv_get_slice()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
get_slice_result result = new get_slice_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get_slice failed: unknown result");
}
public int get_count(byte[] key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level)
{
send_get_count(key, column_parent, predicate, consistency_level);
return recv_get_count();
}
public void send_get_count(byte[] key, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("get_count", TMessageType.Call, seqid_));
get_count_args args = new get_count_args();
args.Key = key;
args.Column_parent = column_parent;
args.Predicate = predicate;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public int recv_get_count()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
get_count_result result = new get_count_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get_count failed: unknown result");
}
public Dictionary<byte[], List<ColumnOrSuperColumn>> multiget_slice(List<byte[]> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level)
{
send_multiget_slice(keys, column_parent, predicate, consistency_level);
return recv_multiget_slice();
}
public void send_multiget_slice(List<byte[]> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("multiget_slice", TMessageType.Call, seqid_));
multiget_slice_args args = new multiget_slice_args();
args.Keys = keys;
args.Column_parent = column_parent;
args.Predicate = predicate;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public Dictionary<byte[], List<ColumnOrSuperColumn>> recv_multiget_slice()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
multiget_slice_result result = new multiget_slice_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "multiget_slice failed: unknown result");
}
public Dictionary<byte[], int> multiget_count(List<byte[]> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level)
{
send_multiget_count(keys, column_parent, predicate, consistency_level);
return recv_multiget_count();
}
public void send_multiget_count(List<byte[]> keys, ColumnParent column_parent, SlicePredicate predicate, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("multiget_count", TMessageType.Call, seqid_));
multiget_count_args args = new multiget_count_args();
args.Keys = keys;
args.Column_parent = column_parent;
args.Predicate = predicate;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public Dictionary<byte[], int> recv_multiget_count()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
multiget_count_result result = new multiget_count_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "multiget_count failed: unknown result");
}
public List<KeySlice> get_range_slices(ColumnParent column_parent, SlicePredicate predicate, KeyRange range, ConsistencyLevel consistency_level)
{
send_get_range_slices(column_parent, predicate, range, consistency_level);
return recv_get_range_slices();
}
public void send_get_range_slices(ColumnParent column_parent, SlicePredicate predicate, KeyRange range, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("get_range_slices", TMessageType.Call, seqid_));
get_range_slices_args args = new get_range_slices_args();
args.Column_parent = column_parent;
args.Predicate = predicate;
args.Range = range;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public List<KeySlice> recv_get_range_slices()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
get_range_slices_result result = new get_range_slices_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get_range_slices failed: unknown result");
}
public List<KeySlice> get_paged_slice(string column_family, KeyRange range, byte[] start_column, ConsistencyLevel consistency_level)
{
send_get_paged_slice(column_family, range, start_column, consistency_level);
return recv_get_paged_slice();
}
public void send_get_paged_slice(string column_family, KeyRange range, byte[] start_column, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("get_paged_slice", TMessageType.Call, seqid_));
get_paged_slice_args args = new get_paged_slice_args();
args.Column_family = column_family;
args.Range = range;
args.Start_column = start_column;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public List<KeySlice> recv_get_paged_slice()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
get_paged_slice_result result = new get_paged_slice_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get_paged_slice failed: unknown result");
}
public List<KeySlice> get_indexed_slices(ColumnParent column_parent, IndexClause index_clause, SlicePredicate column_predicate, ConsistencyLevel consistency_level)
{
send_get_indexed_slices(column_parent, index_clause, column_predicate, consistency_level);
return recv_get_indexed_slices();
}
public void send_get_indexed_slices(ColumnParent column_parent, IndexClause index_clause, SlicePredicate column_predicate, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("get_indexed_slices", TMessageType.Call, seqid_));
get_indexed_slices_args args = new get_indexed_slices_args();
args.Column_parent = column_parent;
args.Index_clause = index_clause;
args.Column_predicate = column_predicate;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public List<KeySlice> recv_get_indexed_slices()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
get_indexed_slices_result result = new get_indexed_slices_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "get_indexed_slices failed: unknown result");
}
public void insert(byte[] key, ColumnParent column_parent, Column column, ConsistencyLevel consistency_level)
{
send_insert(key, column_parent, column, consistency_level);
recv_insert();
}
public void send_insert(byte[] key, ColumnParent column_parent, Column column, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("insert", TMessageType.Call, seqid_));
insert_args args = new insert_args();
args.Key = key;
args.Column_parent = column_parent;
args.Column = column;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public void recv_insert()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
insert_result result = new insert_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
return;
}
public void add(byte[] key, ColumnParent column_parent, CounterColumn column, ConsistencyLevel consistency_level)
{
send_add(key, column_parent, column, consistency_level);
recv_add();
}
public void send_add(byte[] key, ColumnParent column_parent, CounterColumn column, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("add", TMessageType.Call, seqid_));
add_args args = new add_args();
args.Key = key;
args.Column_parent = column_parent;
args.Column = column;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public void recv_add()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
add_result result = new add_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
return;
}
public void remove(byte[] key, ColumnPath column_path, long timestamp, ConsistencyLevel consistency_level)
{
send_remove(key, column_path, timestamp, consistency_level);
recv_remove();
}
public void send_remove(byte[] key, ColumnPath column_path, long timestamp, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("remove", TMessageType.Call, seqid_));
remove_args args = new remove_args();
args.Key = key;
args.Column_path = column_path;
args.Timestamp = timestamp;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public void recv_remove()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
remove_result result = new remove_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
return;
}
public void remove_counter(byte[] key, ColumnPath path, ConsistencyLevel consistency_level)
{
send_remove_counter(key, path, consistency_level);
recv_remove_counter();
}
public void send_remove_counter(byte[] key, ColumnPath path, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("remove_counter", TMessageType.Call, seqid_));
remove_counter_args args = new remove_counter_args();
args.Key = key;
args.Path = path;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public void recv_remove_counter()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
remove_counter_result result = new remove_counter_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
return;
}
public void batch_mutate(Dictionary<byte[], Dictionary<string, List<Mutation>>> mutation_map, ConsistencyLevel consistency_level)
{
send_batch_mutate(mutation_map, consistency_level);
recv_batch_mutate();
}
public void send_batch_mutate(Dictionary<byte[], Dictionary<string, List<Mutation>>> mutation_map, ConsistencyLevel consistency_level)
{
oprot_.WriteMessageBegin(new TMessage("batch_mutate", TMessageType.Call, seqid_));
batch_mutate_args args = new batch_mutate_args();
args.Mutation_map = mutation_map;
args.Consistency_level = consistency_level;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public void recv_batch_mutate()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
batch_mutate_result result = new batch_mutate_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
return;
}
public void truncate(string cfname)
{
send_truncate(cfname);
recv_truncate();
}
public void send_truncate(string cfname)
{
oprot_.WriteMessageBegin(new TMessage("truncate", TMessageType.Call, seqid_));
truncate_args args = new truncate_args();
args.Cfname = cfname;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public void recv_truncate()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
truncate_result result = new truncate_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
return;
}
public Dictionary<string, List<string>> describe_schema_versions()
{
send_describe_schema_versions();
return recv_describe_schema_versions();
}
public void send_describe_schema_versions()
{
oprot_.WriteMessageBegin(new TMessage("describe_schema_versions", TMessageType.Call, seqid_));
describe_schema_versions_args args = new describe_schema_versions_args();
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public Dictionary<string, List<string>> recv_describe_schema_versions()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_schema_versions_result result = new describe_schema_versions_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_schema_versions failed: unknown result");
}
public List<KsDef> describe_keyspaces()
{
send_describe_keyspaces();
return recv_describe_keyspaces();
}
public void send_describe_keyspaces()
{
oprot_.WriteMessageBegin(new TMessage("describe_keyspaces", TMessageType.Call, seqid_));
describe_keyspaces_args args = new describe_keyspaces_args();
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public List<KsDef> recv_describe_keyspaces()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_keyspaces_result result = new describe_keyspaces_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_keyspaces failed: unknown result");
}
public string describe_cluster_name()
{
send_describe_cluster_name();
return recv_describe_cluster_name();
}
public void send_describe_cluster_name()
{
oprot_.WriteMessageBegin(new TMessage("describe_cluster_name", TMessageType.Call, seqid_));
describe_cluster_name_args args = new describe_cluster_name_args();
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_describe_cluster_name()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_cluster_name_result result = new describe_cluster_name_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_cluster_name failed: unknown result");
}
public string describe_version()
{
send_describe_version();
return recv_describe_version();
}
public void send_describe_version()
{
oprot_.WriteMessageBegin(new TMessage("describe_version", TMessageType.Call, seqid_));
describe_version_args args = new describe_version_args();
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_describe_version()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_version_result result = new describe_version_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_version failed: unknown result");
}
public List<TokenRange> describe_ring(string keyspace)
{
send_describe_ring(keyspace);
return recv_describe_ring();
}
public void send_describe_ring(string keyspace)
{
oprot_.WriteMessageBegin(new TMessage("describe_ring", TMessageType.Call, seqid_));
describe_ring_args args = new describe_ring_args();
args.Keyspace = keyspace;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public List<TokenRange> recv_describe_ring()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_ring_result result = new describe_ring_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_ring failed: unknown result");
}
public Dictionary<string, string> describe_token_map()
{
send_describe_token_map();
return recv_describe_token_map();
}
public void send_describe_token_map()
{
oprot_.WriteMessageBegin(new TMessage("describe_token_map", TMessageType.Call, seqid_));
describe_token_map_args args = new describe_token_map_args();
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public Dictionary<string, string> recv_describe_token_map()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_token_map_result result = new describe_token_map_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_token_map failed: unknown result");
}
public string describe_partitioner()
{
send_describe_partitioner();
return recv_describe_partitioner();
}
public void send_describe_partitioner()
{
oprot_.WriteMessageBegin(new TMessage("describe_partitioner", TMessageType.Call, seqid_));
describe_partitioner_args args = new describe_partitioner_args();
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_describe_partitioner()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_partitioner_result result = new describe_partitioner_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_partitioner failed: unknown result");
}
public string describe_snitch()
{
send_describe_snitch();
return recv_describe_snitch();
}
public void send_describe_snitch()
{
oprot_.WriteMessageBegin(new TMessage("describe_snitch", TMessageType.Call, seqid_));
describe_snitch_args args = new describe_snitch_args();
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_describe_snitch()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_snitch_result result = new describe_snitch_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_snitch failed: unknown result");
}
public KsDef describe_keyspace(string keyspace)
{
send_describe_keyspace(keyspace);
return recv_describe_keyspace();
}
public void send_describe_keyspace(string keyspace)
{
oprot_.WriteMessageBegin(new TMessage("describe_keyspace", TMessageType.Call, seqid_));
describe_keyspace_args args = new describe_keyspace_args();
args.Keyspace = keyspace;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public KsDef recv_describe_keyspace()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_keyspace_result result = new describe_keyspace_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.nfe) {
throw result.Nfe;
}
if (result.__isset.ire) {
throw result.Ire;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_keyspace failed: unknown result");
}
public List<string> describe_splits(string cfName, string start_token, string end_token, int keys_per_split)
{
send_describe_splits(cfName, start_token, end_token, keys_per_split);
return recv_describe_splits();
}
public void send_describe_splits(string cfName, string start_token, string end_token, int keys_per_split)
{
oprot_.WriteMessageBegin(new TMessage("describe_splits", TMessageType.Call, seqid_));
describe_splits_args args = new describe_splits_args();
args.CfName = cfName;
args.Start_token = start_token;
args.End_token = end_token;
args.Keys_per_split = keys_per_split;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public List<string> recv_describe_splits()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
describe_splits_result result = new describe_splits_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "describe_splits failed: unknown result");
}
public string system_add_column_family(CfDef cf_def)
{
send_system_add_column_family(cf_def);
return recv_system_add_column_family();
}
public void send_system_add_column_family(CfDef cf_def)
{
oprot_.WriteMessageBegin(new TMessage("system_add_column_family", TMessageType.Call, seqid_));
system_add_column_family_args args = new system_add_column_family_args();
args.Cf_def = cf_def;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_system_add_column_family()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
system_add_column_family_result result = new system_add_column_family_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.sde) {
throw result.Sde;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_add_column_family failed: unknown result");
}
public string system_drop_column_family(string column_family)
{
send_system_drop_column_family(column_family);
return recv_system_drop_column_family();
}
public void send_system_drop_column_family(string column_family)
{
oprot_.WriteMessageBegin(new TMessage("system_drop_column_family", TMessageType.Call, seqid_));
system_drop_column_family_args args = new system_drop_column_family_args();
args.Column_family = column_family;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_system_drop_column_family()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
system_drop_column_family_result result = new system_drop_column_family_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.sde) {
throw result.Sde;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_drop_column_family failed: unknown result");
}
public string system_add_keyspace(KsDef ks_def)
{
send_system_add_keyspace(ks_def);
return recv_system_add_keyspace();
}
public void send_system_add_keyspace(KsDef ks_def)
{
oprot_.WriteMessageBegin(new TMessage("system_add_keyspace", TMessageType.Call, seqid_));
system_add_keyspace_args args = new system_add_keyspace_args();
args.Ks_def = ks_def;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_system_add_keyspace()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
system_add_keyspace_result result = new system_add_keyspace_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.sde) {
throw result.Sde;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_add_keyspace failed: unknown result");
}
public string system_drop_keyspace(string keyspace)
{
send_system_drop_keyspace(keyspace);
return recv_system_drop_keyspace();
}
public void send_system_drop_keyspace(string keyspace)
{
oprot_.WriteMessageBegin(new TMessage("system_drop_keyspace", TMessageType.Call, seqid_));
system_drop_keyspace_args args = new system_drop_keyspace_args();
args.Keyspace = keyspace;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_system_drop_keyspace()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
system_drop_keyspace_result result = new system_drop_keyspace_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.sde) {
throw result.Sde;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_drop_keyspace failed: unknown result");
}
public string system_update_keyspace(KsDef ks_def)
{
send_system_update_keyspace(ks_def);
return recv_system_update_keyspace();
}
public void send_system_update_keyspace(KsDef ks_def)
{
oprot_.WriteMessageBegin(new TMessage("system_update_keyspace", TMessageType.Call, seqid_));
system_update_keyspace_args args = new system_update_keyspace_args();
args.Ks_def = ks_def;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_system_update_keyspace()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
system_update_keyspace_result result = new system_update_keyspace_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.sde) {
throw result.Sde;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_update_keyspace failed: unknown result");
}
public string system_update_column_family(CfDef cf_def)
{
send_system_update_column_family(cf_def);
return recv_system_update_column_family();
}
public void send_system_update_column_family(CfDef cf_def)
{
oprot_.WriteMessageBegin(new TMessage("system_update_column_family", TMessageType.Call, seqid_));
system_update_column_family_args args = new system_update_column_family_args();
args.Cf_def = cf_def;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public string recv_system_update_column_family()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
system_update_column_family_result result = new system_update_column_family_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.sde) {
throw result.Sde;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_update_column_family failed: unknown result");
}
public CqlResult execute_cql_query(byte[] query, Compression compression)
{
send_execute_cql_query(query, compression);
return recv_execute_cql_query();
}
public void send_execute_cql_query(byte[] query, Compression compression)
{
oprot_.WriteMessageBegin(new TMessage("execute_cql_query", TMessageType.Call, seqid_));
execute_cql_query_args args = new execute_cql_query_args();
args.Query = query;
args.Compression = compression;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public CqlResult recv_execute_cql_query()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
execute_cql_query_result result = new execute_cql_query_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
if (result.__isset.sde) {
throw result.Sde;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "execute_cql_query failed: unknown result");
}
public CqlPreparedResult prepare_cql_query(byte[] query, Compression compression)
{
send_prepare_cql_query(query, compression);
return recv_prepare_cql_query();
}
public void send_prepare_cql_query(byte[] query, Compression compression)
{
oprot_.WriteMessageBegin(new TMessage("prepare_cql_query", TMessageType.Call, seqid_));
prepare_cql_query_args args = new prepare_cql_query_args();
args.Query = query;
args.Compression = compression;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public CqlPreparedResult recv_prepare_cql_query()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
prepare_cql_query_result result = new prepare_cql_query_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "prepare_cql_query failed: unknown result");
}
public CqlResult execute_prepared_cql_query(int itemId, List<byte[]> values)
{
send_execute_prepared_cql_query(itemId, values);
return recv_execute_prepared_cql_query();
}
public void send_execute_prepared_cql_query(int itemId, List<byte[]> values)
{
oprot_.WriteMessageBegin(new TMessage("execute_prepared_cql_query", TMessageType.Call, seqid_));
execute_prepared_cql_query_args args = new execute_prepared_cql_query_args();
args.ItemId = itemId;
args.Values = values;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public CqlResult recv_execute_prepared_cql_query()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
execute_prepared_cql_query_result result = new execute_prepared_cql_query_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success) {
return result.Success;
}
if (result.__isset.ire) {
throw result.Ire;
}
if (result.__isset.ue) {
throw result.Ue;
}
if (result.__isset.te) {
throw result.Te;
}
if (result.__isset.sde) {
throw result.Sde;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "execute_prepared_cql_query failed: unknown result");
}
public void set_cql_version(string version)
{
send_set_cql_version(version);
recv_set_cql_version();
}
public void send_set_cql_version(string version)
{
oprot_.WriteMessageBegin(new TMessage("set_cql_version", TMessageType.Call, seqid_));
set_cql_version_args args = new set_cql_version_args();
args.Version = version;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public void recv_set_cql_version()
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception) {
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
set_cql_version_result result = new set_cql_version_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.ire) {
throw result.Ire;
}
return;
}
}
public class Processor : TProcessor {
public Processor(Iface iface)
{
iface_ = iface;
processMap_["login"] = login_Process;
processMap_["set_keyspace"] = set_keyspace_Process;
processMap_["get"] = get_Process;
processMap_["get_slice"] = get_slice_Process;
processMap_["get_count"] = get_count_Process;
processMap_["multiget_slice"] = multiget_slice_Process;
processMap_["multiget_count"] = multiget_count_Process;
processMap_["get_range_slices"] = get_range_slices_Process;
processMap_["get_paged_slice"] = get_paged_slice_Process;
processMap_["get_indexed_slices"] = get_indexed_slices_Process;
processMap_["insert"] = insert_Process;
processMap_["add"] = add_Process;
processMap_["remove"] = remove_Process;
processMap_["remove_counter"] = remove_counter_Process;
processMap_["batch_mutate"] = batch_mutate_Process;
processMap_["truncate"] = truncate_Process;
processMap_["describe_schema_versions"] = describe_schema_versions_Process;
processMap_["describe_keyspaces"] = describe_keyspaces_Process;
processMap_["describe_cluster_name"] = describe_cluster_name_Process;
processMap_["describe_version"] = describe_version_Process;
processMap_["describe_ring"] = describe_ring_Process;
processMap_["describe_token_map"] = describe_token_map_Process;
processMap_["describe_partitioner"] = describe_partitioner_Process;
processMap_["describe_snitch"] = describe_snitch_Process;
processMap_["describe_keyspace"] = describe_keyspace_Process;
processMap_["describe_splits"] = describe_splits_Process;
processMap_["system_add_column_family"] = system_add_column_family_Process;
processMap_["system_drop_column_family"] = system_drop_column_family_Process;
processMap_["system_add_keyspace"] = system_add_keyspace_Process;
processMap_["system_drop_keyspace"] = system_drop_keyspace_Process;
processMap_["system_update_keyspace"] = system_update_keyspace_Process;
processMap_["system_update_column_family"] = system_update_column_family_Process;
processMap_["execute_cql_query"] = execute_cql_query_Process;
processMap_["prepare_cql_query"] = prepare_cql_query_Process;
processMap_["execute_prepared_cql_query"] = execute_prepared_cql_query_Process;
processMap_["set_cql_version"] = set_cql_version_Process;
}
protected delegate void ProcessFunction(int seqid, TProtocol iprot, TProtocol oprot);
private Iface iface_;
protected Dictionary<string, ProcessFunction> processMap_ = new Dictionary<string, ProcessFunction>();
public bool Process(TProtocol iprot, TProtocol oprot)
{
try
{
TMessage msg = iprot.ReadMessageBegin();
ProcessFunction fn;
processMap_.TryGetValue(msg.Name, out fn);
if (fn == null) {
TProtocolUtil.Skip(iprot, TType.Struct);
iprot.ReadMessageEnd();
TApplicationException x = new TApplicationException (TApplicationException.ExceptionType.UnknownMethod, "Invalid method name: '" + msg.Name + "'");
oprot.WriteMessageBegin(new TMessage(msg.Name, TMessageType.Exception, msg.SeqID));
x.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
return true;
}
fn(msg.SeqID, iprot, oprot);
}
catch (IOException)
{
return false;
}
return true;
}
public void login_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
login_args args = new login_args();
args.Read(iprot);
iprot.ReadMessageEnd();
login_result result = new login_result();
try {
iface_.login(args.Auth_request);
} catch (AuthenticationException authnx) {
result.Authnx = authnx;
} catch (AuthorizationException authzx) {
result.Authzx = authzx;
}
oprot.WriteMessageBegin(new TMessage("login", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void set_keyspace_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
set_keyspace_args args = new set_keyspace_args();
args.Read(iprot);
iprot.ReadMessageEnd();
set_keyspace_result result = new set_keyspace_result();
try {
iface_.set_keyspace(args.Keyspace);
} catch (InvalidRequestException ire) {
result.Ire = ire;
}
oprot.WriteMessageBegin(new TMessage("set_keyspace", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void get_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
get_args args = new get_args();
args.Read(iprot);
iprot.ReadMessageEnd();
get_result result = new get_result();
try {
result.Success = iface_.get(args.Key, args.Column_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;
}
oprot.WriteMessageBegin(new TMessage("get", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void get_slice_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
get_slice_args args = new get_slice_args();
args.Read(iprot);
iprot.ReadMessageEnd();
get_slice_result result = new get_slice_result();
try {
result.Success = iface_.get_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;
}
oprot.WriteMessageBegin(new TMessage("get_slice", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void get_count_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
get_count_args args = new get_count_args();
args.Read(iprot);
iprot.ReadMessageEnd();
get_count_result result = new get_count_result();
try {
result.Success = iface_.get_count(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;
}
oprot.WriteMessageBegin(new TMessage("get_count", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void multiget_slice_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
multiget_slice_args args = new multiget_slice_args();
args.Read(iprot);
iprot.ReadMessageEnd();
multiget_slice_result result = new multiget_slice_result();
try {
result.Success = iface_.multiget_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;
}
oprot.WriteMessageBegin(new TMessage("multiget_slice", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void multiget_count_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
multiget_count_args args = new multiget_count_args();
args.Read(iprot);
iprot.ReadMessageEnd();
multiget_count_result result = new multiget_count_result();
try {
result.Success = iface_.multiget_count(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;
}
oprot.WriteMessageBegin(new TMessage("multiget_count", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void get_range_slices_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
get_range_slices_args args = new get_range_slices_args();
args.Read(iprot);
iprot.ReadMessageEnd();
get_range_slices_result result = new get_range_slices_result();
try {
result.Success = iface_.get_range_slices(args.Column_parent, args.Predicate, args.Range, args.Consistency_level);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (UnavailableException ue) {
result.Ue = ue;
} catch (TimedOutException te) {
result.Te = te;
}
oprot.WriteMessageBegin(new TMessage("get_range_slices", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void get_paged_slice_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
get_paged_slice_args args = new get_paged_slice_args();
args.Read(iprot);
iprot.ReadMessageEnd();
get_paged_slice_result result = new get_paged_slice_result();
try {
result.Success = iface_.get_paged_slice(args.Column_family, args.Range, args.Start_column, args.Consistency_level);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (UnavailableException ue) {
result.Ue = ue;
} catch (TimedOutException te) {
result.Te = te;
}
oprot.WriteMessageBegin(new TMessage("get_paged_slice", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void get_indexed_slices_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
get_indexed_slices_args args = new get_indexed_slices_args();
args.Read(iprot);
iprot.ReadMessageEnd();
get_indexed_slices_result result = new get_indexed_slices_result();
try {
result.Success = iface_.get_indexed_slices(args.Column_parent, args.Index_clause, args.Column_predicate, args.Consistency_level);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (UnavailableException ue) {
result.Ue = ue;
} catch (TimedOutException te) {
result.Te = te;
}
oprot.WriteMessageBegin(new TMessage("get_indexed_slices", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void insert_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
insert_args args = new insert_args();
args.Read(iprot);
iprot.ReadMessageEnd();
insert_result result = new insert_result();
try {
iface_.insert(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;
}
oprot.WriteMessageBegin(new TMessage("insert", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void add_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
add_args args = new add_args();
args.Read(iprot);
iprot.ReadMessageEnd();
add_result result = new add_result();
try {
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;
}
oprot.WriteMessageBegin(new TMessage("add", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void remove_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
remove_args args = new remove_args();
args.Read(iprot);
iprot.ReadMessageEnd();
remove_result result = new remove_result();
try {
iface_.remove(args.Key, args.Column_path, args.Timestamp, args.Consistency_level);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (UnavailableException ue) {
result.Ue = ue;
} catch (TimedOutException te) {
result.Te = te;
}
oprot.WriteMessageBegin(new TMessage("remove", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void remove_counter_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
remove_counter_args args = new remove_counter_args();
args.Read(iprot);
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;
}
oprot.WriteMessageBegin(new TMessage("remove_counter", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void batch_mutate_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
batch_mutate_args args = new batch_mutate_args();
args.Read(iprot);
iprot.ReadMessageEnd();
batch_mutate_result result = new batch_mutate_result();
try {
iface_.batch_mutate(args.Mutation_map, args.Consistency_level);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (UnavailableException ue) {
result.Ue = ue;
} catch (TimedOutException te) {
result.Te = te;
}
oprot.WriteMessageBegin(new TMessage("batch_mutate", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void truncate_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
truncate_args args = new truncate_args();
args.Read(iprot);
iprot.ReadMessageEnd();
truncate_result result = new truncate_result();
try {
iface_.truncate(args.Cfname);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (UnavailableException ue) {
result.Ue = ue;
} catch (TimedOutException te) {
result.Te = te;
}
oprot.WriteMessageBegin(new TMessage("truncate", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void describe_schema_versions_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_schema_versions_args args = new describe_schema_versions_args();
args.Read(iprot);
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;
}
oprot.WriteMessageBegin(new TMessage("describe_schema_versions", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void describe_keyspaces_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_keyspaces_args args = new describe_keyspaces_args();
args.Read(iprot);
iprot.ReadMessageEnd();
describe_keyspaces_result result = new describe_keyspaces_result();
try {
result.Success = iface_.describe_keyspaces();
} catch (InvalidRequestException ire) {
result.Ire = ire;
}
oprot.WriteMessageBegin(new TMessage("describe_keyspaces", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void describe_cluster_name_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_cluster_name_args args = new describe_cluster_name_args();
args.Read(iprot);
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.Transport.Flush();
}
public void describe_version_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_version_args args = new describe_version_args();
args.Read(iprot);
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.Transport.Flush();
}
public void describe_ring_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_ring_args args = new describe_ring_args();
args.Read(iprot);
iprot.ReadMessageEnd();
describe_ring_result result = new describe_ring_result();
try {
result.Success = iface_.describe_ring(args.Keyspace);
} catch (InvalidRequestException ire) {
result.Ire = ire;
}
oprot.WriteMessageBegin(new TMessage("describe_ring", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void describe_token_map_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_token_map_args args = new describe_token_map_args();
args.Read(iprot);
iprot.ReadMessageEnd();
describe_token_map_result result = new describe_token_map_result();
try {
result.Success = iface_.describe_token_map();
} catch (InvalidRequestException ire) {
result.Ire = ire;
}
oprot.WriteMessageBegin(new TMessage("describe_token_map", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void describe_partitioner_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_partitioner_args args = new describe_partitioner_args();
args.Read(iprot);
iprot.ReadMessageEnd();
describe_partitioner_result result = new describe_partitioner_result();
result.Success = iface_.describe_partitioner();
oprot.WriteMessageBegin(new TMessage("describe_partitioner", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void describe_snitch_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_snitch_args args = new describe_snitch_args();
args.Read(iprot);
iprot.ReadMessageEnd();
describe_snitch_result result = new describe_snitch_result();
result.Success = iface_.describe_snitch();
oprot.WriteMessageBegin(new TMessage("describe_snitch", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void describe_keyspace_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_keyspace_args args = new describe_keyspace_args();
args.Read(iprot);
iprot.ReadMessageEnd();
describe_keyspace_result result = new describe_keyspace_result();
try {
result.Success = iface_.describe_keyspace(args.Keyspace);
} catch (NotFoundException nfe) {
result.Nfe = nfe;
} catch (InvalidRequestException ire) {
result.Ire = ire;
}
oprot.WriteMessageBegin(new TMessage("describe_keyspace", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void describe_splits_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
describe_splits_args args = new describe_splits_args();
args.Read(iprot);
iprot.ReadMessageEnd();
describe_splits_result result = new describe_splits_result();
try {
result.Success = iface_.describe_splits(args.CfName, args.Start_token, args.End_token, args.Keys_per_split);
} catch (InvalidRequestException ire) {
result.Ire = ire;
}
oprot.WriteMessageBegin(new TMessage("describe_splits", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void system_add_column_family_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
system_add_column_family_args args = new system_add_column_family_args();
args.Read(iprot);
iprot.ReadMessageEnd();
system_add_column_family_result result = new system_add_column_family_result();
try {
result.Success = iface_.system_add_column_family(args.Cf_def);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (SchemaDisagreementException sde) {
result.Sde = sde;
}
oprot.WriteMessageBegin(new TMessage("system_add_column_family", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void system_drop_column_family_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
system_drop_column_family_args args = new system_drop_column_family_args();
args.Read(iprot);
iprot.ReadMessageEnd();
system_drop_column_family_result result = new system_drop_column_family_result();
try {
result.Success = iface_.system_drop_column_family(args.Column_family);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (SchemaDisagreementException sde) {
result.Sde = sde;
}
oprot.WriteMessageBegin(new TMessage("system_drop_column_family", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void system_add_keyspace_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
system_add_keyspace_args args = new system_add_keyspace_args();
args.Read(iprot);
iprot.ReadMessageEnd();
system_add_keyspace_result result = new system_add_keyspace_result();
try {
result.Success = iface_.system_add_keyspace(args.Ks_def);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (SchemaDisagreementException sde) {
result.Sde = sde;
}
oprot.WriteMessageBegin(new TMessage("system_add_keyspace", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void system_drop_keyspace_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
system_drop_keyspace_args args = new system_drop_keyspace_args();
args.Read(iprot);
iprot.ReadMessageEnd();
system_drop_keyspace_result result = new system_drop_keyspace_result();
try {
result.Success = iface_.system_drop_keyspace(args.Keyspace);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (SchemaDisagreementException sde) {
result.Sde = sde;
}
oprot.WriteMessageBegin(new TMessage("system_drop_keyspace", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void system_update_keyspace_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
system_update_keyspace_args args = new system_update_keyspace_args();
args.Read(iprot);
iprot.ReadMessageEnd();
system_update_keyspace_result result = new system_update_keyspace_result();
try {
result.Success = iface_.system_update_keyspace(args.Ks_def);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (SchemaDisagreementException sde) {
result.Sde = sde;
}
oprot.WriteMessageBegin(new TMessage("system_update_keyspace", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void system_update_column_family_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
system_update_column_family_args args = new system_update_column_family_args();
args.Read(iprot);
iprot.ReadMessageEnd();
system_update_column_family_result result = new system_update_column_family_result();
try {
result.Success = iface_.system_update_column_family(args.Cf_def);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (SchemaDisagreementException sde) {
result.Sde = sde;
}
oprot.WriteMessageBegin(new TMessage("system_update_column_family", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void execute_cql_query_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
execute_cql_query_args args = new execute_cql_query_args();
args.Read(iprot);
iprot.ReadMessageEnd();
execute_cql_query_result result = new execute_cql_query_result();
try {
result.Success = iface_.execute_cql_query(args.Query, args.Compression);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (UnavailableException ue) {
result.Ue = ue;
} catch (TimedOutException te) {
result.Te = te;
} catch (SchemaDisagreementException sde) {
result.Sde = sde;
}
oprot.WriteMessageBegin(new TMessage("execute_cql_query", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void prepare_cql_query_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
prepare_cql_query_args args = new prepare_cql_query_args();
args.Read(iprot);
iprot.ReadMessageEnd();
prepare_cql_query_result result = new prepare_cql_query_result();
try {
result.Success = iface_.prepare_cql_query(args.Query, args.Compression);
} catch (InvalidRequestException ire) {
result.Ire = ire;
}
oprot.WriteMessageBegin(new TMessage("prepare_cql_query", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void execute_prepared_cql_query_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
execute_prepared_cql_query_args args = new execute_prepared_cql_query_args();
args.Read(iprot);
iprot.ReadMessageEnd();
execute_prepared_cql_query_result result = new execute_prepared_cql_query_result();
try {
result.Success = iface_.execute_prepared_cql_query(args.ItemId, args.Values);
} catch (InvalidRequestException ire) {
result.Ire = ire;
} catch (UnavailableException ue) {
result.Ue = ue;
} catch (TimedOutException te) {
result.Te = te;
} catch (SchemaDisagreementException sde) {
result.Sde = sde;
}
oprot.WriteMessageBegin(new TMessage("execute_prepared_cql_query", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
public void set_cql_version_Process(int seqid, TProtocol iprot, TProtocol oprot)
{
set_cql_version_args args = new set_cql_version_args();
args.Read(iprot);
iprot.ReadMessageEnd();
set_cql_version_result result = new set_cql_version_result();
try {
iface_.set_cql_version(args.Version);
} catch (InvalidRequestException ire) {
result.Ire = ire;
}
oprot.WriteMessageBegin(new TMessage("set_cql_version", TMessageType.Reply, seqid));
result.Write(oprot);
oprot.WriteMessageEnd();
oprot.Transport.Flush();
}
}
[Serializable]
public partial class login_args : TBase
{
private AuthenticationRequest _auth_request;
public AuthenticationRequest Auth_request
{
get
{
return _auth_request;
}
set
{
__isset.auth_request = true;
this._auth_request = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool auth_request;
}
public login_args() {
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct) {
Auth_request = new AuthenticationRequest();
Auth_request.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("login_args");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (Auth_request != null && __isset.auth_request) {
field.Name = "auth_request";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
Auth_request.Write(oprot);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("login_args(");
sb.Append("Auth_request: ");
sb.Append(Auth_request== null ? "<null>" : Auth_request.ToString());
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class login_result : TBase
{
private AuthenticationException _authnx;
private AuthorizationException _authzx;
public AuthenticationException Authnx
{
get
{
return _authnx;
}
set
{
__isset.authnx = true;
this._authnx = value;
}
}
public AuthorizationException Authzx
{
get
{
return _authzx;
}
set
{
__isset.authzx = true;
this._authzx = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool authnx;
public bool authzx;
}
public login_result() {
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct) {
Authnx = new AuthenticationException();
Authnx.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Authzx = new AuthorizationException();
Authzx.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("login_result");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (this.__isset.authnx) {
if (Authnx != null) {
field.Name = "Authnx";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
Authnx.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.authzx) {
if (Authzx != null) {
field.Name = "Authzx";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
Authzx.Write(oprot);
oprot.WriteFieldEnd();
}
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("login_result(");
sb.Append("Authnx: ");
sb.Append(Authnx== null ? "<null>" : Authnx.ToString());
sb.Append(",Authzx: ");
sb.Append(Authzx== null ? "<null>" : Authzx.ToString());
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class set_keyspace_args : TBase
{
private string _keyspace;
public string Keyspace
{
get
{
return _keyspace;
}
set
{
__isset.keyspace = true;
this._keyspace = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool keyspace;
}
public set_keyspace_args() {
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Keyspace = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("set_keyspace_args");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (Keyspace != null && __isset.keyspace) {
field.Name = "keyspace";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteString(Keyspace);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("set_keyspace_args(");
sb.Append("Keyspace: ");
sb.Append(Keyspace);
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class set_keyspace_result : TBase
{
private InvalidRequestException _ire;
public InvalidRequestException Ire
{
get
{
return _ire;
}
set
{
__isset.ire = true;
this._ire = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool ire;
}
public set_keyspace_result() {
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct) {
Ire = new InvalidRequestException();
Ire.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("set_keyspace_result");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (this.__isset.ire) {
if (Ire != null) {
field.Name = "Ire";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
Ire.Write(oprot);
oprot.WriteFieldEnd();
}
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("set_keyspace_result(");
sb.Append("Ire: ");
sb.Append(Ire== null ? "<null>" : Ire.ToString());
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class get_args : TBase
{
private byte[] _key;
private ColumnPath _column_path;
private ConsistencyLevel _consistency_level;
public byte[] Key
{
get
{
return _key;
}
set
{
__isset.key = true;
this._key = value;
}
}
public ColumnPath Column_path
{
get
{
return _column_path;
}
set
{
__isset.column_path = true;
this._column_path = value;
}
}
public ConsistencyLevel Consistency_level
{
get
{
return _consistency_level;
}
set
{
__isset.consistency_level = true;
this._consistency_level = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool key;
public bool column_path;
public bool consistency_level;
}
public get_args() {
this._consistency_level = (ConsistencyLevel)1;
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Key = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Column_path = new ColumnPath();
Column_path.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("get_args");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (Key != null && __isset.key) {
field.Name = "key";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteBinary(Key);
oprot.WriteFieldEnd();
}
if (Column_path != null && __isset.column_path) {
field.Name = "column_path";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
Column_path.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.consistency_level) {
field.Name = "consistency_level";
field.Type = TType.I32;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteI32((int)Consistency_level);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("get_args(");
sb.Append("Key: ");
sb.Append(Key);
sb.Append(",Column_path: ");
sb.Append(Column_path== null ? "<null>" : Column_path.ToString());
sb.Append(",Consistency_level: ");
sb.Append(Consistency_level);
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class get_result : TBase
{
private ColumnOrSuperColumn _success;
private InvalidRequestException _ire;
private NotFoundException _nfe;
private UnavailableException _ue;
private TimedOutException _te;
public ColumnOrSuperColumn Success
{
get
{
return _success;
}
set
{
__isset.success = true;
this._success = value;
}
}
public InvalidRequestException Ire
{
get
{
return _ire;
}
set
{
__isset.ire = true;
this._ire = value;
}
}
public NotFoundException Nfe
{
get
{
return _nfe;
}
set
{
__isset.nfe = true;
this._nfe = value;
}
}
public UnavailableException Ue
{
get
{
return _ue;
}
set
{
__isset.ue = true;
this._ue = value;
}
}
public TimedOutException Te
{
get
{
return _te;
}
set
{
__isset.te = true;
this._te = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool success;
public bool ire;
public bool nfe;
public bool ue;
public bool te;
}
public get_result() {
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 0:
if (field.Type == TType.Struct) {
Success = new ColumnOrSuperColumn();
Success.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 1:
if (field.Type == TType.Struct) {
Ire = new InvalidRequestException();
Ire.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Nfe = new NotFoundException();
Nfe.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Ue = new UnavailableException();
Ue.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Struct) {
Te = new TimedOutException();
Te.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("get_result");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (this.__isset.success) {
if (Success != null) {
field.Name = "Success";
field.Type = TType.Struct;
field.ID = 0;
oprot.WriteFieldBegin(field);
Success.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.ire) {
if (Ire != null) {
field.Name = "Ire";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
Ire.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.nfe) {
if (Nfe != null) {
field.Name = "Nfe";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
Nfe.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.ue) {
if (Ue != null) {
field.Name = "Ue";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Ue.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.te) {
if (Te != null) {
field.Name = "Te";
field.Type = TType.Struct;
field.ID = 4;
oprot.WriteFieldBegin(field);
Te.Write(oprot);
oprot.WriteFieldEnd();
}
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("get_result(");
sb.Append("Success: ");
sb.Append(Success== null ? "<null>" : Success.ToString());
sb.Append(",Ire: ");
sb.Append(Ire== null ? "<null>" : Ire.ToString());
sb.Append(",Nfe: ");
sb.Append(Nfe== null ? "<null>" : Nfe.ToString());
sb.Append(",Ue: ");
sb.Append(Ue== null ? "<null>" : Ue.ToString());
sb.Append(",Te: ");
sb.Append(Te== null ? "<null>" : Te.ToString());
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class get_slice_args : TBase
{
private byte[] _key;
private ColumnParent _column_parent;
private SlicePredicate _predicate;
private ConsistencyLevel _consistency_level;
public byte[] Key
{
get
{
return _key;
}
set
{
__isset.key = true;
this._key = value;
}
}
public ColumnParent Column_parent
{
get
{
return _column_parent;
}
set
{
__isset.column_parent = true;
this._column_parent = value;
}
}
public SlicePredicate Predicate
{
get
{
return _predicate;
}
set
{
__isset.predicate = true;
this._predicate = value;
}
}
public ConsistencyLevel Consistency_level
{
get
{
return _consistency_level;
}
set
{
__isset.consistency_level = true;
this._consistency_level = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool key;
public bool column_parent;
public bool predicate;
public bool consistency_level;
}
public get_slice_args() {
this._consistency_level = (ConsistencyLevel)1;
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Key = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Column_parent = new ColumnParent();
Column_parent.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Predicate = new SlicePredicate();
Predicate.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("get_slice_args");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (Key != null && __isset.key) {
field.Name = "key";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteBinary(Key);
oprot.WriteFieldEnd();
}
if (Column_parent != null && __isset.column_parent) {
field.Name = "column_parent";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
Column_parent.Write(oprot);
oprot.WriteFieldEnd();
}
if (Predicate != null && __isset.predicate) {
field.Name = "predicate";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Predicate.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.consistency_level) {
field.Name = "consistency_level";
field.Type = TType.I32;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteI32((int)Consistency_level);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("get_slice_args(");
sb.Append("Key: ");
sb.Append(Key);
sb.Append(",Column_parent: ");
sb.Append(Column_parent== null ? "<null>" : Column_parent.ToString());
sb.Append(",Predicate: ");
sb.Append(Predicate== null ? "<null>" : Predicate.ToString());
sb.Append(",Consistency_level: ");
sb.Append(Consistency_level);
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class get_slice_result : TBase
{
private List<ColumnOrSuperColumn> _success;
private InvalidRequestException _ire;
private UnavailableException _ue;
private TimedOutException _te;
public List<ColumnOrSuperColumn> Success
{
get
{
return _success;
}
set
{
__isset.success = true;
this._success = value;
}
}
public InvalidRequestException Ire
{
get
{
return _ire;
}
set
{
__isset.ire = true;
this._ire = value;
}
}
public UnavailableException Ue
{
get
{
return _ue;
}
set
{
__isset.ue = true;
this._ue = value;
}
}
public TimedOutException Te
{
get
{
return _te;
}
set
{
__isset.te = true;
this._te = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool success;
public bool ire;
public bool ue;
public bool te;
}
public get_slice_result() {
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 0:
if (field.Type == TType.List) {
{
Success = new List<ColumnOrSuperColumn>();
TList _list95 = iprot.ReadListBegin();
for( int _i96 = 0; _i96 < _list95.Count; ++_i96)
{
ColumnOrSuperColumn _elem97 = new ColumnOrSuperColumn();
_elem97 = new ColumnOrSuperColumn();
_elem97.Read(iprot);
Success.Add(_elem97);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 1:
if (field.Type == TType.Struct) {
Ire = new InvalidRequestException();
Ire.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Ue = new UnavailableException();
Ue.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Te = new TimedOutException();
Te.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("get_slice_result");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (this.__isset.success) {
if (Success != null) {
field.Name = "Success";
field.Type = TType.List;
field.ID = 0;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, Success.Count));
foreach (ColumnOrSuperColumn _iter98 in Success)
{
_iter98.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
} else if (this.__isset.ire) {
if (Ire != null) {
field.Name = "Ire";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
Ire.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.ue) {
if (Ue != null) {
field.Name = "Ue";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
Ue.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.te) {
if (Te != null) {
field.Name = "Te";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Te.Write(oprot);
oprot.WriteFieldEnd();
}
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("get_slice_result(");
sb.Append("Success: ");
sb.Append(Success);
sb.Append(",Ire: ");
sb.Append(Ire== null ? "<null>" : Ire.ToString());
sb.Append(",Ue: ");
sb.Append(Ue== null ? "<null>" : Ue.ToString());
sb.Append(",Te: ");
sb.Append(Te== null ? "<null>" : Te.ToString());
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class get_count_args : TBase
{
private byte[] _key;
private ColumnParent _column_parent;
private SlicePredicate _predicate;
private ConsistencyLevel _consistency_level;
public byte[] Key
{
get
{
return _key;
}
set
{
__isset.key = true;
this._key = value;
}
}
public ColumnParent Column_parent
{
get
{
return _column_parent;
}
set
{
__isset.column_parent = true;
this._column_parent = value;
}
}
public SlicePredicate Predicate
{
get
{
return _predicate;
}
set
{
__isset.predicate = true;
this._predicate = value;
}
}
public ConsistencyLevel Consistency_level
{
get
{
return _consistency_level;
}
set
{
__isset.consistency_level = true;
this._consistency_level = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool key;
public bool column_parent;
public bool predicate;
public bool consistency_level;
}
public get_count_args() {
this._consistency_level = (ConsistencyLevel)1;
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Key = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Column_parent = new ColumnParent();
Column_parent.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Predicate = new SlicePredicate();
Predicate.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("get_count_args");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (Key != null && __isset.key) {
field.Name = "key";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteBinary(Key);
oprot.WriteFieldEnd();
}
if (Column_parent != null && __isset.column_parent) {
field.Name = "column_parent";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
Column_parent.Write(oprot);
oprot.WriteFieldEnd();
}
if (Predicate != null && __isset.predicate) {
field.Name = "predicate";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Predicate.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.consistency_level) {
field.Name = "consistency_level";
field.Type = TType.I32;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteI32((int)Consistency_level);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("get_count_args(");
sb.Append("Key: ");
sb.Append(Key);
sb.Append(",Column_parent: ");
sb.Append(Column_parent== null ? "<null>" : Column_parent.ToString());
sb.Append(",Predicate: ");
sb.Append(Predicate== null ? "<null>" : Predicate.ToString());
sb.Append(",Consistency_level: ");
sb.Append(Consistency_level);
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class get_count_result : TBase
{
private int _success;
private InvalidRequestException _ire;
private UnavailableException _ue;
private TimedOutException _te;
public int Success
{
get
{
return _success;
}
set
{
__isset.success = true;
this._success = value;
}
}
public InvalidRequestException Ire
{
get
{
return _ire;
}
set
{
__isset.ire = true;
this._ire = value;
}
}
public UnavailableException Ue
{
get
{
return _ue;
}
set
{
__isset.ue = true;
this._ue = value;
}
}
public TimedOutException Te
{
get
{
return _te;
}
set
{
__isset.te = true;
this._te = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool success;
public bool ire;
public bool ue;
public bool te;
}
public get_count_result() {
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 0:
if (field.Type == TType.I32) {
Success = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 1:
if (field.Type == TType.Struct) {
Ire = new InvalidRequestException();
Ire.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Ue = new UnavailableException();
Ue.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Te = new TimedOutException();
Te.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("get_count_result");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (this.__isset.success) {
field.Name = "Success";
field.Type = TType.I32;
field.ID = 0;
oprot.WriteFieldBegin(field);
oprot.WriteI32(Success);
oprot.WriteFieldEnd();
} else if (this.__isset.ire) {
if (Ire != null) {
field.Name = "Ire";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
Ire.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.ue) {
if (Ue != null) {
field.Name = "Ue";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
Ue.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.te) {
if (Te != null) {
field.Name = "Te";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Te.Write(oprot);
oprot.WriteFieldEnd();
}
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("get_count_result(");
sb.Append("Success: ");
sb.Append(Success);
sb.Append(",Ire: ");
sb.Append(Ire== null ? "<null>" : Ire.ToString());
sb.Append(",Ue: ");
sb.Append(Ue== null ? "<null>" : Ue.ToString());
sb.Append(",Te: ");
sb.Append(Te== null ? "<null>" : Te.ToString());
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class multiget_slice_args : TBase
{
private List<byte[]> _keys;
private ColumnParent _column_parent;
private SlicePredicate _predicate;
private ConsistencyLevel _consistency_level;
public List<byte[]> Keys
{
get
{
return _keys;
}
set
{
__isset.keys = true;
this._keys = value;
}
}
public ColumnParent Column_parent
{
get
{
return _column_parent;
}
set
{
__isset.column_parent = true;
this._column_parent = value;
}
}
public SlicePredicate Predicate
{
get
{
return _predicate;
}
set
{
__isset.predicate = true;
this._predicate = value;
}
}
public ConsistencyLevel Consistency_level
{
get
{
return _consistency_level;
}
set
{
__isset.consistency_level = true;
this._consistency_level = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool keys;
public bool column_parent;
public bool predicate;
public bool consistency_level;
}
public multiget_slice_args() {
this._consistency_level = (ConsistencyLevel)1;
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.List) {
{
Keys = new List<byte[]>();
TList _list99 = iprot.ReadListBegin();
for( int _i100 = 0; _i100 < _list99.Count; ++_i100)
{
byte[] _elem101 = null;
_elem101 = iprot.ReadBinary();
Keys.Add(_elem101);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Column_parent = new ColumnParent();
Column_parent.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Predicate = new SlicePredicate();
Predicate.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("multiget_slice_args");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (Keys != null && __isset.keys) {
field.Name = "keys";
field.Type = TType.List;
field.ID = 1;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.String, Keys.Count));
foreach (byte[] _iter102 in Keys)
{
oprot.WriteBinary(_iter102);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (Column_parent != null && __isset.column_parent) {
field.Name = "column_parent";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
Column_parent.Write(oprot);
oprot.WriteFieldEnd();
}
if (Predicate != null && __isset.predicate) {
field.Name = "predicate";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Predicate.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.consistency_level) {
field.Name = "consistency_level";
field.Type = TType.I32;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteI32((int)Consistency_level);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("multiget_slice_args(");
sb.Append("Keys: ");
sb.Append(Keys);
sb.Append(",Column_parent: ");
sb.Append(Column_parent== null ? "<null>" : Column_parent.ToString());
sb.Append(",Predicate: ");
sb.Append(Predicate== null ? "<null>" : Predicate.ToString());
sb.Append(",Consistency_level: ");
sb.Append(Consistency_level);
sb.Append(")");
return sb.ToString();
}
}
[Serializable]
public partial class multiget_slice_result : TBase
{
private Dictionary<byte[], List<ColumnOrSuperColumn>> _success;
private InvalidRequestException _ire;
private UnavailableException _ue;
private TimedOutException _te;
public Dictionary<byte[], List<ColumnOrSuperColumn>> Success
{
get
{
return _success;
}
set
{
__isset.success = true;
this._success = value;
}
}
public InvalidRequestException Ire
{
get
{
return _ire;
}
set
{
__isset.ire = true;
this._ire = value;
}
}
public UnavailableException Ue
{
get
{
return _ue;
}
set
{
__isset.ue = true;
this._ue = value;
}
}
public TimedOutException Te
{
get
{
return _te;
}
set
{
__isset.te = true;
this._te = value;
}
}
public Isset __isset;
[Serializable]
public struct Isset {
public bool success;
public bool ire;
public bool ue;
public bool te;
}
public multiget_slice_result() {
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 0:
if (field.Type == TType.Map) {
{
Success = new Dictionary<byte[], List<ColumnOrSuperColumn>>();
TMap _map103 = iprot.ReadMapBegin();
for( int _i104 = 0; _i104 < _map103.Count; ++_i104)
{
byte[] _key105;
List<ColumnOrSuperColumn> _val106;
_key105 = iprot.ReadBinary();
{
_val106 = new List<ColumnOrSuperColumn>();
TList _list107 = iprot.ReadListBegin();
for( int _i108 = 0; _i108 < _list107.Count; ++_i108)
{
ColumnOrSuperColumn _elem109 = new ColumnOrSuperColumn();
_elem109 = new ColumnOrSuperColumn();
_elem109.Read(iprot);
_val106.Add(_elem109);
}
iprot.ReadListEnd();
}
Success[_key105] = _val106;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 1:
if (field.Type == TType.Struct) {
Ire = new InvalidRequestException();
Ire.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Ue = new UnavailableException();
Ue.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Te = new TimedOutException();
Te.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Write(TProtocol oprot) {
TStruct struc = new TStruct("multiget_slice_result");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (this.__isset.success) {
if (Success != null) {
field.Name = "Success";
field.Type = TType.Map;
field.ID = 0;
oprot.WriteFieldBegin(field);
{
oprot.WriteMapBegin(new TMap(TType.String, TType.List, Success.Count));
foreach (byte[] _iter110 in Success.Keys)
{
oprot.WriteBinary(_iter110);
{
oprot.WriteListBegin(new TList(TType.Struct, Success[_iter110].Count));
foreach (ColumnOrSuperColumn _iter111 in Success[_iter110])
{
_iter111.Write(oprot);
}
oprot.WriteListEnd();
}
}
oprot.WriteMapEnd();
}
oprot.WriteFieldEnd();
}
} else if (this.__isset.ire) {
if (Ire != null) {
field.Name = "Ire";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
Ire.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.ue) {
if (Ue != null) {
field.Name = "Ue";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
Ue.Write(oprot);
oprot.WriteFieldEnd();
}
} else if (this.__isset.te) {
if (Te != null) {
field.Name = "Te";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Te.Write(oprot);
oprot.WriteFieldEnd();
}
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
public override string ToString() {
StringBuilder sb = new StringBuilder("multiget_slice_result(");