Cassandra.cs

/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
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_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 remove(byte[] key, ColumnPath column_path, long timestamp, 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);
      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);
    }

    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_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 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 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;
        }
        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 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;
        }
        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;
        }
        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;
        }
        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;
        }
        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;
        }
        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;
        }
        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;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "system_update_column_family failed: unknown result");
      }

    }
    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_indexed_slices"] = get_indexed_slices_Process;
        processMap_["insert"] = insert_Process;
        processMap_["remove"] = remove_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_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;
      }

      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_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 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 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;
        }
        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_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();
        result.Success = iface_.describe_splits(args.CfName, args.Start_token, args.End_token, args.Keys_per_split);
        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;
        }
        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;
        }
        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;
        }
        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;
        }
        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;
        }
        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;
        }
        oprot.WriteMessageBegin(new TMessage("system_update_column_family", 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 _list38 = iprot.ReadListBegin();
                  for( int _i39 = 0; _i39 < _list38.Count; ++_i39)
                  {
                    ColumnOrSuperColumn _elem40 = new ColumnOrSuperColumn();
                    _elem40 = new ColumnOrSuperColumn();
                    _elem40.Read(iprot);
                    Success.Add(_elem40);
                  }
                  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 _iter41 in Success)
              {
                _iter41.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 _list42 = iprot.ReadListBegin();
                  for( int _i43 = 0; _i43 < _list42.Count; ++_i43)
                  {
                    byte[] _elem44 = null;
                    _elem44 = iprot.ReadBinary();
                    Keys.Add(_elem44);
                  }
                  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[] _iter45 in Keys)
            {
              oprot.WriteBinary(_iter45);
              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 _map46 = iprot.ReadMapBegin();
                  for( int _i47 = 0; _i47 < _map46.Count; ++_i47)
                  {
                    byte[] _key48;
                    List<ColumnOrSuperColumn> _val49;
                    _key48 = iprot.ReadBinary();
                    {
                      _val49 = new List<ColumnOrSuperColumn>();
                      TList _list50 = iprot.ReadListBegin();
                      for( int _i51 = 0; _i51 < _list50.Count; ++_i51)
                      {
                        ColumnOrSuperColumn _elem52 = new ColumnOrSuperColumn();
                        _elem52 = new ColumnOrSuperColumn();
                        _elem52.Read(iprot);
                        _val49.Add(_elem52);
                      }
                      iprot.ReadListEnd();
                    }
                    Success[_key48] = _val49;
                  }
                  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[] _iter53 in Success.Keys)
              {
                oprot.WriteBinary(_iter53);
                {
                  oprot.WriteListBegin(new TList(TType.Struct, Success[_iter53].Count));
                  foreach (ColumnOrSuperColumn _iter54 in Success[_iter53])
                  {
                    _iter54.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(");
        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_count_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_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.List) {
                {
                  Keys = new List<byte[]>();
                  TList _list55 = iprot.ReadListBegin();
                  for( int _i56 = 0; _i56 < _list55.Count; ++_i56)
                  {
                    byte[] _elem57 = null;
                    _elem57 = iprot.ReadBinary();
                    Keys.Add(_elem57);
                  }
                  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_count_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[] _iter58 in Keys)
            {
              oprot.WriteBinary(_iter58);
              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_count_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_count_result : TBase
    {
      private Dictionary<byte[], int> _success;
      private InvalidRequestException _ire;
      private UnavailableException _ue;
      private TimedOutException _te;

      public Dictionary<byte[], 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 multiget_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.Map) {
                {
                  Success = new Dictionary<byte[], int>();
                  TMap _map59 = iprot.ReadMapBegin();
                  for( int _i60 = 0; _i60 < _map59.Count; ++_i60)
                  {
                    byte[] _key61;
                    int _val62;
                    _key61 = iprot.ReadBinary();
                    _val62 = iprot.ReadI32();
                    Success[_key61] = _val62;
                  }
                  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_count_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.I32, Success.Count));
              foreach (byte[] _iter63 in Success.Keys)
              {
                oprot.WriteBinary(_iter63);
                oprot.WriteI32(Success[_iter63]);
                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_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 get_range_slices_args : TBase
    {
      private ColumnParent _column_parent;
      private SlicePredicate _predicate;
      private KeyRange _range;
      private ConsistencyLevel _consistency_level;

      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 KeyRange Range
      {
        get
        {
          return _range;
        }
        set
        {
          __isset.range = true;
          this._range = 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 column_parent;
        public bool predicate;
        public bool range;
        public bool consistency_level;
      }

      public get_range_slices_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.Struct) {
                Column_parent = new ColumnParent();
                Column_parent.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Predicate = new SlicePredicate();
                Predicate.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                Range = new KeyRange();
                Range.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_range_slices_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Column_parent != null && __isset.column_parent) {
          field.Name = "column_parent";
          field.Type = TType.Struct;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          Column_parent.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (Predicate != null && __isset.predicate) {
          field.Name = "predicate";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Predicate.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (Range != null && __isset.range) {
          field.Name = "range";
          field.Type = TType.Struct;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          Range.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_range_slices_args(");
        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(",Range: ");
        sb.Append(Range== null ? "<null>" : Range.ToString());
        sb.Append(",Consistency_level: ");
        sb.Append(Consistency_level);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class get_range_slices_result : TBase
    {
      private List<KeySlice> _success;
      private InvalidRequestException _ire;
      private UnavailableException _ue;
      private TimedOutException _te;

      public List<KeySlice> 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_range_slices_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<KeySlice>();
                  TList _list64 = iprot.ReadListBegin();
                  for( int _i65 = 0; _i65 < _list64.Count; ++_i65)
                  {
                    KeySlice _elem66 = new KeySlice();
                    _elem66 = new KeySlice();
                    _elem66.Read(iprot);
                    Success.Add(_elem66);
                  }
                  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_range_slices_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 (KeySlice _iter67 in Success)
              {
                _iter67.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_range_slices_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_indexed_slices_args : TBase
    {
      private ColumnParent _column_parent;
      private IndexClause _index_clause;
      private SlicePredicate _column_predicate;
      private ConsistencyLevel _consistency_level;

      public ColumnParent Column_parent
      {
        get
        {
          return _column_parent;
        }
        set
        {
          __isset.column_parent = true;
          this._column_parent = value;
        }
      }

      public IndexClause Index_clause
      {
        get
        {
          return _index_clause;
        }
        set
        {
          __isset.index_clause = true;
          this._index_clause = value;
        }
      }

      public SlicePredicate Column_predicate
      {
        get
        {
          return _column_predicate;
        }
        set
        {
          __isset.column_predicate = true;
          this._column_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 column_parent;
        public bool index_clause;
        public bool column_predicate;
        public bool consistency_level;
      }

      public get_indexed_slices_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.Struct) {
                Column_parent = new ColumnParent();
                Column_parent.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Index_clause = new IndexClause();
                Index_clause.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                Column_predicate = new SlicePredicate();
                Column_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_indexed_slices_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Column_parent != null && __isset.column_parent) {
          field.Name = "column_parent";
          field.Type = TType.Struct;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          Column_parent.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (Index_clause != null && __isset.index_clause) {
          field.Name = "index_clause";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Index_clause.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (Column_predicate != null && __isset.column_predicate) {
          field.Name = "column_predicate";
          field.Type = TType.Struct;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          Column_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_indexed_slices_args(");
        sb.Append("Column_parent: ");
        sb.Append(Column_parent== null ? "<null>" : Column_parent.ToString());
        sb.Append(",Index_clause: ");
        sb.Append(Index_clause== null ? "<null>" : Index_clause.ToString());
        sb.Append(",Column_predicate: ");
        sb.Append(Column_predicate== null ? "<null>" : Column_predicate.ToString());
        sb.Append(",Consistency_level: ");
        sb.Append(Consistency_level);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class get_indexed_slices_result : TBase
    {
      private List<KeySlice> _success;
      private InvalidRequestException _ire;
      private UnavailableException _ue;
      private TimedOutException _te;

      public List<KeySlice> 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_indexed_slices_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<KeySlice>();
                  TList _list68 = iprot.ReadListBegin();
                  for( int _i69 = 0; _i69 < _list68.Count; ++_i69)
                  {
                    KeySlice _elem70 = new KeySlice();
                    _elem70 = new KeySlice();
                    _elem70.Read(iprot);
                    Success.Add(_elem70);
                  }
                  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_indexed_slices_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 (KeySlice _iter71 in Success)
              {
                _iter71.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_indexed_slices_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 insert_args : TBase
    {
      private byte[] _key;
      private ColumnParent _column_parent;
      private Column _column;
      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 Column Column
      {
        get
        {
          return _column;
        }
        set
        {
          __isset.column = true;
          this._column = 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 column;
        public bool consistency_level;
      }

      public insert_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) {
                Column = new Column();
                Column.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("insert_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 (Column != null && __isset.column) {
          field.Name = "column";
          field.Type = TType.Struct;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          Column.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("insert_args(");
        sb.Append("Key: ");
        sb.Append(Key);
        sb.Append(",Column_parent: ");
        sb.Append(Column_parent== null ? "<null>" : Column_parent.ToString());
        sb.Append(",Column: ");
        sb.Append(Column== null ? "<null>" : Column.ToString());
        sb.Append(",Consistency_level: ");
        sb.Append(Consistency_level);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class insert_result : TBase
    {
      private InvalidRequestException _ire;
      private UnavailableException _ue;
      private TimedOutException _te;

      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 ire;
        public bool ue;
        public bool te;
      }

      public insert_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;
            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("insert_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();
          }
        } 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("insert_result(");
        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 remove_args : TBase
    {
      private byte[] _key;
      private ColumnPath _column_path;
      private long _timestamp;
      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 long Timestamp
      {
        get
        {
          return _timestamp;
        }
        set
        {
          __isset.timestamp = true;
          this._timestamp = 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 timestamp;
        public bool consistency_level;
      }

      public remove_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.I64) {
                Timestamp = iprot.ReadI64();
              } 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("remove_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.timestamp) {
          field.Name = "timestamp";
          field.Type = TType.I64;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteI64(Timestamp);
          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("remove_args(");
        sb.Append("Key: ");
        sb.Append(Key);
        sb.Append(",Column_path: ");
        sb.Append(Column_path== null ? "<null>" : Column_path.ToString());
        sb.Append(",Timestamp: ");
        sb.Append(Timestamp);
        sb.Append(",Consistency_level: ");
        sb.Append(Consistency_level);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class remove_result : TBase
    {
      private InvalidRequestException _ire;
      private UnavailableException _ue;
      private TimedOutException _te;

      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 ire;
        public bool ue;
        public bool te;
      }

      public remove_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;
            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("remove_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();
          }
        } 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("remove_result(");
        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 batch_mutate_args : TBase
    {
      private Dictionary<byte[], Dictionary<string, List<Mutation>>> _mutation_map;
      private ConsistencyLevel _consistency_level;

      public Dictionary<byte[], Dictionary<string, List<Mutation>>> Mutation_map
      {
        get
        {
          return _mutation_map;
        }
        set
        {
          __isset.mutation_map = true;
          this._mutation_map = 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 mutation_map;
        public bool consistency_level;
      }

      public batch_mutate_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.Map) {
                {
                  Mutation_map = new Dictionary<byte[], Dictionary<string, List<Mutation>>>();
                  TMap _map72 = iprot.ReadMapBegin();
                  for( int _i73 = 0; _i73 < _map72.Count; ++_i73)
                  {
                    byte[] _key74;
                    Dictionary<string, List<Mutation>> _val75;
                    _key74 = iprot.ReadBinary();
                    {
                      _val75 = new Dictionary<string, List<Mutation>>();
                      TMap _map76 = iprot.ReadMapBegin();
                      for( int _i77 = 0; _i77 < _map76.Count; ++_i77)
                      {
                        string _key78;
                        List<Mutation> _val79;
                        _key78 = iprot.ReadString();
                        {
                          _val79 = new List<Mutation>();
                          TList _list80 = iprot.ReadListBegin();
                          for( int _i81 = 0; _i81 < _list80.Count; ++_i81)
                          {
                            Mutation _elem82 = new Mutation();
                            _elem82 = new Mutation();
                            _elem82.Read(iprot);
                            _val79.Add(_elem82);
                          }
                          iprot.ReadListEnd();
                        }
                        _val75[_key78] = _val79;
                      }
                      iprot.ReadMapEnd();
                    }
                    Mutation_map[_key74] = _val75;
                  }
                  iprot.ReadMapEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              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("batch_mutate_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Mutation_map != null && __isset.mutation_map) {
          field.Name = "mutation_map";
          field.Type = TType.Map;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          {
            oprot.WriteMapBegin(new TMap(TType.String, TType.Map, Mutation_map.Count));
            foreach (byte[] _iter83 in Mutation_map.Keys)
            {
              oprot.WriteBinary(_iter83);
              {
                oprot.WriteMapBegin(new TMap(TType.String, TType.List, Mutation_map[_iter83].Count));
                foreach (string _iter84 in Mutation_map[_iter83].Keys)
                {
                  oprot.WriteString(_iter84);
                  {
                    oprot.WriteListBegin(new TList(TType.Struct, Mutation_map[_iter83][_iter84].Count));
                    foreach (Mutation _iter85 in Mutation_map[_iter83][_iter84])
                    {
                      _iter85.Write(oprot);
                      oprot.WriteListEnd();
                    }
                  }
                  oprot.WriteMapEnd();
                }
              }
              oprot.WriteMapEnd();
            }
          }
          oprot.WriteFieldEnd();
        }
        if (__isset.consistency_level) {
          field.Name = "consistency_level";
          field.Type = TType.I32;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32((int)Consistency_level);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("batch_mutate_args(");
        sb.Append("Mutation_map: ");
        sb.Append(Mutation_map);
        sb.Append(",Consistency_level: ");
        sb.Append(Consistency_level);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class batch_mutate_result : TBase
    {
      private InvalidRequestException _ire;
      private UnavailableException _ue;
      private TimedOutException _te;

      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 ire;
        public bool ue;
        public bool te;
      }

      public batch_mutate_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;
            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("batch_mutate_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();
          }
        } 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("batch_mutate_result(");
        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 truncate_args : TBase
    {
      private string _cfname;

      public string Cfname
      {
        get
        {
          return _cfname;
        }
        set
        {
          __isset.cfname = true;
          this._cfname = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool cfname;
      }

      public truncate_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) {
                Cfname = 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("truncate_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Cfname != null && __isset.cfname) {
          field.Name = "cfname";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Cfname);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("truncate_args(");
        sb.Append("Cfname: ");
        sb.Append(Cfname);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class truncate_result : TBase
    {
      private InvalidRequestException _ire;
      private UnavailableException _ue;

      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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool ire;
        public bool ue;
      }

      public truncate_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;
            case 2:
              if (field.Type == TType.Struct) {
                Ue = new UnavailableException();
                Ue.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("truncate_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();
          }
        } 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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("truncate_result(");
        sb.Append("Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(",Ue: ");
        sb.Append(Ue== null ? "<null>" : Ue.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_schema_versions_args : TBase
    {

      public describe_schema_versions_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("describe_schema_versions_args");
        oprot.WriteStructBegin(struc);
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_schema_versions_args(");
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_schema_versions_result : TBase
    {
      private Dictionary<string, List<string>> _success;
      private InvalidRequestException _ire;

      public Dictionary<string, List<string>> 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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool ire;
      }

      public describe_schema_versions_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<string, List<string>>();
                  TMap _map86 = iprot.ReadMapBegin();
                  for( int _i87 = 0; _i87 < _map86.Count; ++_i87)
                  {
                    string _key88;
                    List<string> _val89;
                    _key88 = iprot.ReadString();
                    {
                      _val89 = new List<string>();
                      TList _list90 = iprot.ReadListBegin();
                      for( int _i91 = 0; _i91 < _list90.Count; ++_i91)
                      {
                        string _elem92 = null;
                        _elem92 = iprot.ReadString();
                        _val89.Add(_elem92);
                      }
                      iprot.ReadListEnd();
                    }
                    Success[_key88] = _val89;
                  }
                  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;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("describe_schema_versions_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 (string _iter93 in Success.Keys)
              {
                oprot.WriteString(_iter93);
                {
                  oprot.WriteListBegin(new TList(TType.String, Success[_iter93].Count));
                  foreach (string _iter94 in Success[_iter93])
                  {
                    oprot.WriteString(_iter94);
                    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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_schema_versions_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_keyspaces_args : TBase
    {

      public describe_keyspaces_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("describe_keyspaces_args");
        oprot.WriteStructBegin(struc);
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_keyspaces_args(");
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_keyspaces_result : TBase
    {
      private List<KsDef> _success;
      private InvalidRequestException _ire;

      public List<KsDef> 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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool ire;
      }

      public describe_keyspaces_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<KsDef>();
                  TList _list95 = iprot.ReadListBegin();
                  for( int _i96 = 0; _i96 < _list95.Count; ++_i96)
                  {
                    KsDef _elem97 = new KsDef();
                    _elem97 = new KsDef();
                    _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;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("describe_keyspaces_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 (KsDef _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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_keyspaces_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_cluster_name_args : TBase
    {

      public describe_cluster_name_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("describe_cluster_name_args");
        oprot.WriteStructBegin(struc);
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_cluster_name_args(");
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_cluster_name_result : TBase
    {
      private string _success;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
      }

      public describe_cluster_name_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.String) {
                Success = 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("describe_cluster_name_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_cluster_name_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_version_args : TBase
    {

      public describe_version_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("describe_version_args");
        oprot.WriteStructBegin(struc);
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_version_args(");
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_version_result : TBase
    {
      private string _success;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
      }

      public describe_version_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.String) {
                Success = 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("describe_version_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_version_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_ring_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 describe_ring_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("describe_ring_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("describe_ring_args(");
        sb.Append("Keyspace: ");
        sb.Append(Keyspace);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_ring_result : TBase
    {
      private List<TokenRange> _success;
      private InvalidRequestException _ire;

      public List<TokenRange> 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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool ire;
      }

      public describe_ring_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<TokenRange>();
                  TList _list99 = iprot.ReadListBegin();
                  for( int _i100 = 0; _i100 < _list99.Count; ++_i100)
                  {
                    TokenRange _elem101 = new TokenRange();
                    _elem101 = new TokenRange();
                    _elem101.Read(iprot);
                    Success.Add(_elem101);
                  }
                  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;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("describe_ring_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 (TokenRange _iter102 in Success)
              {
                _iter102.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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_ring_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_partitioner_args : TBase
    {

      public describe_partitioner_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("describe_partitioner_args");
        oprot.WriteStructBegin(struc);
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_partitioner_args(");
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_partitioner_result : TBase
    {
      private string _success;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
      }

      public describe_partitioner_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.String) {
                Success = 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("describe_partitioner_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_partitioner_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_snitch_args : TBase
    {

      public describe_snitch_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("describe_snitch_args");
        oprot.WriteStructBegin(struc);
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_snitch_args(");
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_snitch_result : TBase
    {
      private string _success;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
      }

      public describe_snitch_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.String) {
                Success = 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("describe_snitch_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_snitch_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_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 describe_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("describe_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("describe_keyspace_args(");
        sb.Append("Keyspace: ");
        sb.Append(Keyspace);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_keyspace_result : TBase
    {
      private KsDef _success;
      private NotFoundException _nfe;
      private InvalidRequestException _ire;

      public KsDef Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public NotFoundException Nfe
      {
        get
        {
          return _nfe;
        }
        set
        {
          __isset.nfe = true;
          this._nfe = value;
        }
      }

      public InvalidRequestException Ire
      {
        get
        {
          return _ire;
        }
        set
        {
          __isset.ire = true;
          this._ire = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool nfe;
        public bool ire;
      }

      public describe_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 0:
              if (field.Type == TType.Struct) {
                Success = new KsDef();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                Nfe = new NotFoundException();
                Nfe.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              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("describe_keyspace_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.nfe) {
          if (Nfe != null) {
            field.Name = "Nfe";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            Nfe.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.ire) {
          if (Ire != null) {
            field.Name = "Ire";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            Ire.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_keyspace_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",Nfe: ");
        sb.Append(Nfe== null ? "<null>" : Nfe.ToString());
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_splits_args : TBase
    {
      private string _cfName;
      private string _start_token;
      private string _end_token;
      private int _keys_per_split;

      public string CfName
      {
        get
        {
          return _cfName;
        }
        set
        {
          __isset.cfName = true;
          this._cfName = value;
        }
      }

      public string Start_token
      {
        get
        {
          return _start_token;
        }
        set
        {
          __isset.start_token = true;
          this._start_token = value;
        }
      }

      public string End_token
      {
        get
        {
          return _end_token;
        }
        set
        {
          __isset.end_token = true;
          this._end_token = value;
        }
      }

      public int Keys_per_split
      {
        get
        {
          return _keys_per_split;
        }
        set
        {
          __isset.keys_per_split = true;
          this._keys_per_split = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool cfName;
        public bool start_token;
        public bool end_token;
        public bool keys_per_split;
      }

      public describe_splits_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) {
                CfName = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Start_token = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                End_token = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.I32) {
                Keys_per_split = 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("describe_splits_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (CfName != null && __isset.cfName) {
          field.Name = "cfName";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(CfName);
          oprot.WriteFieldEnd();
        }
        if (Start_token != null && __isset.start_token) {
          field.Name = "start_token";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Start_token);
          oprot.WriteFieldEnd();
        }
        if (End_token != null && __isset.end_token) {
          field.Name = "end_token";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(End_token);
          oprot.WriteFieldEnd();
        }
        if (__isset.keys_per_split) {
          field.Name = "keys_per_split";
          field.Type = TType.I32;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Keys_per_split);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_splits_args(");
        sb.Append("CfName: ");
        sb.Append(CfName);
        sb.Append(",Start_token: ");
        sb.Append(Start_token);
        sb.Append(",End_token: ");
        sb.Append(End_token);
        sb.Append(",Keys_per_split: ");
        sb.Append(Keys_per_split);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class describe_splits_result : TBase
    {
      private List<string> _success;

      public List<string> Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
      }

      public describe_splits_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<string>();
                  TList _list103 = iprot.ReadListBegin();
                  for( int _i104 = 0; _i104 < _list103.Count; ++_i104)
                  {
                    string _elem105 = null;
                    _elem105 = iprot.ReadString();
                    Success.Add(_elem105);
                  }
                  iprot.ReadListEnd();
                }
              } 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("describe_splits_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.String, Success.Count));
              foreach (string _iter106 in Success)
              {
                oprot.WriteString(_iter106);
                oprot.WriteListEnd();
              }
            }
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("describe_splits_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_add_column_family_args : TBase
    {
      private CfDef _cf_def;

      public CfDef Cf_def
      {
        get
        {
          return _cf_def;
        }
        set
        {
          __isset.cf_def = true;
          this._cf_def = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool cf_def;
      }

      public system_add_column_family_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) {
                Cf_def = new CfDef();
                Cf_def.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("system_add_column_family_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Cf_def != null && __isset.cf_def) {
          field.Name = "cf_def";
          field.Type = TType.Struct;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          Cf_def.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_add_column_family_args(");
        sb.Append("Cf_def: ");
        sb.Append(Cf_def== null ? "<null>" : Cf_def.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_add_column_family_result : TBase
    {
      private string _success;
      private InvalidRequestException _ire;

      public string 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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool ire;
      }

      public system_add_column_family_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.String) {
                Success = iprot.ReadString();
              } 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;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("system_add_column_family_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_add_column_family_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_drop_column_family_args : TBase
    {
      private string _column_family;

      public string Column_family
      {
        get
        {
          return _column_family;
        }
        set
        {
          __isset.column_family = true;
          this._column_family = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool column_family;
      }

      public system_drop_column_family_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) {
                Column_family = 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("system_drop_column_family_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Column_family != null && __isset.column_family) {
          field.Name = "column_family";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Column_family);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_drop_column_family_args(");
        sb.Append("Column_family: ");
        sb.Append(Column_family);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_drop_column_family_result : TBase
    {
      private string _success;
      private InvalidRequestException _ire;

      public string 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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool ire;
      }

      public system_drop_column_family_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.String) {
                Success = iprot.ReadString();
              } 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;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("system_drop_column_family_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_drop_column_family_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_add_keyspace_args : TBase
    {
      private KsDef _ks_def;

      public KsDef Ks_def
      {
        get
        {
          return _ks_def;
        }
        set
        {
          __isset.ks_def = true;
          this._ks_def = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool ks_def;
      }

      public system_add_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.Struct) {
                Ks_def = new KsDef();
                Ks_def.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("system_add_keyspace_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Ks_def != null && __isset.ks_def) {
          field.Name = "ks_def";
          field.Type = TType.Struct;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          Ks_def.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_add_keyspace_args(");
        sb.Append("Ks_def: ");
        sb.Append(Ks_def== null ? "<null>" : Ks_def.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_add_keyspace_result : TBase
    {
      private string _success;
      private InvalidRequestException _ire;

      public string 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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool ire;
      }

      public system_add_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 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadString();
              } 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;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("system_add_keyspace_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_add_keyspace_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_drop_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 system_drop_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("system_drop_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("system_drop_keyspace_args(");
        sb.Append("Keyspace: ");
        sb.Append(Keyspace);
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_drop_keyspace_result : TBase
    {
      private string _success;
      private InvalidRequestException _ire;

      public string 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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool ire;
      }

      public system_drop_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 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadString();
              } 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;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("system_drop_keyspace_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_drop_keyspace_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_update_keyspace_args : TBase
    {
      private KsDef _ks_def;

      public KsDef Ks_def
      {
        get
        {
          return _ks_def;
        }
        set
        {
          __isset.ks_def = true;
          this._ks_def = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool ks_def;
      }

      public system_update_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.Struct) {
                Ks_def = new KsDef();
                Ks_def.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("system_update_keyspace_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Ks_def != null && __isset.ks_def) {
          field.Name = "ks_def";
          field.Type = TType.Struct;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          Ks_def.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_update_keyspace_args(");
        sb.Append("Ks_def: ");
        sb.Append(Ks_def== null ? "<null>" : Ks_def.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_update_keyspace_result : TBase
    {
      private string _success;
      private InvalidRequestException _ire;

      public string 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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool ire;
      }

      public system_update_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 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadString();
              } 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;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("system_update_keyspace_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_update_keyspace_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_update_column_family_args : TBase
    {
      private CfDef _cf_def;

      public CfDef Cf_def
      {
        get
        {
          return _cf_def;
        }
        set
        {
          __isset.cf_def = true;
          this._cf_def = value;
        }
      }


      public Isset __isset;
      [Serializable]
      public struct Isset {
        public bool cf_def;
      }

      public system_update_column_family_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) {
                Cf_def = new CfDef();
                Cf_def.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("system_update_column_family_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Cf_def != null && __isset.cf_def) {
          field.Name = "cf_def";
          field.Type = TType.Struct;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          Cf_def.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_update_column_family_args(");
        sb.Append("Cf_def: ");
        sb.Append(Cf_def== null ? "<null>" : Cf_def.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    [Serializable]
    public partial class system_update_column_family_result : TBase
    {
      private string _success;
      private InvalidRequestException _ire;

      public string 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 Isset __isset;
      [Serializable]
      public struct Isset {
        public bool success;
        public bool ire;
      }

      public system_update_column_family_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.String) {
                Success = iprot.ReadString();
              } 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;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("system_update_column_family_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(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();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("system_update_column_family_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",Ire: ");
        sb.Append(Ire== null ? "<null>" : Ire.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }

  }
}